初次提交

flowable-center-dao/src/main/java/com/ho/flow/common/FlowTool.java

@@ -0,0 +1,75 @@
+package com.ho.flow.common;
+
+import com.ho.common.tools.constant.RedisKeyConstant;
+import com.ho.common.tools.exception.BaseResponseCode;
+import com.ho.common.tools.exception.BusinessException;
+import com.ho.common.tools.service.RedisService;
+import com.ho.common.tools.util.CodeUtil;
+import com.ho.flow.constant.WorkOrderConstant;
+import com.ho.flow.mapper.BusiIdControlMapper;
+import com.ho.flow.vo.BusiIdControl;
+import lombok.extern.slf4j.Slf4j;
+import org.redisson.api.RLock;
+import org.redisson.api.RedissonClient;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+/**
+ * @author fancl
+ * @desc:
+ * @date 2023/1/23
+ */
+@Component
+@Slf4j
+public class FlowTool {
+
+    @Autowired
+    RedisService redisService;
+
+    @Autowired
+    BusiIdControlMapper busiMapper;
+
+    @Autowired
+    RedissonClient redissonClient;
+
+    //获取工单id
+    public String getNextWorkOrderId(String type) {
+        //类型必须为已经定义的
+        if (!WorkOrderConstant.IdTypeWorkOrder.equals(type)) {
+            throw new BusinessException(BaseResponseCode.WORK_ORDER_ID_TYPE_NOT_RIGHT);
+        }
+        //定义锁
+        RLock lock = null;
+        //返回的工单号
+        Long id = null;
+        try {
+            lock = redissonClient.getLock(RedisKeyConstant.LOCK_KEY_WORK_ORDER);
+            //获取锁,没有获取到锁的阻塞在lock.lock() 这行
+            lock.lock();
+            BusiIdControl busiIdControl = busiMapper.selectByType(type);
+            //首次直接变为2,因为1已经返回被使用了
+            if (busiIdControl != null) {
+                Long currentValue = busiIdControl.getCurrentValue();
+                id = currentValue;
+                //每次返回数值后+1
+                busiIdControl.setCurrentValue(++currentValue);
+                busiMapper.update(busiIdControl);
+            } else {
+                id = 1L;
+                //没有对象，创建一条记录
+                BusiIdControl busi = new BusiIdControl();
+                busi.setIdType(type);
+                busi.setCurrentValue(2L);
+                busiMapper.insert(busi);
+            }
+        } finally {
+            if (lock != null && lock.isHeldByCurrentThread()) {
+                lock.unlock();
+            }
+        }
+        log.info("工单id: {}", id);
+        String workSn = CodeUtil.getCode(CodeUtil.WORK_ORDER_PREFIX, String.valueOf(id), 10, "0");
+        log.info("工单号: {}", workSn);
+        return workSn;
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/entity/process/ActReDeploymentVO.java

@@ -0,0 +1,25 @@
+package com.ho.flow.entity.process;
+
+import java.util.Date;
+
+
+public class ActReDeploymentVO {
+    private String id;
+    private Date deployTime;
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public Date getDeployTime() {
+        return deployTime;
+    }
+
+    public void setDeployTime(Date deployTime) {
+        this.deployTime = deployTime;
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/entity/process/DefinitionIdDTO.java

@@ -0,0 +1,38 @@
+package com.ho.flow.entity.process;
+
+import io.swagger.annotations.ApiModelProperty;
+import org.activiti.engine.repository.ProcessDefinition;
+
+
+public class DefinitionIdDTO {
+
+    @ApiModelProperty(value = "流程部署id")
+    private String deploymentID;
+
+    @ApiModelProperty(value = "资源名称")
+    private String resourceName;
+
+    public String getDeploymentID() {
+        return deploymentID;
+    }
+
+    public void setDeploymentID(String deploymentID) {
+        this.deploymentID = deploymentID;
+    }
+
+    public String getResourceName() {
+        return resourceName;
+    }
+
+    public void setResourceName(String resourceName) {
+        this.resourceName = resourceName;
+    }
+
+    public DefinitionIdDTO() {
+    }
+
+    public DefinitionIdDTO(ProcessDefinition processDefinition) {
+        this.deploymentID = processDefinition.getDeploymentId();
+        this.resourceName = processDefinition.getResourceName();
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/entity/process/MovementDTO.java

@@ -0,0 +1,23 @@
+package com.ho.flow.entity.process;
+
+import com.ho.flow.vo.Event;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * @Author yule
+ * @Date 2023/9/22 14:59
+ * @desc ${}
+ */
+@Data
+public class MovementDTO {
+
+    private Integer orderType;
+
+    private String userId;
+
+    private Integer priority;
+
+    List<Event> events;
+}

flowable-center-dao/src/main/java/com/ho/flow/entity/process/PreDoUser.java

@@ -0,0 +1,25 @@
+package com.ho.flow.entity.process;
+
+import com.ho.user.api.entity.SysUser;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * @Author yule
+ * @Date 2023/9/4 13:42
+ * @desc ${流转前返回参数}
+ */
+@Data
+public class PreDoUser {
+
+    @ApiModelProperty(value = "岗位名称")
+    String realName;
+
+    @ApiModelProperty(value = "岗位id")
+    Integer id;
+
+    @ApiModelProperty(value = "用户列表")
+    List<SysUser> userList;
+}

flowable-center-dao/src/main/java/com/ho/flow/entity/process/ProcessDefinitionDTO.java

@@ -0,0 +1,148 @@
+package com.ho.flow.entity.process;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import io.swagger.annotations.ApiModelProperty;
+import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntityImpl;
+
+import java.util.Date;
+
+public class ProcessDefinitionDTO  {
+
+
+    @ApiModelProperty(value = "id")
+    private String id;
+
+    @ApiModelProperty(value = "流程名称")
+    private String name;
+
+    @ApiModelProperty(value = "流程key")
+    private String key;
+
+    @ApiModelProperty(value = "版本")
+    private int version;
+
+    @ApiModelProperty(value = "部署id")
+    private String deploymentId;
+
+    @ApiModelProperty(value = "资源名称")
+    private String resourceName;
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty(value = "部署时间")
+    private Date deploymentTime;
+
+    @ApiModelProperty(value = "流程实例状态 1 激活 2 挂起 ")
+    private Integer suspendState;
+
+    @ApiModelProperty(value = "第几页")
+    private Integer pageNum=1;
+
+    @ApiModelProperty(value = "分页数量")
+    private Integer pageSize=10;
+
+    @ApiModelProperty(value = "租户id")
+    private String tenantId;
+
+    public ProcessDefinitionDTO() {
+    }
+
+    public ProcessDefinitionDTO(ProcessDefinitionEntityImpl processDefinition, ActReDeploymentVO actReDeploymentVO) {
+        this.tenantId = processDefinition.getTenantId();
+        this.id = processDefinition.getId();
+        this.name = processDefinition.getName();
+        this.key = processDefinition.getKey();
+        this.version = processDefinition.getVersion();
+        this.deploymentId = processDefinition.getDeploymentId();
+        this.resourceName = processDefinition.getResourceName();
+        this.deploymentTime = actReDeploymentVO.getDeployTime();
+        this.suspendState = processDefinition.getSuspensionState();
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getKey() {
+        return key;
+    }
+
+    public void setKey(String key) {
+        this.key = key;
+    }
+
+    public int getVersion() {
+        return version;
+    }
+
+    public void setVersion(int version) {
+        this.version = version;
+    }
+
+    public String getDeploymentId() {
+        return deploymentId;
+    }
+
+    public void setDeploymentId(String deploymentId) {
+        this.deploymentId = deploymentId;
+    }
+
+    public String getResourceName() {
+        return resourceName;
+    }
+
+    public void setResourceName(String resourceName) {
+        this.resourceName = resourceName;
+    }
+
+    public Date getDeploymentTime() {
+        return deploymentTime;
+    }
+
+    public void setDeploymentTime(Date deploymentTime) {
+        this.deploymentTime = deploymentTime;
+    }
+
+    public Integer getSuspendState() {
+        return suspendState;
+    }
+
+    public void setSuspendState(Integer suspendState) {
+        this.suspendState = suspendState;
+    }
+
+    public Integer getPageNum() {
+        return pageNum;
+    }
+
+    public void setPageNum(Integer pageNum) {
+        this.pageNum = pageNum;
+    }
+
+    public Integer getPageSize() {
+        return pageSize;
+    }
+
+    public void setPageSize(Integer pageSize) {
+        this.pageSize = pageSize;
+    }
+
+    public String getTenantId() {
+        return tenantId;
+    }
+
+    public void setTenantId(String tenantId) {
+        this.tenantId = tenantId;
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/entity/process/TaskOrderInfo.java

@@ -0,0 +1,45 @@
+package com.ho.flow.entity.process;
+
+import com.ho.common.tools.entity.OrderForm;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+/**
+ * @Author yule
+ * @Date 2023/9/5 16:25
+ * @desc ${工作流任务详情返回对象}
+ */
+@Data
+public class TaskOrderInfo {
+
+    @ApiModelProperty(value = "工单标题")
+    String title;
+
+    @ApiModelProperty(value = "任务code")
+    String code;
+
+    @ApiModelProperty(value = "工单表单对象")
+    OrderForm orderForm;
+
+    @ApiModelProperty(value = "流转按钮: 0:不显示 1:流转  2 同意(流转)/拒绝")
+    Integer circulation;
+
+    @ApiModelProperty(value = "接收按钮")
+    Boolean  accept;
+
+    @ApiModelProperty(value = "回退按钮")
+    Boolean back;
+
+    @ApiModelProperty(value = "作废按钮")
+    Boolean cancel;
+
+    @ApiModelProperty(value = "转发按钮")
+    Boolean forward;
+
+    @ApiModelProperty(value = "流转选人按钮")
+    Boolean user;
+
+    @ApiModelProperty(value = "修改标题")
+    Boolean updateTitle;
+
+}

flowable-center-dao/src/main/java/com/ho/flow/factory/Factory.java

@@ -0,0 +1,16 @@
+package com.ho.flow.factory;
+
+import java.util.concurrent.ThreadFactory;
+
+public class Factory implements ThreadFactory {
+    /**
+     * 该方法用来创建线程
+     * @param r
+     * @return
+     */
+    @Override
+    public Thread newThread(Runnable r) {
+        Thread newThread = new Thread(r);
+        return newThread;
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/factory/ThreadRejectedExecutionHandler.java

@@ -0,0 +1,64 @@
+package com.ho.flow.factory;
+
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.RejectedExecutionHandler;
+import java.util.concurrent.ThreadPoolExecutor;
+
+/**
+ * @author catkins
+ */
+public class ThreadRejectedExecutionHandler implements RejectedExecutionHandler{
+    @Override
+    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {}
+
+    /**
+     * 饱和策略一：调用者线程执行策略
+     * 在该策略下，在调用者中执行被拒绝任务的run方法。除非线程池showdown，否则直接丢弃线程
+     */
+    public static class CallerRunsPolicy extends ThreadRejectedExecutionHandler {
+        @Override
+        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
+            //判断线程池是否在正常运行，如果线程池在正常运行则由调用者线程执行被拒绝的任务。如果线程池停止运行，则直接丢弃该任务
+            if (!executor.isShutdown()){
+                r.run();
+            }
+        }
+    }
+
+
+    /**
+     * 饱和策略二：终止策略
+     * 在该策略下，丢弃被拒绝的任务，并抛出拒绝执行异常
+     */
+    public static class AbortPolicy extends ThreadRejectedExecutionHandler {
+        @Override
+        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
+            throw new RejectedExecutionException("请求任务：" + r.toString() + "，线程池负载过高执行饱和终止策略！");
+        }
+    }
+
+
+    /**
+     * 饱和策略三：丢弃策略
+     * 在该策略下，什么都不做直接丢弃被拒绝的任务
+     */
+    public static class DiscardPolicy extends ThreadRejectedExecutionHandler {
+        @Override
+        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {}
+    }
+
+    /**
+     * 饱和策略四：弃老策略
+     * 在该策略下，丢弃最早放入阻塞队列中的线程，并尝试将拒绝任务加入阻塞队列
+     */
+    public static class DiscardOldestPolicy extends ThreadRejectedExecutionHandler {
+        @Override
+        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
+            //判断线程池是否正常运行，如果线程池正常运行则弹出（或丢弃）最早放入阻塞队列中的任务，并尝试将拒绝任务加入阻塞队列。如果线程池停止运行，则直接丢弃该任务
+            if (!executor.isShutdown()){
+                executor.getQueue().poll();
+                executor.execute(r);
+            }
+        }
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/feignclient/BusinessFeignClient.java

@@ -0,0 +1,85 @@
+package com.ho.flow.feignclient;
+
+import com.ho.business.entity.*;
+import com.ho.business.vo.req.DeviceReqVO;
+import com.ho.business.vo.req.EventColReq;
+import com.ho.business.vo.req.StationPageReqVO;
+import com.ho.business.vo.req.device.DeviceListReq;
+import com.ho.business.vo.req.device.DeviceTypeQuery;
+import com.ho.business.vo.req.deviceTypeCol.DeviceTypeColQueryVo;
+import com.ho.business.vo.req.inspectionFault.InspectionFaultVo;
+import com.ho.business.vo.resp.DeviceRespVO;
+import com.ho.common.tools.constant.ContextConstant;
+import com.ho.common.tools.exception.DataResult;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+
+import java.util.List;
+import java.util.Map;
+
+
+@FeignClient(value = ContextConstant.BUSINESS_SERVICE, fallback = BusinessFeignClientFallback.class)
+public interface BusinessFeignClient {
+
+    // 根据部门id查电站集合
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT +ContextConstant.BUSINESS + "outerApi/selectByStationIds")
+    DataResult<List<Station>> selectByStationIds(@RequestBody List<Integer> ids);
+
+    // 查询全部电站
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT +ContextConstant.BUSINESS + "outerApi/selectStationSNAll")
+    DataResult<List<Station>> selectStationSNAll();
+
+    // 根据分组id查电站集合
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT +ContextConstant.BUSINESS + "outerApi/selectByGroupId")
+    DataResult<List<Station>> selectByGroupId(@RequestBody Integer group);
+
+    // 根据电站id查电站
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT +ContextConstant.BUSINESS + "outerApi/selectByStationId")
+     DataResult<Station> selectByStationId(@RequestBody Integer id);
+
+    // 根据条件查询电站信息
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT +ContextConstant.BUSINESS + "outerApi/selectStationByCondition")
+    DataResult<List<Station>> selectStationByCondition(@RequestBody StationPageReqVO vo);
+
+    // 根据设备id查设备
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT +ContextConstant.BUSINESS + "outerApi/selectByDeviceId")
+    DataResult<Device> selectByDeviceId(@RequestBody Integer id);
+
+    // 根据设备id查电站
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT +ContextConstant.BUSINESS + "outerApi/selectByDeviceIds")
+    DataResult<List<DeviceRespVO>> selectByDeviceIds(@RequestBody List<Integer> ids);
+
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT +ContextConstant.BUSINESS + "outerApi/selectByStationIdAndSrcId")
+    DataResult<List<DeviceRespVO>> selectDeviceByStationIdsAndSrcId(@RequestBody Map<Integer, List<Integer>> map);
+
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT +ContextConstant.BUSINESS + "outerApi/selectDeviceByStationIdsAndSrcIdVirtual")
+    DataResult<List<Device>> selectDeviceByStationIdsAndSrcIdVirtual(@RequestBody DeviceListReq deviceListReq);
+
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT +ContextConstant.BUSINESS + "outerApi/selectDeviceByDeviceType")
+    DataResult<List<DeviceRespVO>> selectDeviceByDeviceType(@RequestBody String deviceType);
+
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT +ContextConstant.BUSINESS + "outerApi/getQueryEventParam")
+    List<EventColReq> getQueryEventParam(@RequestBody DeviceListReq deviceListReq);
+
+    //根据pid获取设备类型
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT +ContextConstant.BUSINESS +"outerApi/getDeviceTypeOne")
+     DataResult<DeviceType> selectByPId(@RequestBody Integer pid);
+
+    //根据pid获取设备类型
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT +ContextConstant.BUSINESS +"outerApi/getDeviceTypes")
+    DataResult<List<DeviceType>> getDeviceTypes(@RequestBody List<Integer> deviceIds);
+
+    //根据电站id查电站
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT +ContextConstant.BUSINESS + "outerApi/selectDeviceByStationIds")
+    DataResult<List<Device>> selectDeviceByStationIds(@RequestBody DeviceReqVO deviceReqVO);
+
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT +ContextConstant.BUSINESS + "outerApi/getDeviceTypeConfigList")
+    List<DeviceTypeConfig> getDeviceTypeConfigList(@RequestBody DeviceTypeQuery deviceTypeQuery);
+
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT +ContextConstant.BUSINESS + "outerApi/selectDeviceTypeCol")
+    List<DeviceTypeCol> selectDeviceTypeCol(DeviceTypeColQueryVo vo);
+
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT +ContextConstant.BUSINESS + "outerApi/updateInspectionFault")
+    DataResult updateInspectionFault(@RequestBody InspectionFaultVo vo);
+}

flowable-center-dao/src/main/java/com/ho/flow/feignclient/BusinessFeignClientFallback.java

@@ -0,0 +1,128 @@
+package com.ho.flow.feignclient;
+
+import com.ho.business.entity.*;
+import com.ho.business.vo.req.DeviceReqVO;
+import com.ho.business.vo.req.EventColReq;
+import com.ho.business.vo.req.StationPageReqVO;
+import com.ho.business.vo.req.device.DeviceListReq;
+import com.ho.business.vo.req.device.DeviceTypeQuery;
+import com.ho.business.vo.req.deviceTypeCol.DeviceTypeColQueryVo;
+import com.ho.business.vo.req.inspectionFault.InspectionFaultVo;
+import com.ho.business.vo.resp.DeviceRespVO;
+import com.ho.common.tools.exception.BaseResponseCode;
+import com.ho.common.tools.exception.BusinessException;
+import com.ho.common.tools.exception.DataResult;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.Map;
+
+
+@Component
+@Slf4j
+public class BusinessFeignClientFallback implements BusinessFeignClient {
+
+    @Override
+    public DataResult<List<Station>> selectByStationIds(List<Integer> ids) {
+        log.error("调用 [BusinessClient.selectByStationIds] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<List<Station>> selectStationSNAll() {
+        log.error("调用 [BusinessClient.selectStationSNAll] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<List<Station>> selectByGroupId(Integer group) {
+        log.error("调用 [BusinessClient.selectByGroupId] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<Station> selectByStationId(Integer id) {
+        log.error("调用 [BusinessClient.selectByStationId] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<List<Station>> selectStationByCondition(StationPageReqVO vo) {
+        log.error("调用 [BusinessClient.selectStationByCondition] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<Device> selectByDeviceId(Integer id) {
+        log.error("调用 [BusinessClient.selectByDeviceId] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<List<DeviceRespVO>> selectDeviceByStationIdsAndSrcId(Map<Integer, List<Integer>> map) {
+        log.error("调用 [BusinessClient.selectDeviceByStationIdsAndSrcId] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<List<Device>> selectDeviceByStationIdsAndSrcIdVirtual(DeviceListReq deviceListReq) {
+        log.error("调用 [BusinessClient.selectDeviceByStationIdsAndSrcIdVirtual] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<List<DeviceRespVO>> selectDeviceByDeviceType(String deviceType) {
+        log.error("调用 [BusinessClient.selectDeviceByDeviceType] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public List<EventColReq> getQueryEventParam(DeviceListReq deviceListReq) {
+        log.error("调用 [BusinessClient.getQueryEventParam] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<List<DeviceRespVO>> selectByDeviceIds(List<Integer> ids) {
+        log.error("调用 [BusinessClient.selectByDeviceIds] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<DeviceType> selectByPId(Integer pid) {
+        log.error("调用 [BusinessClient.selectByPId] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<List<DeviceType>> getDeviceTypes(List<Integer> deviceIds) {
+        log.error("调用 [BusinessClient.getDeviceTypes] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<List<Device>> selectDeviceByStationIds(DeviceReqVO deviceReqVO) {
+        log.error("调用 [BusinessClient.selectDeviceByStationIds] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public List<DeviceTypeConfig> getDeviceTypeConfigList(DeviceTypeQuery deviceTypeQuery) {
+        log.error("调用 [BusinessClient.getDeviceTypeConfigList] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public List<DeviceTypeCol> selectDeviceTypeCol(DeviceTypeColQueryVo vo) {
+        log.error("调用 [BusinessClient.selectDeviceTypeCol] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult updateInspectionFault(InspectionFaultVo vo) {
+        log.error("调用 [BusinessClient.updateInspectionFault] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+}

flowable-center-dao/src/main/java/com/ho/flow/feignclient/UserFeignClient.java

@@ -0,0 +1,82 @@
+package com.ho.flow.feignclient;
+
+import com.ho.common.tools.constant.ContextConstant;
+import com.ho.common.tools.entity.OrderDept;
+import com.ho.common.tools.exception.DataResult;
+import com.ho.user.api.entity.SysDept;
+import com.ho.user.api.entity.SysLog;
+import com.ho.user.api.entity.SysSubDict;
+import com.ho.user.api.entity.SysUser;
+import com.ho.user.api.vo.req.OrderUserSelectReqVo;
+import com.ho.user.api.vo.req.QueryDeptReqVO;
+import com.ho.user.api.vo.req.QueryUserReqVO;
+import com.ho.user.api.vo.req.SysSubDictVO;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @描述 调用user-center
+ * @创建时间 2021/8/9
+ * @修改人
+ */
+@FeignClient(value = ContextConstant.USER_CENTER, fallback = UserFeignClientFallback.class)
+public interface UserFeignClient {
+
+    // 根据部门id查对象
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT + "outerApi/getTopDept")
+    DataResult<SysDept> getTopDept(@RequestBody QueryDeptReqVO vo);
+
+    // 根据部门id查对象
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT + "outerApi/getDept")
+    DataResult<List<SysDept>> queryDept(@RequestBody List<QueryDeptReqVO> queryDeptReqVOs);
+
+    //根据用户id查询用户
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT + "outerApi/getUserById")
+    DataResult<SysUser>  getUserById(String userId);
+
+    //根据用户id查询用户
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT + "outerApi/getUserByIds")
+    DataResult<List<SysUser>> getUserByIds(Set<String> userIds);
+
+    //根据用户查询条件查询用户
+    @PostMapping(value = "/api/outerApi/getUsers")
+    DataResult<List<SysUser>> queryUser(@RequestBody List<QueryUserReqVO> queryUserReqVO);
+
+    //根据用户名模糊 查询用户
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT + "outerApi/getUserByNameConcat")
+    DataResult<List<SysUser>> getUserByNameConcat(@RequestBody QueryUserReqVO queryUserReqVO);
+
+    //发送用户中心日志
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT + "outerApi/insertLog")
+    DataResult insertLog(@RequestBody SysLog sysLog);
+
+    //根据postCodes 进行模糊查询 得到岗位id后进行人员和查询
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT + "outerApi/selectByPostCodeTree")
+    DataResult<List<OrderDept>> selectByPostCodeTree(OrderUserSelectReqVo vo);
+
+    //根据字典子表id查询到字典子表对象
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT + "outerApi/selectBySubId")
+    DataResult<SysSubDict> getDictById(@RequestBody Integer priority);
+
+    //根据postCodes 进行模糊查询 得到岗位id后进行人员和查询
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT + "outerApi/selectAllPostUser")
+    DataResult<List<SysUser>> selectAllPostUser();
+
+    //根据postCodes 进行模糊查询 得到岗位id后进行人员和查询
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT + "outerApi/selectByPostIds")
+    DataResult<List<SysUser>> selectByPostIds(@RequestBody  List<Integer> postIds);
+
+    //查询字典
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT + "outerApi/getSysSubDict")
+    Map<String, String> getSysSubDict(@RequestBody SysSubDictVO vo);
+
+    //根据字典子表id集合查询到字典子表对象
+    @PostMapping(value = ContextConstant.ROOT_CONTEXT + "outerApi/selectBySubIds")
+    DataResult<List<SysSubDict>> getDictByIds(@RequestBody List<Integer> Ids);
+}
+

flowable-center-dao/src/main/java/com/ho/flow/feignclient/UserFeignClientFallback.java

@@ -0,0 +1,114 @@
+package com.ho.flow.feignclient;
+
+import com.ho.common.tools.exception.BaseResponseCode;
+import com.ho.common.tools.exception.BusinessException;
+import com.ho.common.tools.exception.DataResult;
+import com.ho.user.api.entity.SysDept;
+import com.ho.user.api.entity.SysLog;
+import com.ho.user.api.entity.SysSubDict;
+import com.ho.user.api.entity.SysUser;
+import com.ho.user.api.vo.req.OrderUserSelectReqVo;
+import com.ho.user.api.vo.req.QueryDeptReqVO;
+import com.ho.user.api.vo.req.QueryUserReqVO;
+import com.ho.common.tools.entity.OrderDept;
+import com.ho.user.api.vo.req.SysSubDictVO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @描述 UserClient失败回调
+ * @创建时间 2021/8/9
+ * @修改人
+ */
+@Component
+public class UserFeignClientFallback implements UserFeignClient {
+
+    Logger log = LoggerFactory.getLogger(getClass());
+
+    @Override
+    public DataResult<SysDept> getTopDept(QueryDeptReqVO vo) {
+        log.error("调用 [UserClient.getTopDept] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<List<SysDept>> queryDept(@RequestBody List<QueryDeptReqVO> queryDeptReqVO) {
+        log.error("调用 [UserClient.queryDept] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<SysUser> getUserById(String userId) {
+        log.error("调用 [UserClient.getUserById] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<List<SysUser>> getUserByIds(Set<String> userIds) {
+        log.error("调用 [UserClient.getUserByIds] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @PostMapping("/api/outerApi/getUsers")
+    @Override
+    public DataResult<List<SysUser>> queryUser(List<QueryUserReqVO> queryUserReqVO) {
+        log.error("调用 [UserClient.queryUser] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    //用户名查询多个
+    @Override
+    public DataResult<List<SysUser>> getUserByNameConcat(QueryUserReqVO queryUserReqVO) {
+        log.error("调用 [UserClient.getUserByNameConcat] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult insertLog(SysLog sysLog) {
+        log.error("调用 [UserClient.insertLog] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<List<OrderDept>> selectByPostCodeTree(OrderUserSelectReqVo vo) {
+        log.error("调用 [UserClient.selectByPostCodeTree] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<SysSubDict> getDictById(Integer priority) {
+        log.error("调用 [UserClient.getDictById] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<List<SysUser>> selectByPostIds(List<Integer> postIds) {
+        log.error("调用 [UserClient.selectByPostIds] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<List<SysUser>> selectAllPostUser() {
+        log.error("调用 [UserClient.selectAllPostUser] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public Map<String, String> getSysSubDict(SysSubDictVO vo) {
+        log.error("调用 [UserClient.getSysSubDict] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+
+    @Override
+    public DataResult<List<SysSubDict>> getDictByIds(List<Integer> Ids) {
+        log.error("调用 [UserClient.getDictByIds] 异常!");
+        throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL);
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/listener/Node1Listener.java

@@ -0,0 +1,43 @@
+package com.ho.flow.listener;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.ho.flow.constant.WorkOrderConstant;
+import lombok.extern.slf4j.Slf4j;
+import org.activiti.engine.delegate.DelegateTask;
+import org.activiti.engine.delegate.TaskListener;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author fancl
+ * @desc: 第一节点监听, 设置候选人
+ * @date 2023/2/4
+ */
+@Slf4j
+public class Node1Listener implements TaskListener {
+
+    @Override
+    public void notify(DelegateTask delegateTask) {
+        Map<String, Object> variables = delegateTask.getVariables();
+        Object nodeUsers = delegateTask.getVariableLocal(WorkOrderConstant.CandidateUser.nodeOneUsers);
+        String name = delegateTask.getName();
+        String processInstanceId = delegateTask.getProcessInstanceId();
+        log.info("当前任务名:{}, 流程实例:{}", name, processInstanceId);
+        log.info("Node1Listener 监听得到的 variables:" + variables);
+        //
+        String variableKey = WorkOrderConstant.CandidateUser.nodeOneUsers;
+        List<String> candisUserList = new ArrayList<>();
+        if (nodeUsers !=null && nodeUsers instanceof ArrayNode) {
+            ArrayNode candiUsers = (ArrayNode) nodeUsers;
+            for (JsonNode candiUser : candiUsers) {
+                String user = candiUser.asText();
+                candisUserList.add(user);
+            }
+            delegateTask.addCandidateUsers(candisUserList);
+            log.info("New add candidate user:" + candisUserList);
+        }
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/listener/Node2Listener.java

@@ -0,0 +1,41 @@
+package com.ho.flow.listener;
+
+import com.ho.flow.constant.WorkOrderConstant;
+import lombok.extern.slf4j.Slf4j;
+import org.activiti.engine.delegate.DelegateTask;
+import org.activiti.engine.delegate.TaskListener;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author fancl
+ * @desc: 第2节点监听, 设置候选人
+ * @date 2023/2/4
+ */
+@Slf4j
+public class Node2Listener implements TaskListener {
+
+    @Override
+    public void notify(DelegateTask delegateTask) {
+        Map<String, Object> variables = delegateTask.getVariables();
+        Object variableLocal = delegateTask.getVariableLocal(WorkOrderConstant.CandidateUser.nodeOneUsers);
+        String name = delegateTask.getName();
+        String processInstanceId = delegateTask.getProcessInstanceId();
+        log.info("当前任务名:{}, 流程实例:{}", name, processInstanceId);
+        log.info("Node2Listener 监听得到的 variables:" + variables);
+        //
+        String variableKey = WorkOrderConstant.CandidateUser.nodeTwoUsers;
+        if (variables.containsKey(variableKey)) {
+            try {
+                List<String> toUsers = (List<String>) variables.get(variableKey);
+                delegateTask.addCandidateUsers(toUsers);
+                log.info("New add candidate user:" + toUsers);
+            } catch (Exception e) {
+                log.error("Node2Listener 出错");
+                log.error(e.getMessage());
+            }
+
+        }
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/listener/Node3Listener.java

@@ -0,0 +1,41 @@
+package com.ho.flow.listener;
+
+import com.ho.flow.constant.WorkOrderConstant;
+import lombok.extern.slf4j.Slf4j;
+import org.activiti.engine.delegate.DelegateTask;
+import org.activiti.engine.delegate.TaskListener;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author fancl
+ * @desc: 第3节点监听, 设置候选人
+ * @date 2023/2/4
+ */
+@Slf4j
+public class Node3Listener implements TaskListener {
+
+    @Override
+    public void notify(DelegateTask delegateTask) {
+        Object variableLocal = delegateTask.getVariableLocal(WorkOrderConstant.CandidateUser.nodeThreeUsers);
+        Map<String, Object> variables = delegateTask.getVariables();
+        String name = delegateTask.getName();
+        String processInstanceId = delegateTask.getProcessInstanceId();
+        log.info("当前任务名:{}, 流程实例:{}", name, processInstanceId);
+        log.info("Node3Listener 监听得到的 variables:" + variables);
+        //
+        String variableKey = WorkOrderConstant.CandidateUser.nodeThreeUsers;
+        if (variables.containsKey(variableKey)) {
+            try {
+                List<String> toUsers = (List<String>) variables.get(variableKey);
+                delegateTask.addCandidateUsers(toUsers);
+                log.info("New add candidate user:" + toUsers);
+            } catch (Exception e) {
+                log.error("Node3Listener 出错");
+                log.error(e.getMessage());
+            }
+
+        }
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/mapper/ActReDeploymentMapper.java

@@ -0,0 +1,17 @@
+package com.ho.flow.mapper;
+
+
+import com.ho.flow.entity.process.ActReDeploymentVO;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+import java.util.Set;
+
+
+@Mapper
+public interface ActReDeploymentMapper {
+
+        public List<ActReDeploymentVO> selectActReDeploymentByIds(@Param("ids") Set<String> ids);
+
+}

flowable-center-dao/src/main/java/com/ho/flow/mapper/AlarmConfigMapper.java

@@ -0,0 +1,43 @@
+package com.ho.flow.mapper;
+
+
+import com.ho.flow.vo.AlarmConfig;
+import com.ho.flow.vo.req.AlarmConfig.AlarmConfigPageReqVo;
+import com.ho.flow.vo.req.AlarmConfig.AlarmQuery;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+* @author gyan
+* @description 针对表【alarm_config】的数据库操作Mapper
+* @createDate 2023-02-01 17:15:01
+*/
+@Mapper
+public interface AlarmConfigMapper {
+
+    int insert(@Param("record") AlarmConfig alarmConfig);
+
+    int insertBatch(@Param("list") List<AlarmConfig> list);
+
+    int updateByPrimaryKeySelective(@Param("record") AlarmConfig alarmConfig);
+
+    int updateBatch(@Param("list") List<AlarmConfig> list);
+
+    AlarmConfig selectById(@Param("id") Integer id);
+
+    List<AlarmConfig> selectList(@Param("record") AlarmConfigPageReqVo vo);
+
+    List<AlarmConfig> selectRepeatValue(AlarmQuery alarmQuery);
+
+    List<AlarmConfig> selectListByParams(@Param("stationId") Integer stationId, @Param("deviceType") String deviceType);
+
+    int deleteByPrimaryKey(Integer id);
+
+    int deleteByParam(Integer stationId,String deviceType);
+
+    int deleteBatch(@Param("list") List<Integer> idList);
+
+    int updateByParams(@Param("record") AlarmConfig alarmConfig);
+}

flowable-center-dao/src/main/java/com/ho/flow/mapper/BusiIdControlMapper.java

@@ -0,0 +1,19 @@
+package com.ho.flow.mapper;
+
+import com.ho.flow.vo.BusiIdControl;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * @author fancl
+ * @desc: id控制Mapper
+ * @date 2022/10/14
+ */
+@Mapper
+public interface BusiIdControlMapper {
+
+    BusiIdControl selectByType(String idType);
+
+    int insert(BusiIdControl busiIdControl);
+
+    int update(BusiIdControl busiIdControl);
+}

flowable-center-dao/src/main/java/com/ho/flow/mapper/DeviceColDefineMapper.java

@@ -0,0 +1,41 @@
+package com.ho.flow.mapper;
+
+import com.ho.flow.vo.DeviceColDefine;
+import com.ho.flow.vo.req.AlarmConfig.DeviceColDefineReqVo;
+import com.ho.flow.vo.req.devicecoldefine.DeviceColDefineDeleteVO;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * @author gyan
+ * @desc:
+ * @DateTime: 2023/2/1 16:48
+ */
+@Mapper
+public interface DeviceColDefineMapper {
+
+    List<DeviceColDefine> selectPage(DeviceColDefineReqVo definePageReq);
+
+    DeviceColDefine selectById(@Param("id") Integer id);
+
+    List<DeviceColDefine> selectByIdList(@Param("ids") List<Integer> ids, @Param("deviceType") String deviceType);
+
+    DeviceColDefine selectByIdAndDeviceTypeId(@Param("id")Integer id, @Param("deviceTypeId")Integer deviceTypeId);
+
+    int insertList(@Param("list") List<DeviceColDefine> list);
+
+    int updateList(@Param("list") List<DeviceColDefine> list);
+
+    int insertDeviceColDefine(DeviceColDefine vo);
+
+    int updateDeviceColDefine(DeviceColDefine vo);
+
+    int deleteDeviceColDefine(List<Integer> ids);
+
+    DeviceColDefine selectByColAndDeviceType(String col, String deviceType);
+
+    List<DeviceColDefine> selectByDeviceType(String str);
+
+}

flowable-center-dao/src/main/java/com/ho/flow/mapper/EventMapper.java

@@ -0,0 +1,76 @@
+package com.ho.flow.mapper;
+
+
+import com.ho.common.tools.entity.UserDetailRespVO;
+import com.ho.flow.vo.Event;
+import com.ho.flow.vo.req.AlarmConfig.AlarmConfigQueryVo;
+import com.ho.flow.vo.req.event.EventNumReq;
+import com.ho.flow.vo.req.event.EventReqPageVO;
+import com.ho.flow.vo.resp.event.EventDayNum;
+import com.ho.flow.vo.resp.event.EventLevelNum;
+import com.ho.flow.vo.resp.event.EventRespVO;
+import com.ho.flow.vo.resp.event.EventTypeNum;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+* @author yule
+* @description 针对表【event】的数据库操作Mapper
+* @createDate 2022-08-29 10:19:50
+* @Entity com.ho.business.entity.Event
+*/
+@Mapper
+public interface EventMapper {
+
+    int deleteByPrimaryKey(Long id);
+
+    int insert(Event record);
+
+    int insertSelective(Event record);
+
+    int insertBatch(@Param("list") List<Event> events);
+
+    int updateBatchById(@Param("event") Event event);
+
+    Event selectByPrimaryKey(Long id);
+
+    int updateByPrimaryKeySelective(Event record);
+
+    int updateByPrimaryKey(Event record);
+
+    List<EventRespVO> selectByInfo(@Param("record") EventReqPageVO vo, @Param("depts") List<Integer> depts );
+
+    int selectCountStatusByInfo(@Param("record") EventReqPageVO vo);
+
+     int updateByIds(@Param("ids")List<Long> ids, @Param("userDetail")UserDetailRespVO userDetail);
+
+    List<EventTypeNum>  selectNumByType(@Param("record")EventReqPageVO vo, @Param("depts") List<Integer> depts );
+
+    List<EventLevelNum> selectNumByLevel(@Param("record")EventReqPageVO vo, @Param("depts") List<Integer> depts );
+
+    List<Event> selectByIds(@Param("list") List<Long> eventIds);
+
+    Event selectByParams(@Param("stationId") Integer stationId,@Param("targetDevice") Integer targetDevice,@Param("signal") String signal,@Param("isRecovery") Integer isRecovery);
+
+    Event selectByParam(@Param("vo") Event vo);
+
+    List<Event> selectByTargetDevice(@Param("alarmConfigQueryVo") AlarmConfigQueryVo alarmConfigQueryVo);
+
+    void setRemarkByIds(List<Long> ids);
+
+    Event selectLastTime(@Param("alarmConfigQueryVo") AlarmConfigQueryVo alarmConfigQueryVo);
+
+    //根据告警恢复查询告警故障
+    Event selectByBeforeEventId(Long beforeEventId);
+
+    List<Event> selectByTargetDeviceAsc(@Param("alarmConfigQueryVo") AlarmConfigQueryVo alarmConfigQueryVo);
+
+    //根据天统计告警数目
+    List<EventDayNum> countEventByDay(@Param("record")EventReqPageVO vo, @Param("depts") List<Integer> depts );
+
+    int deleteByParam(@Param("vo") Event vo);
+
+    List<Integer> eventDeviceNum(@Param("vo") EventNumReq vo);
+}

flowable-center-dao/src/main/java/com/ho/flow/mapper/OrderFormMapper.java

@@ -0,0 +1,46 @@
+package com.ho.flow.mapper;
+
+import com.ho.common.tools.entity.OrderForm;
+import com.ho.common.tools.entity.file.OrderFile;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.List;
+
+/**
+ * @Author yule
+ * @Date 2023/9/7 10:48
+ * @desc ${}
+ */
+@Mapper
+public interface OrderFormMapper {
+
+    //根据路程id查询表单对象
+    OrderForm selectByProcessInstanceId(String processInstanceId);
+
+    //新增表数据
+    int insertOrderFormOne(OrderForm orderForm);
+
+    //新增表单文件数据
+    int insertOrderFileOne(OrderFile orderFile);
+
+    //根据用户id查询表单数据
+    OrderForm selectByUserId(String userId);
+
+    //根据用户id查询表单数据
+    OrderForm selectByOrderId(Integer orderFormId);
+
+    List<OrderForm> selectFinishByUserId(String userId);
+
+    void updateStatus(OrderForm orderForm);
+
+    //修改表单数据
+    void update(OrderForm orderForm);
+
+    void deleteFile(Integer orderFormId);
+
+    List<OrderForm> getInspectionOrders(Integer stationId);
+
+    //根据用户id查询表单数据
+    List<OrderForm> selectOrderFormList(String userId);
+
+}

flowable-center-dao/src/main/java/com/ho/flow/mapper/ProcessManagementMapper.java

@@ -0,0 +1,27 @@
+package com.ho.flow.mapper;
+
+import com.ho.flow.entity.ProcessTemplate;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.List;
+
+/**
+ * @Author yule
+ * @Date 2023/8/18 9:24
+ * @desc ${}
+ */
+@Mapper
+public interface ProcessManagementMapper {
+
+    int insert(ProcessTemplate processTemplate);
+
+    List<ProcessTemplate> selectList(ProcessTemplate processTemplate);
+
+    ProcessTemplate selectById(Integer id);
+
+    void update(ProcessTemplate processTemplate);
+
+    void delete(Integer id);
+
+    String selectBpmnById(Integer id);
+}

flowable-center-dao/src/main/java/com/ho/flow/mapper/ProcessTemplateMapper.java

@@ -0,0 +1,32 @@
+package com.ho.flow.mapper;
+
+import com.ho.flow.entity.ProcessTemplate;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.List;
+
+/**
+* @author yule
+* @description 针对表【process_template】的数据库操作Mapper
+* @createDate 2023-08-17 10:45:32
+* @Entity com.ho.flow.entity.ProcessTemplate
+*/
+@Mapper
+public interface ProcessTemplateMapper {
+
+    int insert(ProcessTemplate processTemplate);
+
+    List<ProcessTemplate> selectList(ProcessTemplate processTemplate);
+
+    ProcessTemplate selectById(Integer id);
+
+    void update(ProcessTemplate processTemplate);
+
+    void delete(Integer id);
+
+    String selectBpmnById(Integer id);
+}
+
+
+
+

flowable-center-dao/src/main/java/com/ho/flow/mapper/SendSmsConfigMapper.java

@@ -0,0 +1,28 @@
+package com.ho.flow.mapper;
+
+import com.ho.flow.entity.SendSmsConfig;
+import com.ho.flow.vo.req.SendSmsConfig.SendSmsConfigQueryReq;
+import com.ho.flow.vo.resp.SendSmsConfig.SendSmsConfigRsp;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+@Mapper
+public interface SendSmsConfigMapper {
+
+    List<SendSmsConfigRsp> selectList(@Param("vo") SendSmsConfigQueryReq vo);
+
+    void insertList(List<SendSmsConfig> list);
+
+    int updateById(@Param("vo")SendSmsConfig vo);
+
+    /**
+     * 更加userId更新短信配置中用户信息
+     * @param vo
+     * @return
+     */
+    int updateByUserId(@Param("vo")SendSmsConfig vo);
+
+    int deleteBatch(@Param("ids")List<Integer> ids);
+}

flowable-center-dao/src/main/java/com/ho/flow/mapper/WorkOrderCirculationMapper.java

@@ -0,0 +1,29 @@
+package com.ho.flow.mapper;
+
+import com.ho.flow.vo.WorkOrderCirculation;
+import com.ho.flow.vo.resp.workorder.WorkOrderCirculationRespVO;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+* @author yule
+* @description 针对表【work_order_circulation】的数据库操作Mapper
+* @createDate 2022-10-14 10:37:31
+* @Entity com.ho.flow.vo.WorkOrderCirculation
+*/
+@Mapper
+public interface WorkOrderCirculationMapper {
+
+    int insert(WorkOrderCirculation record);
+
+    int insertSelective(WorkOrderCirculation record);
+
+    WorkOrderCirculation selectByPrimaryKey(Long id);
+
+    int insertBatch(@Param("list")List<WorkOrderCirculation> workOrderCirculations);
+
+    List<WorkOrderCirculationRespVO> selectByOrderId(String orderId);
+
+}

flowable-center-dao/src/main/java/com/ho/flow/mapper/WorkOrderHisMapper.java

@@ -0,0 +1,48 @@
+package com.ho.flow.mapper;
+
+import com.ho.flow.vo.WorkOrderOld;
+import com.ho.flow.vo.req.workorder.WorkOrderPageReq;
+import com.ho.flow.vo.resp.workorder.WorkOrderOldPageRespVO;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+* @author yule
+* @description 针对表【work_order】的数据库操作Mapper
+* @createDate 2022-10-14 10:37:27
+* @Entity com.ho.flow.vo.WorkOrder
+*/
+@Mapper
+public interface WorkOrderHisMapper {
+
+
+    int deleteByPrimaryKey(List<String> orderIds);
+
+
+    int insertSelective(WorkOrderOld record);
+
+    WorkOrderOld selectByPrimaryKey(Long id);
+    //
+    WorkOrderOld selectByOrderId(String orderId);
+
+    int updateByPrimaryKeySelective(WorkOrderOld record);
+
+    int updateByPrimaryKey(WorkOrderOld record);
+
+    WorkOrderOld selectByStatus(@Param("orderId") String orderId);
+
+    List<WorkOrderOldPageRespVO> selectByPageInfo(WorkOrderPageReq vo);
+
+    List<WorkOrderOldPageRespVO> selectByHisPageInfo(WorkOrderPageReq vo);
+
+    int insertBatch(@Param("list")List<WorkOrderOld> workOrderOlds);
+
+    List<WorkOrderOld> selectByEventIds(List<Long> eventIds);
+
+    void delete(String orderId);
+
+    //退回工单
+    void updateReturnWorkOrder(WorkOrderOld workOrderOld);
+}

flowable-center-dao/src/main/java/com/ho/flow/mapper/WorkOrderMapper.java

@@ -0,0 +1,46 @@
+package com.ho.flow.mapper;
+
+import com.ho.flow.entity.WorkOrder;
+import com.ho.flow.vo.req.workorder.WorkOrderPageReq;
+import com.ho.flow.vo.resp.workorder.WorkOrderRespVO;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.List;
+
+/**
+* @author yule
+* @description 针对表【work_order】的数据库操作Mapper
+* @createDate 2023-02-04 12:40:37
+* @Entity com.ho.business.entity.WorkOrder
+*/
+@Mapper
+public interface WorkOrderMapper {
+
+    int deleteByPrimaryKey(Long id);
+
+    int insert(WorkOrder record);
+
+    int insertSelective(WorkOrder record);
+
+    WorkOrder selectByPrimaryKey(Long id);
+
+    WorkOrderRespVO selectByOrderId(String orderId);
+
+    WorkOrderRespVO selectByProcessInstId(String processInstId);
+
+    WorkOrderRespVO selectByProcessInstIdAndTitle(String processInstanceId, String title);
+
+    int updateByPrimaryKeySelective(WorkOrder record);
+
+    int updateByPrimaryKey(WorkOrder record);
+
+    List<WorkOrderRespVO> selectByInfo(WorkOrderPageReq vo);
+
+    int deleteByIds(List<Long> ids);
+
+    WorkOrderRespVO selectByOrderIdAndTitle(String orderId, String title);
+
+    Integer selectByStationId(Integer stationId);
+
+    void setEventNull(Long id);
+}

flowable-center-dao/src/main/java/com/ho/flow/mapper/WorkOrderPictureMapper.java

@@ -0,0 +1,39 @@
+package com.ho.flow.mapper;
+
+import com.ho.common.tools.entity.WorkOrderPicture;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+* @author yule
+* @description 针对表【work_order_picture】的数据库操作Mapper
+* @createDate 2023-02-04 14:19:18
+* @Entity com.ho.flow.entity.WorkOrderPicture
+*/
+@Mapper
+public interface WorkOrderPictureMapper {
+
+    int deleteByPrimaryKey(Integer id);
+
+    int insert(WorkOrderPicture record);
+
+    int insertSelective(WorkOrderPicture record);
+
+    WorkOrderPicture selectByPrimaryKey(Integer id);
+
+    int updateByPrimaryKeySelective(WorkOrderPicture record);
+
+    int updateByPrimaryKey(WorkOrderPicture record);
+
+    List<WorkOrderPicture> selectByWorkOrderIdAndType(@Param("workOrderId") Long workOrderId, @Param("type")Integer type);
+
+    void deletedBySrcIdsAndType(List<Long> ids, Integer type);
+
+    void setUpWorkOrderIdIdNUll(List<Integer> pictureIds);
+
+    //查询全部图片
+    List<WorkOrderPicture> selectAll();
+
+}

flowable-center-dao/src/main/java/com/ho/flow/mapper/WorkOrderPlanMapper.java

@@ -0,0 +1,32 @@
+package com.ho.flow.mapper;
+
+import com.ho.flow.entity.WorkOrderPlan;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.List;
+
+/**
+* @author yule
+* @description 针对表【work_order_plan】的数据库操作Mapper
+* @createDate 2023-03-16 15:21:05
+* @Entity com.ho.flow.entity.WorkOrderPlan
+*/
+@Mapper
+public interface WorkOrderPlanMapper {
+
+    int deleteByPrimaryKey(Integer id);
+
+    int insert(WorkOrderPlan record);
+
+    int insertSelective(WorkOrderPlan record);
+
+    WorkOrderPlan selectByPrimaryKey(Integer id);
+
+    int updateByPrimaryKeySelective(WorkOrderPlan record);
+
+    int updateByPrimaryKey(WorkOrderPlan record);
+
+    List<WorkOrderPlan> selectAll();
+
+    List<WorkOrderPlan> selectByGroupId(Integer groupId);
+}

flowable-center-dao/src/main/java/com/ho/flow/mapper/WorkOrderPlanSubMapper.java

@@ -0,0 +1,36 @@
+package com.ho.flow.mapper;
+
+import com.ho.flow.entity.WorkOrderPlanSub;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.List;
+
+/**
+* @author yule
+* @description 针对表【work_order_plan_sub】的数据库操作Mapper
+* @createDate 2023-03-16 15:26:08
+* @Entity com.ho.flow.entity.WorkOrderPlanSub
+*/
+@Mapper
+public interface WorkOrderPlanSubMapper {
+
+    int deleteByPrimaryKey(Long id);
+
+    int insert(WorkOrderPlanSub record);
+
+    int insertSelective(WorkOrderPlanSub record);
+
+    WorkOrderPlanSub selectByPrimaryKey(Long id);
+
+    int updateByPrimaryKeySelective(WorkOrderPlanSub record);
+
+    int updateByPrimaryKey(WorkOrderPlanSub record);
+
+    int deleteByPid(Integer pid);
+
+    List<WorkOrderPlanSub> selectByPid(Integer pid);
+
+    int insertBatch(List<WorkOrderPlanSub> list);
+
+    int insertUserBatch(List<WorkOrderPlanSub> userList);
+}

flowable-center-dao/src/main/java/com/ho/flow/mapper/WorkOrderSubMapper.java

@@ -0,0 +1,34 @@
+package com.ho.flow.mapper;
+
+import com.ho.flow.entity.WorkOrderSub;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.List;
+
+/**
+* @author yule
+* @description 针对表【word_order_sub】的数据库操作Mapper
+* @createDate 2023-03-20 11:23:15
+* @Entity com.ho.flow.entity.WordOrderSub
+*/
+@Mapper
+public interface WorkOrderSubMapper {
+
+    int deleteByPrimaryKey(Integer id);
+
+    int insert(WorkOrderSub record);
+
+    int insertSelective(WorkOrderSub record);
+
+    WorkOrderSub selectByPrimaryKey(Integer id);
+
+    int updateByPrimaryKeySelective(WorkOrderSub record);
+
+    int updateByPrimaryKey(WorkOrderSub record);
+
+    int insertBatch(List<WorkOrderSub> list);
+
+    void deleteByPid(Long pid);
+
+    List<WorkOrderSub> selectByPid(Long id);
+}

flowable-center-dao/src/main/java/com/ho/flow/monitor/EventToProcessMonitor.java

@@ -0,0 +1,96 @@
+package com.ho.flow.monitor;
+
+import com.ho.flow.entity.process.MovementDTO;
+import com.ho.flow.feignclient.BusinessFeignClient;
+import com.ho.flow.service.process.service.ProcessFlowNewService;
+import com.ho.flow.threads.EventToProcessThread;
+import com.ho.flow.util.EventToProcessThreadPoolUtils;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+
+import javax.annotation.PostConstruct;
+import java.util.TimerTask;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * @author catkins
+ * todo：告警转工单监听器类
+ */
+@Slf4j
+@Configuration
+public class EventToProcessMonitor {
+
+    @Autowired
+    private ProcessFlowNewService processFlowNewService;
+
+    @Autowired
+    private BusinessFeignClient businessFeignClient;
+
+    @Value("${spring.activiti.initialDelay}")
+    private Integer initialDelay;
+
+    @Value("${spring.activiti.flag}")
+    private Integer flag;
+
+    /**
+     * 监听告警队列是否有数据,如果有就生成工单
+     */
+    @PostConstruct
+    public void run() {
+        ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);
+        scheduledThreadPoolExecutor.scheduleAtFixedRate(new TimerTask() {
+            @Override
+            public void run() {
+               // log.error("eventQueue:{}"+eventQueue);
+                if ( eventQueue.size() > 0 ) {
+                    MovementDTO movementDTO = getEvents();
+                    // mysql入库队列是否有数据,有的话就调用入库方法
+                    EventToProcessThreadPoolUtils newInstance = EventToProcessThreadPoolUtils.getNewInstance();
+                    newInstance.executor(new EventToProcessThread(processFlowNewService,movementDTO,businessFeignClient));
+                }
+            }
+        }, initialDelay, 1, TimeUnit.SECONDS);
+    }
+
+    /** 放生成好的告警數據隊列 */
+    public static final ConcurrentLinkedQueue<MovementDTO> eventQueue = new ConcurrentLinkedQueue<MovementDTO>();
+
+    public static final ReentrantLock eventQueueLock = new ReentrantLock();
+
+    /**
+     * 把生成的告警数据保存进队列
+     * @param movementDTO
+     */
+    public void setEvents(MovementDTO movementDTO){
+        eventQueueLock.lock();
+        try{
+            eventQueue.add(movementDTO);
+            log.info("setEvents size:{}",eventQueue.size());
+        } finally {
+            eventQueueLock.unlock();
+        }
+    }
+
+    /**
+     * 从队列取数据
+     * @return
+     */
+    public MovementDTO getEvents(){
+        MovementDTO movementDTO = null;
+        eventQueueLock.lock();
+        try{
+            movementDTO = eventQueue.poll();
+            log.info("getEvents size:{}",eventQueue.size());
+        } finally {
+            eventQueueLock.unlock();
+        }
+        return movementDTO;
+    }
+
+
+}

flowable-center-dao/src/main/java/com/ho/flow/service/AlarmConfigService.java

@@ -0,0 +1,46 @@
+package com.ho.flow.service;
+
+
+import com.ho.business.vo.req.deviceModel.SynchronousReqVo;
+import com.ho.common.tools.entity.SimpleUser;
+import com.ho.flow.vo.AlarmConfig;
+import com.ho.flow.vo.req.AlarmConfig.*;
+
+import java.util.List;
+
+/**
+* @author gyan
+* @description 针对表【alarm_config】的数据库操作Service
+* @createDate 2023-02-01 17:15:01
+*/
+public interface AlarmConfigService{
+
+    List<AlarmConfig> selectList(AlarmConfigPageReqVo vo);
+
+    List<AlarmConfig> selectListGroupCache(Integer groupId,Integer scope, String deviceType);
+
+    List<AlarmConfig> selectListCompanyCache(Integer groupId,Integer stationId, Integer scope, String deviceType);
+
+
+    void add(AlarmConfigAddReqVo vo, SimpleUser user);
+
+    //批量添加遥信
+    void addSignalBatch(AlarmSignalBatchAddReq addReq);
+
+    //批量添加遥测
+    void addMeasureBatch(AlarmMeasureBatchAddReq addReq);
+
+    void deletedById(Integer id);
+
+    //批量删除遥信
+    void deleteSignalBatch(AlarmBatchDeleteReq deleteReq);
+
+    int update(AlarmConfigUpdateReqVo vo);
+
+    /**
+     * 一键同步数据
+     * @param vo
+     * @return
+     */
+    int syAlarmConfig(SynchronousReqVo vo);
+}

flowable-center-dao/src/main/java/com/ho/flow/service/DeviceColDefineService.java

@@ -0,0 +1,60 @@
+package com.ho.flow.service;
+
+
+import com.ho.business.entity.DeviceTypeCol;
+import com.ho.business.vo.DeviceTypeList;
+import com.ho.business.vo.req.deviceModel.SynchronousReqVo;
+import com.ho.common.tools.util.PageResult;
+import com.ho.flow.vo.DeviceColDefine;
+import com.ho.flow.vo.req.AlarmConfig.DeviceColDefineReqVo;
+import com.ho.flow.vo.req.devicecoldefine.DeviceColDefineDeleteVO;
+import com.ho.flow.vo.req.devicecoldefine.DeviceColDefineModifyVO;
+import com.ho.flow.vo.req.devicecoldefine.DeviceColDefineReqVO;
+import com.ho.flow.vo.req.devicecoldefine.DeviceColDefineSyncVO;
+
+import java.util.List;
+
+/**
+ * @author gyan
+ * @DateTime: 2023/2/1 16:39
+ *
+ *   @Description 针对表【device_col_define】的数据库操作Service
+ *
+ */
+public interface DeviceColDefineService {
+
+    PageResult<DeviceColDefine> selectPage(DeviceColDefineReqVo definePageReq);
+
+    List<DeviceColDefine> selectList(DeviceColDefineReqVo definePageReq);
+
+    DeviceColDefine selectById(Integer id);
+
+    List<DeviceColDefine> selectByIdList(List<Integer> ids, String deviceType);
+
+    DeviceColDefine selectByIdAndDeviceTypeId(Integer id,Integer deviceTypeId);
+
+    DeviceColDefine selectByColAndDeviceType(String Col,String deviceType);
+
+    int insertList(List<DeviceColDefineReqVO> list);
+
+    int addDeviceColDefine(DeviceColDefineReqVO vo);
+
+    int modifyDeviceColDefine(DeviceColDefineModifyVO vo);
+
+    int deleteDeviceColDefine(DeviceColDefineDeleteVO vo);
+
+
+    int syncNewDeviceColDefine(SynchronousReqVo vo);
+
+
+    int deviceColDefine(List<DeviceTypeCol> deviceTypeCols);
+
+    void syncAlarmConfigList(DeviceTypeList deviceTypeList);
+
+    /**
+     * 同步数据
+     * @param definePageReq
+     * @return
+     */
+    int syncDeviceColDefine(DeviceColDefineSyncVO definePageReq);
+}

flowable-center-dao/src/main/java/com/ho/flow/service/EventService.java

@@ -0,0 +1,99 @@
+package com.ho.flow.service;
+
+
+import com.ho.business.vo.req.MonitorQuery;
+import com.ho.common.tools.entity.SimpleUser;
+import com.ho.common.tools.entity.UserDetailRespVO;
+import com.ho.common.tools.util.PageResult;
+import com.ho.flow.vo.Event;
+import com.ho.flow.vo.req.event.*;
+import com.ho.flow.vo.resp.event.EventDayNum;
+import com.ho.flow.vo.resp.event.EventDemo;
+import com.ho.flow.vo.resp.event.EventNumRespVO;
+import com.ho.flow.vo.resp.event.EventRespVO;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author yule
+ * @description 针对表【event】的数据库操作Service
+ * @createDate 2022-08-25 16:05:20
+ */
+public interface EventService {
+
+    List<EventDemo> getFaultDuration(EventDemoReqVo vo);
+
+    PageResult<EventRespVO> pageEventInfo(EventReqPageVO vo);
+
+    List<EventRespVO> eventInfo(EventReqPageVO vo);
+
+    //告警列表
+    List<EventRespVO> eventList(EventReqPageVO vo);
+
+    int updateById(List<Long> ids, UserDetailRespVO userDetail);
+
+    //批量新增
+    int insertEventBatch(List<Event> events);
+
+    //批量修改
+    int updateEventBatch(List<Event> events);
+
+    EventNumRespVO selectNum(EventReqPageVO vo, SimpleUser user);
+
+    //事件转工单
+    void conversionWorkOrder(List<Long> eventIds, SimpleUser user);
+
+    List<EventRespVO> getDropDownList(SimpleUser user, DropDownReq req);
+
+    /**
+     * 批量查询根据电站id和设备srcId
+     *
+     * @param user
+     * @param list
+     * @return
+     */
+    List<EventRespVO> dropDownBatchList(SimpleUser user, List<DropDownReq> list);
+
+    Event selectById(Long eventId);
+
+    int eventNum(EventReqPageVO vo, SimpleUser user);
+
+    Event selectByParams(Event event);
+
+    /**
+     * 判断电站接入点状态(是否产生告警数据)定时任务
+     */
+    void accessPointEvent();
+
+    /**
+     * 判断外接电表状态（是否产生告警数据）定时任务
+     */
+    void outsideEleEvent();
+
+    void regularlySendNotifications(MonitorQuery monitorQuery);
+    /**
+     * 告警转工单
+     *
+     * @param eventWorkOrder 告警转工单入参
+     */
+    void conversion(EventWorkOrder eventWorkOrder);
+
+    /**
+     * 根据id集合查询
+     *
+     * @param eventIds
+     * @return
+     */
+    List<Event> selectByIds(List<Long> eventIds);
+
+    List<EventDemo> getFaultDurations(EventDemoReqVo vo);
+
+    /**
+     * 根据天统计告警数量
+     * @return
+     */
+    List<EventDayNum> countEventByDay(EventReqPageVO vo);
+
+    Map<String,Integer> eventDeviceNum(EventNumReq vo);
+}

flowable-center-dao/src/main/java/com/ho/flow/service/FlowWorkOrderService.java

@@ -0,0 +1,60 @@
+package com.ho.flow.service;
+
+import org.activiti.engine.runtime.ProcessInstance;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author fancl
+ * @desc: 工单的工作流
+ * @date 2023/1/23
+ */
+public interface FlowWorkOrderService {
+
+    /**
+     * 开启一个流程
+     * @param processDefinitionKey
+     * @param tenantId
+     * @param businessKey
+     * @param variables
+     */
+    ProcessInstance startProcess(String processDefinitionKey, String businessKey, Map<String, Object> variables, String tenantId);
+
+    /**
+     * 查询待分配或待验收的列表
+     * 返回的是对应的Map<key:业务id, value:taskId>
+     * @param category
+     * @param assignType 任务类型 canDistributeOrder canCheckOrder
+     * @param stationIds
+     * @param tenantId
+     */
+    Map<String, String> queryToBeDoneMap(String category, String assignType,List<String> candidateUsers, List<String> stationIds, String tenantId);
+
+    /**
+     * 查询个人任务列表
+     * 返回 businessKey(即orderId) , taskId
+     * @param category
+     * @param assignee
+     * @param tenantId
+     * @return
+     */
+    Map<String, String> queryPersonalTask(String category ,String assignee, String tenantId);
+
+    //从几个map中汇总业务id, 即 订单id
+    List<String> getOrderIdList(Map<String,String> toDistributeMap,Map<String,String> toDoMap,Map<String,String> toCheckMap);
+
+    //完成节点任务,
+    void completeTask(String taskId, Map<String, Object> variables);
+
+    /**
+     * 判断岗位是否和 配置的匹配 匹配返回true , 否则返回false
+     * @param positions
+     * @param postConfig
+     * @return
+     */
+    boolean matchPermit(List<String> positions , String[] postConfig);
+
+    //整型元素转为字符串元素
+    List<String> intToString(List<Integer> intList);
+}

flowable-center-dao/src/main/java/com/ho/flow/service/ProcessFlowService.java

@@ -0,0 +1,74 @@
+package com.ho.flow.service;
+
+import com.ho.common.tools.entity.SimpleUser;
+import com.ho.flow.entity.WorkOrderSub;
+import com.ho.flow.entity.WorkOrderPlan;
+import com.ho.flow.vo.req.workorder.*;
+import com.ho.flow.vo.resp.workorder.FallBackTaskResp;
+import com.ho.flow.vo.resp.workorder.HisTaskResp;
+import com.ho.flow.vo.resp.workorder.TaskDone;
+import com.ho.flow.vo.resp.workorder.WorkOrderRespVO;
+import org.activiti.engine.history.HistoricTaskInstance;
+import org.activiti.engine.task.Task;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author fancl
+ * @desc: 流程控制接口
+ * @date 2023/2/5
+ */
+public interface ProcessFlowService {
+    //根据任务id查询任务
+    Task getTaskById(TaskUserReq taskUserReq);
+
+    //查代办列表,根据用户名集团id查询
+    Map<String,List<Task>> getTodoList(SimpleUser simpleUser);
+
+    //组装任务对象
+    List<TaskDone> getToDoListFromTask(Map<String,List<Task>> taskMap,DoListTaskReq doListTaskReq);
+
+    //保存工单并发起流程,代办人设置为自己
+    String saveOrderAndStartProcess(WorkOrderAddReqVO workOrderAddReqVO);
+
+    //工单详情
+    WorkOrderRespVO getOrderDetail();
+
+    //接收任务,对应claim
+    void doClaimTask(TaskUserReq taskReq);
+
+    //完成工单任务
+    void doCompleteTask(DoTaskReq doTaskReq);
+
+    void doNullifyTaskTask(DoTaskReq doTaskReq);
+
+    //退回工单任务
+    void doRejectTask(RejectTaskReq rejectTaskReq );
+
+    //作废任务
+    void doDiscardTask(TaskReq taskReq);
+
+
+    List<FallBackTaskResp> getFallBackTask(FallBackTaskReq fallBackTaskReq);
+
+    //查下一节点
+    String getNextTaskName(String processInstId);
+
+
+    List<HisTaskResp> getCirculationTask(CirculationTaskReq taskReq);
+
+
+    List<HistoricTaskInstance> getDoneList(SimpleUser simpleUser);
+
+    List<TaskDone> getDoneListFromTask(List<HistoricTaskInstance> taskList,DoListTaskReq doListTaskReq);
+
+    //用于定时任务创建工单并流转工单
+    void planAddWorkOrder(WorkOrderPlan workOrderPlan,List<String> userIds,List<WorkOrderSub> workOrderSubs);
+
+    /**
+     * 根据集团id部署工作流
+     * @param groupId
+     */
+    void deploymentWorkflow(Integer groupId);
+}

flowable-center-dao/src/main/java/com/ho/flow/service/SendSmsConfigService.java

@@ -0,0 +1,54 @@
+package com.ho.flow.service;
+
+import com.ho.common.tools.util.PageResult;
+import com.ho.flow.entity.SendSmsConfig;
+import com.ho.flow.vo.req.SendSmsConfig.SendSmsConfigQueryReq;
+import com.ho.flow.vo.resp.SendSmsConfig.SendSmsConfigRsp;
+
+import java.util.List;
+
+public interface SendSmsConfigService {
+
+    /**
+     * 根据条件分页查询发送短信配置
+     * @param vo
+     * @return
+     */
+    PageResult<SendSmsConfigRsp> getPageList(SendSmsConfigQueryReq vo);
+
+    /**
+     * 根据条件查询发送短信配置
+     * @param vo
+     * @return
+     */
+    List<SendSmsConfigRsp> getList(SendSmsConfigQueryReq vo);
+
+    /**
+     * 批量插入短信配置
+     * @param list
+     */
+    void insertList(List<SendSmsConfig> list);
+
+    /**
+     * 更新短信配置根据主键id
+     * @param vo
+     * @return
+     */
+    int updateById(SendSmsConfig vo);
+
+    /**
+     * 更加userId更新短信配置中用户信息
+     * @param vo
+     * @return
+     */
+    int updateByUserId(SendSmsConfig vo);
+
+    /**
+     * 根据id批量删除
+     * @param ids
+     * @return
+     */
+    int deleteList(List<Integer> ids);
+
+    void sendSms(SendSmsConfigQueryReq vo);
+}

flowable-center-dao/src/main/java/com/ho/flow/service/WorkOrderCirculationService.java

@@ -0,0 +1,24 @@
+package com.ho.flow.service;
+
+
+import com.ho.flow.vo.WorkOrderCirculation;
+import com.ho.flow.vo.resp.workorder.WorkOrderCirculationRespVO;
+
+import java.util.List;
+
+/**
+ * @Description 针对表【work_order_circulation】的数据库操作Service
+ * Author yule
+ * Date 2022/10/14 15:38
+ */
+
+public interface WorkOrderCirculationService {
+
+    void add(WorkOrderCirculation workOrderCirculation);
+
+
+    int insertEventBatch(List<WorkOrderCirculation> workOrderCirculations);
+
+    List<WorkOrderCirculationRespVO> selectByOrderId(String orderId);
+
+}

flowable-center-dao/src/main/java/com/ho/flow/service/WorkOrderHisService.java

@@ -0,0 +1,60 @@
+package com.ho.flow.service;
+
+
+import com.ho.common.tools.entity.SimpleUser;
+import com.ho.common.tools.util.PageResult;
+import com.ho.flow.vo.WorkOrderOld;
+import com.ho.flow.vo.WorkOrderCirculation;
+import com.ho.flow.vo.req.workorder.WorkOrderAddReq;
+import com.ho.flow.vo.req.workorder.WorkOrderApplyReqVO;
+import com.ho.flow.vo.req.workorder.WorkOrderPageReq;
+import com.ho.flow.vo.req.workorder.WorkOrderUpdateReq;
+import com.ho.flow.vo.resp.workorder.WorkOrderOldPageRespVO;
+
+import java.util.List;
+
+/**
+import com.ho.flow.vo.WorkOrder;
+import com.ho.business.vo.req.workorder.WorkOrderApplyReqVO;
+
+ * @Description 工单管理
+ * Author yule
+ * Date 2022/10/14 10:43
+ */
+public interface WorkOrderHisService {
+
+
+    void insertStation(WorkOrderAddReq vo, SimpleUser simpleUser, String workOrderId);
+
+    PageResult<WorkOrderOldPageRespVO> selectPage(WorkOrderPageReq vo, SimpleUser simpleUser);
+
+    WorkOrderOld findByOrderId(String orderId);
+
+    void acceptWorkOrder(WorkOrderOld workOrderOld, WorkOrderCirculation workOrderAllocate);
+
+    void returnWorkOrder(WorkOrderOld workOrderOld, WorkOrderCirculation workOrderAllocate);
+
+    void closeWorkOrder(WorkOrderOld workOrderOld, WorkOrderCirculation workOrderAllocate);
+
+    void updateWorkOrder(WorkOrderUpdateReq vo, SimpleUser simpleUser);
+
+    //分配工单
+    void allocateOrder(WorkOrderApplyReqVO applyReqVO, SimpleUser simpleUser);
+
+    //批量删除
+    void deleteWorkOrder(List<String> orderIds);
+
+    int insertEventBatch(List<WorkOrderOld> workOrderOlds);
+
+    WorkOrderOld selectById(String orderId);
+
+    PageResult<WorkOrderOldPageRespVO> selectHisPage(WorkOrderPageReq vo);
+
+    List<WorkOrderOld> selectByEventIds(List<Long> eventIds);
+
+    //根据电站ids 查询
+    List<WorkOrderOld> selectByStationIds(List<Long> stationIds);
+
+    //单个删除
+    void delete(String orderId);
+}

flowable-center-dao/src/main/java/com/ho/flow/service/WorkOrderPictureService.java

@@ -0,0 +1,46 @@
+package com.ho.flow.service;
+
+
+import com.ho.common.tools.entity.WorkOrderPicture;
+import com.ho.flow.vo.req.workorder.WorkOrderAddReqVO;
+import com.ho.flow.vo.req.workorder.WorkOrderUpdateReqVO;
+import com.ho.flow.vo.resp.workorder.PictureRespVO;
+
+import java.util.List;
+
+/**
+ * @Description 图片存储
+ * Author yule
+ * Date 2023/1/3 14:05
+ */
+public interface WorkOrderPictureService {
+    //新增图片中url
+    WorkOrderPicture insertPicture(String url);
+    //添加图片中srcId和type
+    void insertWorkOrderIdAndType(WorkOrderAddReqVO vo);
+
+    WorkOrderPicture selectById(Integer id);
+
+    //根据工单id查询图片对象
+    List<PictureRespVO> selectByOrderId(Long workOrderId);
+
+    void deletedById(Integer id);
+
+    //根据orderId删除
+    void deletedByWorkOrderIds(List<Long> ids);
+
+    void updatePicture(WorkOrderUpdateReqVO vo);
+
+    /**
+     * 查询全部图片数据
+     * @return
+     */
+    List<WorkOrderPicture> selectAll();
+
+    /**
+     * 根据id集合删除文件图片对象
+     * @param workOrderPictureIds 工单图片的id集合
+     */
+    void deletedByIds(List<Long> workOrderPictureIds);
+
+}

flowable-center-dao/src/main/java/com/ho/flow/service/WorkOrderPlanService.java

@@ -0,0 +1,25 @@
+package com.ho.flow.service;
+
+import com.ho.flow.vo.req.workorderplan.WorkOrderPlanAddReqVO;
+import com.ho.flow.vo.req.workorderplan.WorkOrderPlanReqVO;
+import com.ho.flow.vo.resp.workorderplan.WorkOrderPlanRespVO;
+
+import java.util.List;
+
+/**
+ * @Description 工单计划
+ * Author yule
+ * Date 2023/3/16 15:53
+ */
+public interface WorkOrderPlanService {
+
+    void add(WorkOrderPlanAddReqVO vo);
+
+    void delete(WorkOrderPlanReqVO vo);
+
+    void update(WorkOrderPlanAddReqVO vo);
+
+    WorkOrderPlanRespVO getOne(WorkOrderPlanReqVO vo);
+
+    List<WorkOrderPlanRespVO> getAll(WorkOrderPlanReqVO vo);
+}

flowable-center-dao/src/main/java/com/ho/flow/service/WorkOrderService.java

@@ -0,0 +1,52 @@
+package com.ho.flow.service;
+
+import com.ho.common.tools.util.PageResult;
+import com.ho.flow.entity.WorkOrder;
+import com.ho.flow.vo.req.workorder.WorkOrderAddReqVO;
+import com.ho.flow.vo.req.workorder.WorkOrderPageReq;
+import com.ho.flow.vo.req.workorder.WorkOrderUpdateReqVO;
+import com.ho.flow.vo.resp.workorder.WorkOrderRespVO;
+import com.ho.common.tools.entity.OrderDept;
+
+import java.util.List;
+
+/**
+ * @Description 工单业务数据
+ * Author yule
+ * Date 2023/2/4 12:45
+ */
+public interface WorkOrderService {
+
+    int add(WorkOrderAddReqVO vo);
+
+    int delete(List<Long> ids);
+
+    //单独修改工单表
+    int update(WorkOrder vo);
+
+    //修改工单
+    int updateWorkOrder(WorkOrderUpdateReqVO vo);
+
+    WorkOrderRespVO getOne(Long id);
+
+    //根据工单号查对象
+    WorkOrderRespVO findByOrderId(String orderId);
+
+    WorkOrderRespVO findByProcInstId(String procInstId);
+
+    WorkOrderRespVO findByProcInstIdAndTitle(String processInstanceId, String title);
+
+    //查工单列表
+    List<WorkOrderRespVO> findList(WorkOrderPageReq vo);
+
+    PageResult<WorkOrderRespVO> getPage(WorkOrderPageReq vo);
+
+    List<OrderDept> selectOrderUser(Integer groupId , List<String> postCodes);
+
+    WorkOrderRespVO selectByProcessInstId(String processInstId);
+
+    WorkOrderRespVO findByOrderIdAndTitle(String orderId, String title);
+
+    Integer selectByStationId(Integer stationId);
+
+}

flowable-center-dao/src/main/java/com/ho/flow/service/impl/AlarmConfigServiceImpl.java

@@ -0,0 +1,486 @@
+package com.ho.flow.service.impl;
+
+
+import com.google.common.collect.Lists;
+import com.ho.business.vo.req.deviceModel.SynchronousReqVo;
+import com.ho.common.tools.constant.CommonConstant;
+import com.ho.common.tools.constant.RedisKeyConstant;
+import com.ho.common.tools.entity.SimpleUser;
+import com.ho.common.tools.exception.BaseResponseCode;
+import com.ho.common.tools.exception.BusinessException;
+import com.ho.common.tools.service.RedisService;
+import com.ho.common.tools.util.RandomUtil;
+import com.ho.flow.constant.FlowConstant;
+import com.ho.flow.mapper.AlarmConfigMapper;
+import com.ho.flow.mapper.DeviceColDefineMapper;
+import com.ho.flow.service.AlarmConfigService;
+import com.ho.flow.service.DeviceColDefineService;
+import com.ho.flow.vo.AlarmConfig;
+import com.ho.flow.vo.DeviceColDefine;
+import com.ho.flow.vo.req.AlarmConfig.*;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+/**
+ * @author gyan
+ * @description 针对表【alarm_config】的数据库操作Service实现
+ * @createDate 2023-02-01 17:15:01
+ */
+@Service
+@Slf4j
+public class AlarmConfigServiceImpl implements AlarmConfigService {
+
+    @Autowired
+    AlarmConfigMapper alarmConfigMapper;
+
+    @Autowired
+    DeviceColDefineMapper deviceColDefineMapper;
+
+    @Autowired
+    DeviceColDefineService deviceColDefineService;
+
+    @Autowired
+    RedisService redisService;
+
+    //不分页查询
+    @Override
+    public List<AlarmConfig> selectList(AlarmConfigPageReqVo vo) {
+        List<AlarmConfig> alarmList = alarmConfigMapper.selectList(vo);
+        return alarmList;
+    }
+
+    @Override
+    //@Cacheable(cacheManager = "fiveMinuteCacheManager", value = "AlarmConfigListGroupCache", key = "#groupId+'_'+#scope+'_'+#deviceType", sync = true)
+    public List<AlarmConfig> selectListGroupCache(Integer groupId, Integer scope ,String deviceType) {
+        List<AlarmConfig> alarmList = null;
+        String key = RedisKeyConstant.ALARM.GROUP_ALARM_CONFIG + groupId + ":"+ scope + ":" + deviceType;
+        if(redisService.hasKey(key)){
+            alarmList =(List<AlarmConfig>) redisService.get(key);
+        }else{
+            AlarmConfigPageReqVo vo = new AlarmConfigPageReqVo();
+            vo.setGroupId(groupId);
+            vo.setScope(scope);
+            vo.setDeviceType(deviceType);
+            alarmList = alarmConfigMapper.selectList(vo);
+            redisService.set(key,alarmList);
+            redisService.expire(key, RandomUtil.getRandomInt(), TimeUnit.MINUTES);
+        }
+        return alarmList;
+    }
+
+    @Override
+    //@Cacheable(cacheManager = "fiveMinuteCacheManager", value = "AlarmConfigListCompanyCache", key = "#groupId+'_'+#stationId+'_'+#scope+'_'+#deviceType", sync = true)
+    public List<AlarmConfig> selectListCompanyCache(Integer groupId, Integer stationId, Integer scope ,String deviceType) {
+        List<AlarmConfig> alarmList = null;
+        String key = RedisKeyConstant.ALARM.COMPANY_ALARM_CONFIG + groupId + ":"+ stationId + ":" + deviceType;
+        if(redisService.hasKey(key)){
+            alarmList =(List<AlarmConfig>) redisService.get(key);
+        }else{
+            AlarmConfigPageReqVo vo = new AlarmConfigPageReqVo();
+            vo.setGroupId(groupId);
+            vo.setStationId(stationId);
+            vo.setScope(scope);
+            vo.setDeviceType(deviceType);
+            alarmList = alarmConfigMapper.selectList(vo);
+            redisService.set(key,alarmList);
+            redisService.expire(key,RandomUtil.getRandomInt(), TimeUnit.MINUTES);
+        }
+        return alarmList;
+    }
+
+    @Override
+    public void add(AlarmConfigAddReqVo vo, SimpleUser user) {
+        //根据col_define_id，查询到device_type device_type_id  col col_name sens_type
+        //新增DeviceTypeId 查询条件，判断是否存在内置设备
+        DeviceColDefine deviceColDefine = deviceColDefineService.selectByIdAndDeviceTypeId(vo.getColDefineId(), vo.getDeviceTypeId());
+        if (deviceColDefine == null) {
+            //配置元素不存在
+            throw new BusinessException(BaseResponseCode.CONFIGURATION_ELEMENT_DOES_NOT_EXIST);
+        }
+        //查询是否有重复的数据,需要增加集团id, 电站id,并且查询未删除的
+        AlarmQuery alarmQuery = new AlarmQuery();
+        alarmQuery.setGroupId(user.getGroupId());
+        //电站级 查询电站, 集团级别不查询电站
+        if (FlowConstant.AlarmConfig.SCOPE_STATION.equals(vo.getScope())) {
+            alarmQuery.setStationId(vo.getStationId());
+        }
+        alarmQuery.setScope(vo.getScope());
+        alarmQuery.setColDefineId(vo.getColDefineId());
+        List<AlarmConfig> alarmConfigList = alarmConfigMapper.selectRepeatValue(alarmQuery);
+        if (!alarmConfigList.isEmpty()) {
+            throw new BusinessException(BaseResponseCode.EXISTS_DUPLICATE_DATA);
+        }
+        AlarmConfig alarmConfig = new AlarmConfig();
+        //判断类型是否为  1遥信(一个值) 或者 2遥测(两个值)
+        if (CommonConstant.ONE.equals(deviceColDefine.getSensType())) {
+            if (vo.getAlarmLevel() == null) {
+                throw new BusinessException(BaseResponseCode.TELEMETRY_NOT_IS_NULL);
+            } else {
+                alarmConfig.setAlarmLevel(vo.getAlarmLevel());
+                //把遥信的两个值冗余进来
+                alarmConfig.setInfo0(deviceColDefine.getInfo0());
+                alarmConfig.setInfo1(deviceColDefine.getInfo1());
+            }
+        }
+        if (CommonConstant.TWO.equals(deviceColDefine.getSensType())) {
+            if (vo.getLowerLimit() == null && vo.getUpperLimit() == null) {
+                throw new BusinessException(BaseResponseCode.TELEMETRY_VALUE_NOT_LIMIT);
+            } else {
+                alarmConfig.setUpperLimit(vo.getUpperLimit());
+                alarmConfig.setLowerLimit(vo.getLowerLimit());
+            }
+        }
+        //集团id
+        alarmConfig.setGroupId(user.getGroupId());
+        //电站级别查询电站
+        if (FlowConstant.AlarmConfig.SCOPE_STATION.equals(vo.getScope())) {
+            alarmConfig.setStationId(vo.getStationId());
+        }
+        alarmConfig.setScope(vo.getScope());
+        alarmConfig.setColDefineId(vo.getColDefineId());
+        alarmConfig.setDeviceTypeId(deviceColDefine.getDeviceTypeId());
+        alarmConfig.setDeviceType(deviceColDefine.getDeviceType());
+        alarmConfig.setDeviceName(deviceColDefine.getDeviceName());
+        alarmConfig.setCol(deviceColDefine.getCol());
+        alarmConfig.setColName(deviceColDefine.getColName());
+        alarmConfig.setSensType(deviceColDefine.getSensType());
+        Date now = new Date();
+        alarmConfig.setCreateTime(now);
+        alarmConfig.setUpdateTime(now);
+        alarmConfig.setDeleted(CommonConstant.DELETED);
+        alarmConfigMapper.insert(alarmConfig);
+    }
+
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void addSignalBatch(AlarmSignalBatchAddReq addReq) {
+        //在alarmconfig表里查询判断是否有重复值,有就报错
+        List<Integer> colIdList = addReq.getColIdList();
+        //集团级别 ,stationId置空
+        AlarmConfigPageReqVo alarmQuery = new AlarmConfigPageReqVo();
+        alarmQuery.setDeviceType(addReq.getDeviceType());
+        alarmQuery.setScope(addReq.getScope());
+        alarmQuery.setColIds(colIdList);
+        //电站级别才匹配电站参数,集团级别不用匹配电站参数
+        if (FlowConstant.AlarmConfig.SCOPE_STATION.equals(addReq.getScope())) {
+            alarmQuery.setStationId(addReq.getStationId());
+        }
+        List<AlarmConfig> alarmConfigs = selectList(alarmQuery);
+        if (!alarmConfigs.isEmpty()) {
+            //抛出已存在相关数据异常,并且把具体字段提示出来
+            //把字段名称列出来,提示给客户
+            List<String> colRepeatNames = new ArrayList<>();
+            for (AlarmConfig alarmConfig : alarmConfigs) {
+                colRepeatNames.add(alarmConfig.getColName());
+            }
+            String join = StringUtils.join(colRepeatNames.toArray(), ",");
+            throw new BusinessException(BaseResponseCode.EXISTS_DUPLICATE_ALARM.getCode(), BaseResponseCode.EXISTS_DUPLICATE_ALARM.getMsg()+ join);
+        }
+        //这个时候可以新增数据了
+        //先查这些数据对应的字段定义集合
+        List<DeviceColDefine> deviceColDefines = deviceColDefineService.selectByIdList(colIdList, addReq.getDeviceType());
+        //将类型转换为AlarmConfig
+        List<AlarmConfig> configList = new ArrayList<>();
+        for (DeviceColDefine deviceColDefine : deviceColDefines) {
+            AlarmConfig alarmConfig = new AlarmConfig();
+            alarmConfig.setGroupId(addReq.getGroupId());
+            //只有电站的才需要增加电站属性
+            if (FlowConstant.AlarmConfig.SCOPE_STATION.equals(addReq.getScope())) {
+                alarmConfig.setStationId(addReq.getStationId());
+            }
+            alarmConfig.setScope(addReq.getScope());
+            alarmConfig.setColDefineId(deviceColDefine.getId());
+            alarmConfig.setDeviceTypeId(deviceColDefine.getDeviceTypeId());
+            alarmConfig.setDeviceName(deviceColDefine.getDeviceName());
+            alarmConfig.setDeviceType(deviceColDefine.getDeviceType());
+            alarmConfig.setCol(deviceColDefine.getCol());
+            alarmConfig.setColName(deviceColDefine.getColName());
+            alarmConfig.setSensType(deviceColDefine.getSensType());
+            alarmConfig.setInfo0(deviceColDefine.getInfo0());
+            alarmConfig.setInfo1(deviceColDefine.getInfo1());
+            alarmConfig.setAlarmLevel(addReq.getAlarmLevel());
+            Date now = new Date();
+            alarmConfig.setCreateTime(now);
+            alarmConfig.setUpdateTime(now);
+            alarmConfig.setDeleted(1);
+            configList.add(alarmConfig);
+        }
+        //有数据就入库
+        if (!configList.isEmpty()) {
+            alarmConfigMapper.insertBatch(configList);
+            String key = RedisKeyConstant.ALARM.GROUP_ALARM_CONFIG + addReq.getGroupId() + ":"+ addReq.getScope() + ":" + addReq.getDeviceType();
+            if (FlowConstant.AlarmConfig.SCOPE_STATION.equals(addReq.getScope())) {
+                key = RedisKeyConstant.ALARM.COMPANY_ALARM_CONFIG + addReq.getGroupId() + ":"+ addReq.getStationId() + ":" + addReq.getDeviceType();
+            }
+            addAlarmRedis(configList,key);
+        }
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void addMeasureBatch(AlarmMeasureBatchAddReq addReq) {
+        List<MeasureVo> measureList = addReq.getMeasureList();
+        if (measureList == null || measureList.isEmpty()) {
+            return;
+        }
+        //类型是固定的,新增和修改是一个接口
+        //一种是之前alarmconfig表没有的,新增进去
+        //一种是之前有的，进行修改,要么是改值,要么删除
+        //需要根据alarmconfig表中是否有这个id进行判断,如果没有就新增,对于有的,判断是修改还是删除
+
+        //这个list和alarm表中的数据是一致的,只是需要把这里面的数据加工为新增、修改、删除3个子集合
+        //第一种，要新增的,先按这个scope查询alarm中已经配置的
+        AlarmConfigPageReqVo alarmConfigPageReqVo = new AlarmConfigPageReqVo();
+        alarmConfigPageReqVo.setGroupId(addReq.getGroupId());
+        alarmConfigPageReqVo.setDeviceType(addReq.getDeviceType());
+        alarmConfigPageReqVo.setScope(addReq.getScope());
+        alarmConfigPageReqVo.setSensType(addReq.getSensType());
+        if (FlowConstant.AlarmConfig.SCOPE_STATION.equals(addReq.getScope())) {
+            alarmConfigPageReqVo.setStationId(addReq.getStationId());
+        }
+        //先查已经配置的数据列表
+        List<AlarmConfig> configList = alarmConfigMapper.selectList(alarmConfigPageReqVo);
+        log.info("configList:{}" ,configList);
+        Map<Integer, AlarmConfig> configMap = configList.stream().collect(Collectors.toMap(AlarmConfig::getColDefineId, alarmConfig -> alarmConfig));
+        List<AlarmConfig> addNewList = new ArrayList<>();
+        //用于删除的
+        List<Integer> deleteList = new ArrayList<>();
+        //用于修改的
+        List<AlarmConfig> updateList = new ArrayList<>();
+        //用于新增id
+        List<Integer> defineIds = new ArrayList<>();
+        Date now = new Date();
+        Map<Integer,Integer> map = new HashMap<>();
+        List<AlarmConfig> updateAllList = new ArrayList<>();
+        for (MeasureVo measureVo : measureList) {
+            if (!configMap.containsKey(measureVo.getId())) {
+                if (measureVo.getLowerLimit() == null && measureVo.getUpperLimit() == null) {
+                    continue;
+                }
+                //这个过程把要插入的数据都
+                defineIds.add(measureVo.getId());
+                AlarmConfig alarmConfigAdd = new AlarmConfig();
+                alarmConfigAdd.setGroupId(addReq.getGroupId());
+                alarmConfigAdd.setScope(addReq.getScope());
+                //站级别，把stationId加进来
+                if (FlowConstant.AlarmConfig.SCOPE_STATION.equals(addReq.getScope())) {
+                    alarmConfigAdd.setStationId(addReq.getStationId());
+                }
+                alarmConfigAdd.setColDefineId(measureVo.getId());
+                alarmConfigAdd.setSensType(addReq.getSensType());
+                alarmConfigAdd.setLowerLimit(measureVo.getLowerLimit());
+                alarmConfigAdd.setUpperLimit(measureVo.getUpperLimit());
+                alarmConfigAdd.setCreateTime(now);
+                alarmConfigAdd.setUpdateTime(now);
+                addNewList.add(alarmConfigAdd);
+            } else {
+                AlarmConfig alarmConfig = configMap.get(measureVo.getId());
+                map.put(alarmConfig.getId(),alarmConfig.getId());
+                //这个时候是有这个字段的配置,继续判断是删除还是修改,根据 measureVo 这个值中的两个上下限是否同时为null，同时为null就是要删除的，不同时为null就是要修改的
+                if (measureVo.getLowerLimit() == null && measureVo.getUpperLimit() == null) {
+                    deleteList.add(alarmConfig.getId());
+                } else {
+                    //用于修改的
+                    AlarmConfig alarmConfigUpdate = new AlarmConfig();
+                    alarmConfigUpdate.setId(alarmConfig.getId());
+                    //只修改上下限
+                    alarmConfigUpdate.setUpperLimit(measureVo.getUpperLimit());
+                    alarmConfigUpdate.setLowerLimit(measureVo.getLowerLimit());
+                    updateList.add(alarmConfigUpdate);
+                    AlarmConfig alarmConfigTotalUpdate = new AlarmConfig();
+                    BeanUtils.copyProperties(alarmConfig,alarmConfigTotalUpdate);
+                    alarmConfigTotalUpdate.setUpperLimit(measureVo.getUpperLimit());
+                    alarmConfigTotalUpdate.setLowerLimit(measureVo.getLowerLimit());
+                    alarmConfigTotalUpdate.setUpdateTime(now);
+                    updateAllList.add(alarmConfigTotalUpdate);
+                }
+            }
+        }
+        //此时新增的集合还缺少基础信息,需要根据ids从字段定义表中查询
+        //对新增、删除、修改的进行统一操作
+        List<AlarmConfig> addAllList = new ArrayList<>();
+        if (!defineIds.isEmpty()) {
+            List<DeviceColDefine> deviceColDefines = deviceColDefineMapper.selectByIdList(defineIds, addReq.getDeviceType());
+            if (!deviceColDefines.isEmpty()) {
+                Map<Integer, DeviceColDefine> defineMap = deviceColDefines.stream().collect(Collectors.toMap(DeviceColDefine::getId, deviceColDefine -> deviceColDefine));
+                for (AlarmConfig alarmConfig : addNewList) {
+                    Integer key = alarmConfig.getColDefineId();
+                    if (defineMap.containsKey(key)) {
+                        DeviceColDefine deviceColDefine = defineMap.get(key);
+                        alarmConfig.setCol(deviceColDefine.getCol());
+                        alarmConfig.setColName(deviceColDefine.getColName());
+                        alarmConfig.setDeviceTypeId(deviceColDefine.getDeviceTypeId());
+                        alarmConfig.setDeviceType(addReq.getDeviceType());
+                        alarmConfig.setDeviceName(deviceColDefine.getDeviceName());
+                    }
+                }
+                log.info("addNewList:{}", addNewList);
+                alarmConfigMapper.insertBatch(addNewList);
+                addAllList.addAll(addNewList);
+            }
+        }
+        log.info("deleteList:{}", deleteList);
+        if (!deleteList.isEmpty()) {
+            alarmConfigMapper.deleteBatch(deleteList);
+        }
+        log.info("updateList:{}", updateList);
+        if (!updateList.isEmpty()) {
+            for (AlarmConfig alarmConfig : updateList) {
+                alarmConfigMapper.updateByPrimaryKeySelective(alarmConfig);
+            }
+            addAllList.addAll(updateAllList);
+        }
+        String key = RedisKeyConstant.ALARM.GROUP_ALARM_CONFIG + addReq.getGroupId() + ":"+ addReq.getScope() + ":" + addReq.getDeviceType();
+        if (FlowConstant.AlarmConfig.SCOPE_STATION.equals(addReq.getScope())) {
+            key = RedisKeyConstant.ALARM.COMPANY_ALARM_CONFIG + addReq.getGroupId() + ":"+ addReq.getStationId() + ":" + addReq.getDeviceType();
+        }
+        if(!map.isEmpty()){
+            deleteAlarmRedis(map, key);
+        }
+        if(!addAllList.isEmpty()){
+            addAlarmRedis(addAllList, key);
+        }
+    }
+
+    @Override
+    public void deletedById(Integer id) {
+        AlarmConfig alarmConfig = alarmConfigMapper.selectById(id);
+        alarmConfig.setDeleted(CommonConstant.DELETED_FLAG);
+        alarmConfig.setUpdateTime(new Date());
+        alarmConfigMapper.updateByPrimaryKeySelective(alarmConfig);
+
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void deleteSignalBatch(AlarmBatchDeleteReq deleteReq) {
+        //先查到alarm表中用于删除的数据,然后把id组装成ids进行删除
+        AlarmConfigPageReqVo queryReq = new AlarmConfigPageReqVo();
+        queryReq.setGroupId(deleteReq.getGroupId());
+        queryReq.setDeviceType(deleteReq.getDeviceType());
+        queryReq.setScope(deleteReq.getScope());
+        queryReq.setColIds(deleteReq.getColIds());
+        //如果是站级就把 stationId塞进去
+        if(FlowConstant.AlarmConfig.SCOPE_STATION.equals(deleteReq.getScope())){
+            queryReq.setStationId(deleteReq.getStationId());
+        }
+        List<AlarmConfig> configList = alarmConfigMapper.selectList(queryReq);
+        if(configList.isEmpty()){
+            log.info("要删除的告警配置数据查询后为空");
+            return ;
+        }
+        List<Integer> idForDeleteList = new ArrayList<>();
+        Map<Integer,Integer> map = new HashMap<>();
+        for (AlarmConfig alarmConfig : configList) {
+            idForDeleteList.add(alarmConfig.getId());
+            map.put(alarmConfig.getId(),alarmConfig.getId());
+        }
+        if(!idForDeleteList.isEmpty()){
+            String key = RedisKeyConstant.ALARM.GROUP_ALARM_CONFIG + deleteReq.getGroupId() + ":"+ deleteReq.getScope() + ":" + deleteReq.getDeviceType();
+            if (FlowConstant.AlarmConfig.SCOPE_STATION.equals(deleteReq.getScope())) {
+                key = RedisKeyConstant.ALARM.COMPANY_ALARM_CONFIG  + deleteReq.getGroupId() + ":"+ deleteReq.getStationId() + ":" + deleteReq.getDeviceType();
+            }
+            deleteAlarmRedis(map,key);
+            alarmConfigMapper.deleteBatch(idForDeleteList);
+        }
+    }
+
+    @Override
+    public int update(AlarmConfigUpdateReqVo vo) {
+        AlarmConfig alarmConfig = new AlarmConfig();
+        BeanUtils.copyProperties(vo, alarmConfig);
+        alarmConfig.setStationId(null);
+        //电站级别才匹配电站参数,集团级别不用匹配电站参数
+        if (FlowConstant.AlarmConfig.SCOPE_STATION.equals(vo.getScope())) {
+            alarmConfig.setStationId(vo.getStationId());
+        }
+        alarmConfig.setUpdateTime(new Date());
+        return alarmConfigMapper.updateByParams(alarmConfig);
+    }
+
+    @Override
+    public int syAlarmConfig(SynchronousReqVo vo) {
+        try{
+            Integer stationId = vo.getStationId();
+            //查询告警配置定义
+            DeviceColDefineReqVo definePageReq = new DeviceColDefineReqVo();
+            definePageReq.setDeviceTypeSuffix(CommonConstant.JOIN_STATION_ID+stationId);
+            List<DeviceColDefine> resultList = deviceColDefineService.selectList(definePageReq);
+            //同步告警配置
+            AlarmConfigPageReqVo alarmConfig = new AlarmConfigPageReqVo();
+            alarmConfig.setDeviceTypeSuffix(CommonConstant.JOIN_STATION_ID+vo.getModelStationId());
+            List<AlarmConfig> alarmList = alarmConfigMapper.selectList(alarmConfig);
+            if(!alarmList.isEmpty()){
+                Map<String, Integer> modelMap = resultList.stream().collect(Collectors.toMap(s -> s.getDeviceType() + CommonConstant.JOIN + s.getCol(), t -> t.getId(), (k1, k2) -> k1));
+                List<AlarmConfig> insetList = new ArrayList<>();
+                AlarmConfig ac = null;
+                for (AlarmConfig alarm:alarmList) {
+                    ac = new AlarmConfig();
+                    BeanUtils.copyProperties(alarm,ac);
+                    String type = alarm.getDeviceType().replace(CommonConstant.JOIN + vo.getModelStationId(), CommonConstant.JOIN + stationId);
+                    ac.setColDefineId(modelMap.get(type+ CommonConstant.JOIN + alarm.getCol()));
+                    ac.setDeviceType(type);
+                    if(alarm.getStationId()!=null){
+                        ac.setStationId(stationId);
+                    }
+                    insetList.add(ac);
+                }
+                if(!insetList.isEmpty()){
+                    int result = alarmConfigMapper.deleteByParam(stationId, CommonConstant.JOIN + stationId);
+                    log.info("删除旧的告警配置,电站：{},结果：{}",stationId,result);
+                    List<List<AlarmConfig>> partition = Lists.partition(insetList, CommonConstant.NINE_HUNDRED_AND_NINETY_NINE);
+                    for (List<AlarmConfig> list:partition) {
+                        alarmConfigMapper.insertBatch(insetList);
+                    }
+                }
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+            log.info("同步告警配置发生异常：{}",e.getMessage());
+        }
+        return 0;
+    }
+
+    /**
+     * 删除缓存中的告警配置
+     * @param map
+     * @param key
+     */
+    private void deleteAlarmRedis(Map<Integer, Integer> map, String key) {
+        List<AlarmConfig> alarmList = (List<AlarmConfig>)redisService.get(key);
+        if(alarmList!=null){
+            alarmList = alarmList.stream().filter(i-> map.get(i.getId())==null).collect(Collectors.toList());
+            if(alarmList.size()==0){
+                redisService.delete(key);
+            }else{
+                redisService.set(key,alarmList);
+                redisService.expire(key,1, TimeUnit.HOURS);
+            }
+        }
+    }
+
+    /**
+     * 增加缓存中的告警配置
+     * @param configList
+     * @param key
+     */
+    private void addAlarmRedis(List<AlarmConfig> configList, String key) {
+        List<AlarmConfig> alarmList = (List<AlarmConfig>)redisService.get(key);
+        if(alarmList!=null){
+            alarmList.addAll(configList);
+        }else{
+            alarmList = configList;
+        }
+        redisService.set(key,alarmList);
+        redisService.expire(key,1, TimeUnit.HOURS);
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/service/impl/DeviceColDefineServiceImpl.java

@@ -0,0 +1,343 @@
+package com.ho.flow.service.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.ho.business.entity.DeviceTypeCol;
+import com.ho.business.entity.DeviceTypeConfig;
+import com.ho.business.vo.DeviceTypeList;
+import com.ho.business.vo.req.device.DeviceTypeQuery;
+import com.ho.business.vo.req.deviceModel.SynchronousReqVo;
+import com.ho.business.vo.req.deviceTypeCol.DeviceTypeColQueryVo;
+import com.ho.common.tools.constant.CommonConstant;
+import com.ho.common.tools.exception.BaseResponseCode;
+import com.ho.common.tools.exception.BusinessException;
+import com.ho.common.tools.util.PageResult;
+import com.ho.common.tools.util.PageUtils;
+import com.ho.flow.feignclient.BusinessFeignClient;
+import com.ho.flow.mapper.AlarmConfigMapper;
+import com.ho.flow.mapper.DeviceColDefineMapper;
+import com.ho.flow.service.AlarmConfigService;
+import com.ho.flow.service.DeviceColDefineService;
+import com.ho.flow.vo.AlarmConfig;
+import com.ho.flow.vo.DeviceColDefine;
+import com.ho.flow.vo.req.AlarmConfig.AlarmConfigPageReqVo;
+import com.ho.flow.vo.req.AlarmConfig.DeviceColDefineReqVo;
+import com.ho.flow.vo.req.devicecoldefine.DeviceColDefineDeleteVO;
+import com.ho.flow.vo.req.devicecoldefine.DeviceColDefineModifyVO;
+import com.ho.flow.vo.req.devicecoldefine.DeviceColDefineReqVO;
+import com.ho.flow.vo.req.devicecoldefine.DeviceColDefineSyncVO;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * @author gyan
+ * @desc:
+ * @DateTime: 2023/2/1 16:45
+ */
+@Service
+@Slf4j
+public class DeviceColDefineServiceImpl implements DeviceColDefineService {
+    @Autowired
+    DeviceColDefineMapper deviceColDefineMapper;
+
+    @Autowired
+    BusinessFeignClient businessFeignClient;
+
+    @Autowired
+    AlarmConfigMapper alarmConfigMapper;
+
+    @Autowired
+    AlarmConfigService alarmConfigService;
+
+    @Override
+    public PageResult<DeviceColDefine> selectPage(DeviceColDefineReqVo definePageReq) {
+        PageHelper.startPage(definePageReq.getPageNum(), definePageReq.getPageSize());
+        List<DeviceColDefine> deviceColDefinePageResult = deviceColDefineMapper.selectPage(definePageReq);
+        PageResult pageResult = PageUtils.getPageResult(new PageInfo<>(deviceColDefinePageResult));
+        return pageResult;
+
+    }
+
+    @Override
+    public DeviceColDefine selectByColAndDeviceType(String Col, String deviceType) {
+        DeviceColDefine deviceColDefine = deviceColDefineMapper.selectByColAndDeviceType(Col, deviceType);
+        return deviceColDefine;
+    }
+
+    @Override
+    public List<DeviceColDefine> selectList(DeviceColDefineReqVo definePageReq) {
+        List<DeviceColDefine> list = deviceColDefineMapper.selectPage(definePageReq);
+        return list;
+    }
+
+    @Override
+    public DeviceColDefine selectById(Integer id) {
+        DeviceColDefine deviceColDefine = deviceColDefineMapper.selectById(id);
+        return deviceColDefine;
+    }
+
+    @Override
+    public List<DeviceColDefine> selectByIdList(List<Integer> ids, String deviceType) {
+        List<DeviceColDefine> deviceColDefines = deviceColDefineMapper.selectByIdList(ids, deviceType);
+        return deviceColDefines;
+    }
+
+    public DeviceColDefineServiceImpl() {
+        super();
+    }
+
+    @Override
+    public DeviceColDefine selectByIdAndDeviceTypeId(Integer id, Integer deviceTypeId) {
+        DeviceColDefine deviceColDefine = deviceColDefineMapper.selectByIdAndDeviceTypeId(id, deviceTypeId);
+        return deviceColDefine;
+    }
+
+    @Override
+    public int insertList(List<DeviceColDefineReqVO> list) {
+        //以deviceType分组
+        DeviceColDefine deviceCol = null;
+        Map<Integer, List<DeviceColDefine>> addMap = new HashMap<>();
+        Map<Integer, List<DeviceColDefine>> updateMap = new HashMap<>();
+        List<DeviceColDefine> addList = new ArrayList<>();
+        List<DeviceColDefine> updateList = new ArrayList<>();
+        Integer num = 1;
+        Integer updateNum = 1;
+        Map<String, List<DeviceColDefineReqVO>> deviceMap = list.stream().collect(Collectors.groupingBy(DeviceColDefineReqVO::getDeviceType));
+        List<String> deviceTypeList = deviceMap.keySet().stream().collect(Collectors.toList());
+        DeviceColDefineReqVo vo = new DeviceColDefineReqVo();
+        vo.setDeviceTypeList(deviceTypeList);
+        List<DeviceColDefine> deviceColDefines = deviceColDefineMapper.selectPage(vo);
+        Map<String, DeviceColDefine> isSaveMap = deviceColDefines.stream().collect(Collectors.toMap(i -> i.getDeviceType() + "_" + i.getCol(), deviceColDefine -> deviceColDefine));
+        for (DeviceColDefineReqVO deviceColDefineReqVO : list) {
+            deviceCol = isSaveMap.get(deviceColDefineReqVO.getDeviceType() + "_" + deviceColDefineReqVO.getCol());
+            //走更新
+            if (null != deviceCol) {
+                BeanUtil.copyProperties(deviceColDefineReqVO, deviceCol);
+                updateList.add(deviceCol);
+                if (updateList.size() % 999 == 998) {
+                    updateList = new ArrayList<>();
+                    updateNum++;
+                }
+                updateMap.put(updateNum, updateList);
+            } else {
+                //走新增
+                deviceCol = new DeviceColDefine();
+                BeanUtil.copyProperties(deviceColDefineReqVO, deviceCol);
+                addList.add(deviceCol);
+                if (addList.size() % 999 == 998) {
+                    addList = new ArrayList<>();
+                    num++;
+                }
+                addMap.put(num, addList);
+            }
+        }
+        for (Map.Entry<Integer, List<DeviceColDefine>> m : addMap.entrySet()) {
+            deviceColDefineMapper.insertList(m.getValue());
+        }
+        for (Map.Entry<Integer, List<DeviceColDefine>> m : updateMap.entrySet()) {
+            deviceColDefineMapper.updateList(m.getValue());
+        }
+
+        return 0;
+    }
+
+    @Override
+    public int addDeviceColDefine(DeviceColDefineReqVO vo) {
+        DeviceColDefine deviceCol = new DeviceColDefine();
+        BeanUtil.copyProperties(vo, deviceCol);
+        DeviceColDefineReqVo definePageReq = new DeviceColDefineReqVo();
+        definePageReq.setCol(vo.getCol());
+        definePageReq.setDeviceType(vo.getDeviceType());
+        List<DeviceColDefine> list = deviceColDefineMapper.selectPage(definePageReq);
+        if (list.size() > 0) {
+            throw new BusinessException(BaseResponseCode.STATION_ALREADY_EXISTS);
+        }
+        return deviceColDefineMapper.insertDeviceColDefine(deviceCol);
+    }
+
+    @Override
+    public int modifyDeviceColDefine(DeviceColDefineModifyVO vo) {
+        DeviceColDefine deviceCol = new DeviceColDefine();
+        BeanUtil.copyProperties(vo, deviceCol);
+        return deviceColDefineMapper.updateDeviceColDefine(deviceCol);
+    }
+
+    @Override
+    public int deleteDeviceColDefine(DeviceColDefineDeleteVO vo) {
+        int count = deviceColDefineMapper.deleteDeviceColDefine(vo.getIdList());
+        return count;
+    }
+
+    @Override
+    public int syncNewDeviceColDefine(SynchronousReqVo vo) {
+        String str = null;
+        String newStr = null;
+        List<DeviceColDefine> deviceColDefines = new ArrayList<>();
+        if (vo.getDeviceType() != null) {
+            str = vo.getDeviceType() + "_" + vo.getModelStationId();
+            newStr = vo.getDeviceType() + "_" + vo.getStationId();
+            DeviceColDefineReqVo definePageReq = new DeviceColDefineReqVo();
+            definePageReq.setDeviceType(str);
+            deviceColDefines = deviceColDefineMapper.selectPage(definePageReq);
+        } else {
+            deviceColDefines = deviceColDefineMapper.selectByDeviceType(CommonConstant.JOIN_STATION_ID+vo.getModelStationId());
+
+        }
+        List<DeviceColDefine> stationList = deviceColDefineMapper.selectByDeviceType(CommonConstant.JOIN_STATION_ID+vo.getStationId());
+        if (deviceColDefines.size() > 0) {
+            for (DeviceColDefine deviceColDefine : deviceColDefines) {
+                if (newStr == null) {
+                    String newDeviceType = deviceColDefine.getDeviceType();
+                    int index = newDeviceType.lastIndexOf("_");
+                    deviceColDefine.setDeviceType(newDeviceType.substring(0, index + 1) + vo.getStationId());
+                } else {
+                    deviceColDefine.setDeviceType(newStr);
+                }
+            }
+            if (!stationList.isEmpty()) {
+                List<Integer> ids = stationList.stream().map(DeviceColDefine::getId).collect(Collectors.toList());
+                deviceColDefineMapper.deleteDeviceColDefine(ids);
+            }
+            deviceColDefineMapper.insertList(deviceColDefines);
+        }
+        return 0;
+    }
+
+    @Override
+    public int syncDeviceColDefine(DeviceColDefineSyncVO definePageReq) {
+        DeviceTypeColQueryVo vo = new DeviceTypeColQueryVo();
+        vo.setDeviceType(definePageReq.getDeviceType());
+        vo.setStationId(definePageReq.getStationId());
+        List<DeviceTypeCol> deviceTypeCols = businessFeignClient.selectDeviceTypeCol(vo);
+
+        List<DeviceColDefineReqVO> list = new ArrayList<>();
+        DeviceColDefineReqVO dcd = null;
+        for (DeviceTypeCol deviceTypeCol : deviceTypeCols) {
+            dcd = new DeviceColDefineReqVO();
+            dcd.setDeviceName(deviceTypeCol.getDeviceTypeName());
+            dcd.setDeviceType(deviceTypeCol.getDeviceType());
+            dcd.setCol(deviceTypeCol.getCol());
+            dcd.setColEn(deviceTypeCol.getColEn());
+            dcd.setColName(deviceTypeCol.getColName());
+            dcd.setSensType(deviceTypeCol.getSensType());
+            //若是遥信
+            if (CommonConstant.ONE.equals(deviceTypeCol.getSensType())) {
+                dcd.setInfo0(deviceTypeCol.getColName() + CommonConstant.Info.QUANTILE);
+                dcd.setInfo1(deviceTypeCol.getColName() + CommonConstant.Info.CLOSED_POSITION);
+            }
+            list.add(dcd);
+        }
+        if (list.size() > 0) {
+            insertList(list);
+        }
+        return 0;
+    }
+
+
+    @Override
+    public int deviceColDefine(List<DeviceTypeCol> deviceTypeCols) {
+        try {
+            List<DeviceColDefineReqVO> list = new ArrayList<>();
+            DeviceColDefineReqVO dcd = null;
+            for (DeviceTypeCol deviceTypeCol : deviceTypeCols) {
+                dcd = new DeviceColDefineReqVO();
+                dcd.setDeviceName(deviceTypeCol.getDeviceTypeName());
+                dcd.setDeviceType(deviceTypeCol.getDeviceType());
+                dcd.setCol(deviceTypeCol.getCol());
+                dcd.setColName(deviceTypeCol.getColName());
+                dcd.setSensType(deviceTypeCol.getSensType());
+                //若是遥信
+                if (CommonConstant.ONE.equals(deviceTypeCol.getSensType())) {
+                    dcd.setInfo0(deviceTypeCol.getColName() + CommonConstant.Info.QUANTILE);
+                    dcd.setInfo1(deviceTypeCol.getColName() + CommonConstant.Info.CLOSED_POSITION);
+                }
+                list.add(dcd);
+            }
+            if (list.size() > 0) {
+                insertList(list);
+            }
+        } catch (Exception e) {
+            log.error("同步告警配置,{}", e.getMessage());
+            e.printStackTrace();
+        }
+        return 0;
+    }
+
+    @Override
+    public void syncAlarmConfigList(DeviceTypeList deviceTypeList) {
+        try {
+            List<DeviceTypeCol> deviceTypeCols = deviceTypeList.getList();
+            Map<String, List<DeviceTypeCol>> collect = deviceTypeCols.stream().collect(Collectors.groupingBy(i -> i.getDeviceType()));
+            String deviceType = deviceTypeCols.get(0).getDeviceType();
+            int i = deviceType.lastIndexOf("_");
+            String stationIdValue = deviceType.substring(i + 1, deviceType.length());
+            Integer stationId = Integer.valueOf(stationIdValue);
+            Set<String> keySet = collect.keySet();
+            List<String> typeList = keySet.stream().collect(Collectors.toList());
+            //获取已配置告警
+            AlarmConfigPageReqVo vo = new AlarmConfigPageReqVo();
+            vo.setScope(CommonConstant.TWO);
+            vo.setStationId(stationId);
+            vo.setDeviceTypeList(typeList);
+            List<AlarmConfig> configList = alarmConfigService.selectList(vo);
+            Map<String, AlarmConfig> configMap = configList.stream().collect(Collectors.toMap(k -> k.getDeviceType() + "_" + k.getCol(), Function.identity(), (k1, k2) -> k2));
+            //获取告警定义
+            DeviceColDefineReqVo defineReqVo = new DeviceColDefineReqVo();
+            defineReqVo.setDeviceTypeList(typeList);
+            List<DeviceColDefine> colDefineList = selectList(defineReqVo);
+            Map<String, DeviceColDefine> colDefineMap = colDefineList.stream().collect(Collectors.toMap(k -> k.getDeviceType() + "_" + k.getCol(), Function.identity(), (k1, k2) -> k2));
+
+            List<AlarmConfig> addList = new ArrayList<>();
+            List<AlarmConfig> updateList = new ArrayList<>();
+            DeviceColDefine deviceColDefine = null;
+            Date now = new Date();
+            for (DeviceTypeCol deviceTypeCol : deviceTypeCols) {
+                AlarmConfig alarm = configMap.get(deviceTypeCol.getDeviceType() + "_" + deviceTypeCol.getCol());
+                deviceColDefine = colDefineMap.get(deviceTypeCol.getDeviceType() + "_" + deviceTypeCol.getCol());
+                if (null == alarm) {
+                    alarm = new AlarmConfig();
+                    alarm.setGroupId(deviceTypeList.getGroupId());
+                    alarm.setStationId(stationId);
+                    alarm.setScope(CommonConstant.TWO);
+                    alarm.setColDefineId(deviceColDefine.getId());
+                    alarm.setDeviceTypeId(deviceColDefine.getDeviceTypeId());
+                    alarm.setDeviceName(deviceColDefine.getDeviceName());
+                    alarm.setDeviceType(deviceColDefine.getDeviceType());
+                    alarm.setCol(deviceColDefine.getCol());
+                    alarm.setColName(deviceColDefine.getColName());
+                    alarm.setSensType(deviceColDefine.getSensType());
+                    alarm.setInfo0(deviceColDefine.getInfo0());
+                    alarm.setInfo1(deviceColDefine.getInfo1());
+                    alarm.setAlarmLevel(deviceTypeCol.getAlarmLevel());
+                    alarm.setCreateTime(now);
+                    alarm.setDeleted(CommonConstant.ONE);
+                    addList.add(alarm);
+                } else {
+                    alarm.setDeviceName(deviceTypeCol.getDeviceTypeName());
+                    alarm.setInfo0(deviceColDefine.getInfo0());
+                    alarm.setInfo1(deviceColDefine.getInfo1());
+                    alarm.setAlarmLevel(deviceTypeCol.getAlarmLevel());
+                    alarm.setUpperLimit(deviceTypeCol.getMaxValue());
+                    alarm.setLowerLimit(deviceTypeCol.getMinValue());
+                    alarm.setUpdateTime(now);
+                    updateList.add(alarm);
+                }
+            }
+            if (addList.size() > 0) {
+                alarmConfigMapper.insertBatch(addList);
+            }
+            if (updateList.size() > 0) {
+                alarmConfigMapper.updateBatch(updateList);
+            }
+        } catch (Exception e) {
+            log.error("同步告警数据,{}", e.getMessage());
+            e.printStackTrace();
+        }
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/service/impl/FlowWorkOrderServiceImpl.java

@@ -0,0 +1,146 @@
+package com.ho.flow.service.impl;
+
+import com.ho.common.tools.exception.BaseResponseCode;
+import com.ho.common.tools.exception.BusinessException;
+import com.ho.flow.service.FlowWorkOrderService;
+import lombok.extern.slf4j.Slf4j;
+import org.activiti.engine.RuntimeService;
+import org.activiti.engine.TaskService;
+import org.activiti.engine.runtime.ProcessInstance;
+import org.activiti.engine.task.Task;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author fancl
+ * @desc: 流程实现类
+ * @date 2023/1/25
+ */
+@Service
+@Slf4j
+public class FlowWorkOrderServiceImpl implements FlowWorkOrderService {
+
+    @Autowired
+    RuntimeService runtimeService;
+
+    @Autowired
+    TaskService taskService;
+
+    @Override
+    public ProcessInstance startProcess(String processDefinitionKey, String businessKey, Map<String, Object> variables, String tenantId) {
+        ProcessInstance processInstance = runtimeService.startProcessInstanceByKeyAndTenantId(processDefinitionKey, businessKey, variables, tenantId);
+        return processInstance;
+    }
+
+    //查询待分配或待审核的任务列表
+    //因为待分配和待审核都是按照流程发起时 stationId 来赋值,所以需要根据所对应的工单状态来确定是哪个
+    @Override
+    public Map<String, String> queryToBeDoneMap(String category, String assignType, List<String> candidateUsers, List<String> stationIds, String tenantId) {
+        Map<String, String> businessKeyMap = new HashMap<>();
+        //查询代办,没有代办返回空
+        List<Task> taskList = taskService.createTaskQuery()
+                .taskTenantId(tenantId)
+                //目前创建工作流时没有找到category的赋值方法,后续再研究
+                //.taskCategory(category)
+                .taskCandidateUser(assignType,candidateUsers)
+                .taskCandidateGroupIn(stationIds).list();
+        if (taskList == null || taskList.isEmpty()) {
+            return businessKeyMap;
+        }
+        for (Task task : taskList) {
+            String processInstanceId = task.getProcessInstanceId();
+            //从流程实例查询到对应的业务key
+            ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
+            String businessKey = processInstance.getBusinessKey();
+            businessKeyMap.put(businessKey, task.getId());
+        }
+        return businessKeyMap;
+    }
+
+    //个人任务列表
+    //返回对应businessKeyList
+    @Override
+    public Map<String, String> queryPersonalTask(String category, String assignee, String tenantId) {
+        Map<String, String> businessKeyMap = new HashMap<>();
+        List<Task> taskList = taskService.createTaskQuery()
+                .taskTenantId(tenantId)
+                .taskCategory(category)
+                .taskAssignee(assignee)
+                .list();
+        if (taskList == null || taskList.isEmpty()) {
+            return businessKeyMap;
+        }
+        for (Task task : taskList) {
+            String processInstanceId = task.getProcessInstanceId();
+            //从流程实例查询到对应的业务key
+            ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
+            String businessKey = processInstance.getBusinessKey();
+            businessKeyMap.put(businessKey, task.getId());
+        }
+        return businessKeyMap;
+
+    }
+
+
+    //得到业务id 集合
+    @Override
+    public List<String> getOrderIdList(Map<String, String> toDistributeMap, Map<String, String> toDoMap, Map<String, String> toCheckMap) {
+        List<String> orderList = new ArrayList<>();
+        toDistributeMap.forEach((k ,v)->{
+            orderList.add(k);
+        });
+
+        toDoMap.forEach((k ,v)->{
+            orderList.add(k);
+        });
+        toCheckMap.forEach((k ,v)->{
+            orderList.add(k);
+        });
+        return orderList;
+    }
+
+    @Override
+    public void completeTask(String taskId, Map<String, Object> variables) {
+        //先查询任务,如果任务不存在,提示错误
+        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
+        if(task ==null){
+            throw  new BusinessException(BaseResponseCode.TASK_NOT_EXISTS);
+        }
+        try{
+            taskService.complete(taskId, variables);
+        }catch (Exception e){
+            log.error("completeTask Error :" +e.getMessage());
+        }
+        log.info("completeTask, taskId:{} ,variables:{}", taskId, variables);
+    }
+
+    @Override
+    public boolean matchPermit(List<String> positions, String[] postConfig) {
+        //两个集合中有一个匹配到就有权限
+        for (String post : postConfig) {
+            for (String position : positions) {
+                if(position.equals(post)){
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public List<String> intToString(List<Integer> intList) {
+        List<String> strList = new ArrayList<>();
+        if(intList==null || intList.isEmpty()){
+            return strList;
+        }
+        for (Integer integerObj : intList) {
+            strList.add(integerObj.toString());
+        }
+        return strList;
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/service/impl/ProcessFlowServiceImpl.java

@@ -0,0 +1,918 @@
+package com.ho.flow.service.impl;
+
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.lang.Snowflake;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.ho.common.tools.constant.CommonConstant;
+import com.ho.common.tools.entity.SimpleUser;
+import com.ho.common.tools.exception.BaseResponseCode;
+import com.ho.common.tools.exception.BusinessException;
+import com.ho.common.tools.exception.DataResult;
+import com.ho.flow.common.FlowTool;
+import com.ho.flow.constant.WorkOrderConstant;
+import com.ho.flow.entity.WorkOrderSub;
+import com.ho.flow.entity.WorkOrderPlan;
+import com.ho.flow.feignclient.UserFeignClient;
+import com.ho.flow.mapper.WorkOrderSubMapper;
+import com.ho.flow.service.ProcessFlowService;
+import com.ho.flow.service.WorkOrderService;
+import com.ho.flow.vo.req.workorder.*;
+import com.ho.flow.vo.resp.workorder.FallBackTaskResp;
+import com.ho.flow.vo.resp.workorder.HisTaskResp;
+import com.ho.flow.vo.resp.workorder.TaskDone;
+import com.ho.flow.vo.resp.workorder.WorkOrderRespVO;
+import com.ho.user.api.entity.SysSubDict;
+import com.ho.user.api.entity.SysUser;
+import com.ho.user.api.vo.req.QueryUserReqVO;
+import lombok.extern.slf4j.Slf4j;
+import org.activiti.bpmn.model.*;
+import org.activiti.engine.HistoryService;
+import org.activiti.engine.RepositoryService;
+import org.activiti.engine.RuntimeService;
+import org.activiti.engine.TaskService;
+import org.activiti.engine.history.HistoricTaskInstance;
+import org.activiti.engine.history.HistoricVariableInstance;
+import org.activiti.engine.repository.Deployment;
+import org.activiti.engine.runtime.ProcessInstance;
+import org.activiti.engine.task.Task;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * @author fancl
+ * @desc: 工作流实现类
+ * @date 2023/2/5
+ */
+@Service
+@Slf4j
+public class ProcessFlowServiceImpl implements ProcessFlowService {
+
+    //工作流 定义的处理类
+    @Autowired
+    RuntimeService runtimeService;
+
+    @Autowired
+    HistoryService historyService;
+
+    @Autowired
+    RepositoryService repositoryService;
+
+    //工作流 Task处理类
+    @Autowired
+    TaskService taskService;
+
+    @Autowired
+    WorkOrderService workOrderService;
+
+    @Autowired
+    WorkOrderSubMapper workOrderSubMapper;
+
+    @Autowired
+    UserFeignClient userFeignClient;
+
+    @Autowired
+    FlowTool flowTool;
+
+    @Autowired
+    Snowflake snowflake;
+
+    //流程定义的key
+    @Value("${flow.workOrder.procDefKey}")
+    String procDefKey;
+
+    //根据taskId查询任务
+    @Override
+    public Task getTaskById(TaskUserReq taskUserReq) {
+        //1.代办人是自己的
+        String tenantId = String.valueOf(taskUserReq.getTenantId());
+        Task task = taskService.createTaskQuery()
+                .processDefinitionKey(procDefKey)
+                .processInstanceId(taskUserReq.getProcessInstId())
+                //.processVariableValueEquals(WorkOrderConstant.orderType, "workOrder")
+                .taskTenantId(tenantId)
+                .singleResult();
+        return task;
+    }
+
+    /**
+     * 代办列表
+     * 数据来自以下几个部分：
+     * 1.处理人是自己的 2.候选人中有自己
+     *
+     * @param simpleUser
+     * @return
+     */
+    @Override
+    public Map<String, List<Task>> getTodoList(SimpleUser simpleUser) {
+        //1.代办人是自己的
+        String tenantId = String.valueOf(simpleUser.getGroupId());
+        String assignee = simpleUser.getUserId();
+        List<Task> assigneeTaskList = taskService.createTaskQuery()
+                .processDefinitionKey(procDefKey)
+                //.processVariableValueEquals(WorkOrderConstant.orderType, "workOrder")
+                .taskTenantId(tenantId)
+                .taskAssignee(assignee)
+                .list();
+        //2.查候选人有自己的
+        List<Task> candidateTaskList = taskService.createTaskQuery()
+                .processDefinitionKey(procDefKey)
+                //.processVariableValueEquals(WorkOrderConstant.orderType, "workOrder")
+                .taskTenantId(tenantId)
+                //候选人有自己的
+                .taskCandidateUser(assignee)
+                .list();
+        //集合合并
+        Map<String, List<Task>> taskMap = new HashMap<>();
+
+        taskMap.put(WorkOrderConstant.WorkOrderStatus.notProcessed, candidateTaskList);
+        taskMap.put(WorkOrderConstant.WorkOrderStatus.processing, assigneeTaskList);
+        return taskMap;
+    }
+
+    //查任务附属信息进行填充
+    @Override
+    public List<TaskDone> getToDoListFromTask(Map<String, List<Task>> taskMap, DoListTaskReq doListTaskReq) {
+        //创建返回结果对象
+        List<TaskDone> doneList = new ArrayList<>();
+
+        //对任务的状态分别处理
+        if (taskMap.containsKey(WorkOrderConstant.WorkOrderStatus.processing)) {
+            List<Task> processingList = taskMap.get(WorkOrderConstant.WorkOrderStatus.processing);
+            //处理中的任务
+            for (Task task : processingList) {
+                String processInstanceId = task.getProcessInstanceId();
+                WorkOrderRespVO workOrder = new WorkOrderRespVO();
+                if (doListTaskReq != null && doListTaskReq.getTitle() != null) {
+                    workOrder = workOrderService.findByProcInstIdAndTitle(processInstanceId, doListTaskReq.getTitle());
+                } else {
+                    workOrder = workOrderService.findByProcInstId(processInstanceId);
+                }
+                if (workOrder != null) {
+                    TaskDone taskDone = new TaskDone();
+                    taskDone.setId(workOrder.getId().toString());
+                    taskDone.setOrderType(workOrder.getOrderType());
+                    taskDone.setTitle(workOrder.getTitle());
+                    taskDone.setPlanTitle(workOrder.getPlanTitle());
+                    //根据任务id和流程id查询节点变量
+                    HistoricVariableInstance historicVariableInstance = historyService.createHistoricVariableInstanceQuery()
+                            .taskId(task.getId())
+                            .processInstanceId(task.getProcessInstanceId())
+                            .variableName(WorkOrderConstant.sender)
+                            .singleResult();
+                    if (historicVariableInstance != null) {
+                        Object value = historicVariableInstance.getValue();
+                        if (value.toString() != null) {
+                            //根据用户id查询用户名称
+                            taskDone.setStartUserId(value.toString());
+                            DataResult<SysUser> user = userFeignClient.getUserById(value.toString());
+                            if (user.getData() != null) {
+                                taskDone.setStartUserName(user.getData().getRealName());
+                            }
+                        }
+                    }
+                    taskDone.setStartTime(task.getCreateTime());
+                    taskDone.setProcessInstanceId(task.getProcessInstanceId());
+                    //查询字典表中优先级的值
+
+                    Integer priority = workOrder.getPriority();
+                    if (priority != null) {
+                        DataResult<SysSubDict> result = userFeignClient.getDictById(priority);
+                        if (result.getData() != null) {
+                            taskDone.setPriority(result.getData().getValue());
+                        } else {
+                            //设置为1，避免空指针
+                            taskDone.setPriority("1");
+                        }
+                    }
+                    //任务状态统一设置为代办
+                    taskDone.setStatus(WorkOrderConstant.WorkOrderStatus.processing);
+                    doneList.add(taskDone);
+                }
+            }
+        }
+        //未处理的任务
+        if (taskMap.containsKey(WorkOrderConstant.WorkOrderStatus.notProcessed)) {
+            List<Task> notProcessedList = taskMap.get(WorkOrderConstant.WorkOrderStatus.notProcessed);
+            //处理中的任务
+            for (Task task : notProcessedList) {
+                String processInstanceId = task.getProcessInstanceId();
+                WorkOrderRespVO workOrder = new WorkOrderRespVO();
+                if (doListTaskReq != null && doListTaskReq.getTitle() != null) {
+                    workOrder = workOrderService.findByProcInstIdAndTitle(processInstanceId, doListTaskReq.getTitle());
+                } else {
+                    workOrder = workOrderService.findByProcInstId(processInstanceId);
+                }
+                if (workOrder != null) {
+                    TaskDone taskDone = new TaskDone();
+                    taskDone.setId(workOrder.getId().toString());
+                    taskDone.setOrderType(workOrder.getOrderType());
+                    taskDone.setTitle(workOrder.getTitle());
+                    taskDone.setPlanTitle(workOrder.getPlanTitle());
+                    taskDone.setStartTime(task.getCreateTime());
+                    //根据任务id和流程id查询节点变量
+                    HistoricVariableInstance historicVariableInstance = historyService.createHistoricVariableInstanceQuery()
+                            .taskId(task.getId())
+                            .processInstanceId(task.getProcessInstanceId())
+                            .variableName(WorkOrderConstant.sender)
+                            .singleResult();
+                    if (historicVariableInstance != null) {
+                        Object value = historicVariableInstance.getValue();
+                        if (value.toString() != null) {
+                            //根据用户id查询用户名称
+                            DataResult<SysUser> user = userFeignClient.getUserById(value.toString());
+                            if (user.getData() != null) {
+                                taskDone.setStartUserName(user.getData().getRealName());
+                            }
+                        }
+                        if (workOrder.getPriority() != null) {
+                            DataResult<SysSubDict> result = userFeignClient.getDictById(workOrder.getPriority());
+                            if (result.getData() != null) {
+                                taskDone.setPriority(result.getData().getValue());
+                            }
+                        }
+                    }
+                    taskDone.setProcessInstanceId(task.getProcessInstanceId());
+                    //任务状态统一设置为未处理
+                    taskDone.setStatus(WorkOrderConstant.WorkOrderStatus.notProcessed);
+                    doneList.add(taskDone);
+                }
+            }
+        }
+        return doneList;
+    }
+
+
+    //保存工单并发起工单流程
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public String saveOrderAndStartProcess(WorkOrderAddReqVO workOrderAddReqVO) {
+        //生成id和工单号
+        String nextWorkOrderId = flowTool.getNextWorkOrderId(WorkOrderConstant.IdTypeWorkOrder);
+        log.info("工单号: {}", nextWorkOrderId);
+        //发起一个流程
+        //tenantId
+        String tenantId = String.valueOf(workOrderAddReqVO.getGroupId());
+        //流程变量,包括工单类型, 站id
+        Map<String, Object> variables = new HashMap<>(16);
+        //工单类型 保存后不可修改
+        variables.put(WorkOrderConstant.orderType, workOrderAddReqVO.getOrderType());
+        //电站 保存后不可以修改
+        variables.put(WorkOrderConstant.stationId, workOrderAddReqVO.getStationId());
+        //发起人
+        variables.put(WorkOrderConstant.startUser, workOrderAddReqVO.getUserId());
+        //发送人
+        variables.put(WorkOrderConstant.sender, workOrderAddReqVO.getUserId());
+        try {
+            //为了工单和流程相互关联,先生成流程数据再生成工单数据
+            ProcessInstance processInstance = runtimeService
+                    .startProcessInstanceByKeyAndTenantId(procDefKey, nextWorkOrderId, variables, tenantId);
+            //流程实例id
+            String processInstanceId = processInstance.getProcessInstanceId();
+            log.info("工单流程实例id: {}", processInstanceId);
+            long nextId = snowflake.nextId();
+            workOrderAddReqVO.setId(nextId);
+            workOrderAddReqVO.setOrderId(nextWorkOrderId);
+            //工单关联流程实例id
+            workOrderAddReqVO.setProcessId(processInstanceId);
+            //设置任务主题
+            String planTitle = workOrderAddReqVO.getPlanTitle();
+            workOrderAddReqVO.setTitle(planTitle);
+            //默认值
+            workOrderAddReqVO.setDeleted(CommonConstant.DELETED);
+            //生成一个工单对象
+            workOrderService.add(workOrderAddReqVO);
+            return processInstanceId;
+        } catch (Exception e) {
+            log.error(e.getMessage());
+            throw new BusinessException(BaseResponseCode.WORK_ORDER_ADD_ERROR);
+        }
+
+    }
+
+    /**
+     * 工单详情
+     *
+     * @return
+     */
+    @Override
+    public WorkOrderRespVO getOrderDetail() {
+        return null;
+    }
+
+    //接受任务
+    @Override
+    public void doClaimTask(TaskUserReq taskReq) {
+        Task task = taskService.createTaskQuery().processInstanceId(taskReq.getProcessInstId())
+                //集团Id一定要带着
+                .taskTenantId(taskReq.getTenantId())
+                .singleResult();
+        //判断任务是否存在,还要判断任务是否已经被认领了
+        if (task != null) {
+            try {
+                taskService.claim(task.getId(), taskReq.getUserId());
+            } catch (Exception e) {
+                log.error("认领任务时出错 ,task:{}, userId: {}", task.getId(), taskReq.getUserId());
+                log.error(e.getMessage());
+                //throw new BusinessException(BaseResponseCode.TASK_ALREADY_CLAIM_BY_OTHER);
+            }
+        }
+    }
+
+    /**
+     * 完成任务
+     */
+    @Override
+    public void doCompleteTask(DoTaskReq doTaskReq) {
+        //先查这个任务
+        Task task = taskService.createTaskQuery()
+                //流程id查询
+                .processInstanceId(doTaskReq.getProcessInstId())
+                //集团id
+                .taskTenantId(doTaskReq.getTenantId())
+                //要使用责任人查询, 避免去做别人的任务
+                //.taskAssignee(taskReq.getAssigneeUser())
+                .singleResult();
+        //如果没查到任务,报错
+        if (task == null) {
+            log.error("对应的任务不存在");
+            throw new BusinessException(BaseResponseCode.TASK_NOT_EXISTS);
+        }
+
+        //判断该任务是否是当前人,不是就报错
+        //todo 后续要打开
+        /*if (!taskReq.getAssigneeUser().equals(task.getAssignee())) {
+            throw new BusinessException(BaseResponseCode.TASK_IS_NOT_YOURS);
+        }*/
+        //下一个节点代办人
+        List<String> candidateUserList = doTaskReq.getCandidateUserList();
+        if (!WorkOrderConstant.TaskNodeName.node4.equals(task.getTaskDefinitionKey())) {
+            if (candidateUserList == null || candidateUserList.isEmpty()) {
+                throw new BusinessException(BaseResponseCode.TASK_CHOICE_CANDIDATE_USER);
+            }
+        }
+        //完成 设置本地环境变量 complete==0
+        Map<String, Object> variables = new HashMap<>();
+        variables.put(WorkOrderConstant.completeKey, WorkOrderConstant.complete);
+        variables.put(WorkOrderConstant.CandidateUser.nodeOneUsers, candidateUserList);
+        //先使用local 设置完成标识变量
+        //始终用这个名字的变量,不然还需要判断当前是第几节点
+        taskService.setVariableLocal(task.getId(), WorkOrderConstant.CandidateUser.nodeOneUsers, candidateUserList);
+        taskService.setVariableLocal(task.getId(), WorkOrderConstant.completeKey, WorkOrderConstant.complete);
+        taskService.setVariableLocal(task.getId(), WorkOrderConstant.suggestion, doTaskReq.getSuggestion());
+        taskService.setVariableLocal(task.getId(), WorkOrderConstant.sender, doTaskReq.getSenderId());
+        try {
+            taskService.complete(task.getId());
+        } catch (Exception e) {
+            log.error("完成任务时出错 ,task:{}, userId: {}", task.getId(), doTaskReq.getAssigneeUser());
+            log.error(e.getMessage());
+        }
+    }
+
+
+    /**
+     * 作废任务
+     *
+     * @param doTaskReq
+     */
+    @Override
+    public void doNullifyTaskTask(DoTaskReq doTaskReq) {
+        //先查这个任务
+        Task task = taskService.createTaskQuery()
+                //用任务id查询
+                .processInstanceId(doTaskReq.getProcessInstId())
+                //集团id
+                .taskTenantId(doTaskReq.getTenantId())
+                //要使用责任人查询, 避免去做别人的任务
+                //.taskAssignee(taskReq.getAssigneeUser())
+                .singleResult();
+        //如果没查到任务,报错
+        if (task == null) {
+            log.error("对应的任务不存在");
+            throw new BusinessException(BaseResponseCode.TASK_NOT_EXISTS);
+        }
+        if (!WorkOrderConstant.TaskNodeName.node1.equals(task.getTaskDefinitionKey())) {
+            log.error("对应的任务不在第一节点");
+            throw new BusinessException(BaseResponseCode.TASK_IS_NOT_FIRST);
+        }
+        //判断该任务是否是当前人,不是就报错
+        //todo 后续要打开
+        /*if (!taskReq.getAssigneeUser().equals(task.getAssignee())) {
+            throw new BusinessException(BaseResponseCode.TASK_IS_NOT_YOURS);
+        }*/
+        //下一个节点代办人
+        List<String> candidateUserList = doTaskReq.getCandidateUserList();
+        //完成 设置本地环境变量 complete==0
+        Map<String, Object> variables = new HashMap<>();
+        variables.put(WorkOrderConstant.completeKey, WorkOrderConstant.complete);
+        variables.put(WorkOrderConstant.CandidateUser.nodeOneUsers, candidateUserList);
+        //先使用local 设置完成标识变量
+        //始终用这个名字的变量,不然还需要判断当前是第几节点
+        taskService.setVariableLocal(task.getId(), WorkOrderConstant.CandidateUser.nodeOneUsers, candidateUserList);
+        taskService.setVariableLocal(task.getId(), WorkOrderConstant.completeKey, WorkOrderConstant.nullifyComplete);
+        taskService.setVariableLocal(task.getId(), WorkOrderConstant.sender, doTaskReq.getAssigneeUser());
+        taskService.setVariableLocal(task.getId(), WorkOrderConstant.suggestion, doTaskReq.getSuggestion());
+        try {
+            taskService.complete(task.getId());
+        } catch (Exception e) {
+            log.error("完成任务时出错 ,task:{}, userId: {}", task.getId(), doTaskReq.getAssigneeUser());
+            log.error(e.getMessage());
+        }
+    }
+
+    /**
+     * 退回任务
+     */
+    @Override
+    public void doRejectTask(RejectTaskReq rejectTaskReq) {
+        //先查这个任务
+        Task task = taskService.createTaskQuery()
+                //用流程id查询
+                .processInstanceId(rejectTaskReq.getProcessInstId())
+                //集团id
+                .taskTenantId(rejectTaskReq.getTenantId())
+                //要使用责任人查询, 避免去做别人的任务
+                //.taskAssignee(taskReq.getAssigneeUser())
+                .singleResult();
+        //如果没查到任务,报错
+        if (task == null) {
+            log.error("对应的任务不存在");
+            throw new BusinessException(BaseResponseCode.TASK_NOT_EXISTS);
+        }
+
+        List<HistoricTaskInstance> list = historyService.createHistoricTaskInstanceQuery()
+                //流程id
+                .processInstanceId(rejectTaskReq.getProcessInstId())
+                //任务定义key
+                .taskDefinitionKey(rejectTaskReq.getTaskDefinitionKey())
+                //集团id
+                .taskTenantId(rejectTaskReq.getTenantId())
+                .list();
+
+        //候选人id集合
+        List<String> candidateUserList = new ArrayList<>();
+        for (HistoricTaskInstance historicTaskInstance : list) {
+            boolean contains = candidateUserList.contains(historicTaskInstance.getAssignee());
+            if (!contains) {
+                candidateUserList.add(historicTaskInstance.getAssignee());
+            }
+        }
+        //获取complete值
+        String complete = rejectTaskReq.getTaskDefinitionKey().substring(1);
+        taskService.setVariableLocal(task.getId(), WorkOrderConstant.CandidateUser.nodeOneUsers, candidateUserList);
+        taskService.setVariableLocal(task.getId(), WorkOrderConstant.completeKey, complete);
+        taskService.setVariableLocal(task.getId(), WorkOrderConstant.suggestion, rejectTaskReq.getSuggestion());
+        taskService.setVariableLocal(task.getId(), WorkOrderConstant.sender, rejectTaskReq.getUserId());
+        try {
+            taskService.complete(task.getId());
+        } catch (Exception e) {
+            log.error("回退任务时出错 ,task:{}", task.getId());
+            log.error(e.getMessage());
+        }
+    }
+
+    @Override
+    public void doDiscardTask(TaskReq taskReq) {
+
+    }
+
+    /**
+     * 获取回退任务列表
+     *
+     * @param fallBackTaskReq
+     */
+    @Override
+    public List<FallBackTaskResp> getFallBackTask(FallBackTaskReq fallBackTaskReq) {
+        //创建返回值对象
+        List<FallBackTaskResp> fallBackTaskRespList = new ArrayList<>();
+        //获取所有历史节点任务
+        List<HistoricTaskInstance> historicTaskInstanceList = historyService.createHistoricTaskInstanceQuery()
+                .processInstanceId(fallBackTaskReq.getProcessInstId())
+                .orderByHistoricTaskInstanceStartTime().asc().list();
+
+        if (historicTaskInstanceList.isEmpty() || historicTaskInstanceList == null) {
+            return fallBackTaskRespList;
+        }
+
+        //先查这个任务
+        Task task = taskService.createTaskQuery()
+                //用任务id查询
+                .processInstanceId(fallBackTaskReq.getProcessInstId())
+                //集团id
+                .taskTenantId(fallBackTaskReq.getTenantId())
+                //要使用责任人查询, 避免去做别人的任务
+                //.taskAssignee(taskReq.getAssigneeUser())
+                .singleResult();
+
+        //判断任务是否存在,还要判断任务是否已经被认领了
+        if (task != null) {
+            try {
+                String taskDefinitionKey = task.getTaskDefinitionKey();
+                //获取当前任务节点的数字
+                String substring = taskDefinitionKey.substring(1);
+                Integer currentNumber = Integer.valueOf(substring);
+
+                Map<String, List<HistoricTaskInstance>> hisTaskMap = historicTaskInstanceList.stream()
+                        //过滤当前任务以后的节点
+                        .filter(s -> {
+                            String number = s.getTaskDefinitionKey().substring(1);
+                            Integer integer = Integer.valueOf(number);
+                            return currentNumber > integer;
+                        })
+                        //转化为以name分组的map
+                        .collect(Collectors.groupingBy(HistoricTaskInstance::getName));
+
+
+                //遍历map并赋值
+                for (String key : hisTaskMap.keySet()) {
+                    List<HistoricTaskInstance> historicTaskInstances = hisTaskMap.get(key);
+                    FallBackTaskResp resp = new FallBackTaskResp();
+                    resp.setName(key);
+                    resp.setProcessInstId(fallBackTaskReq.getProcessInstId());
+                    //历史任务的id集合
+                    List<String> taskInstIds = new ArrayList<>();
+                    for (HistoricTaskInstance historicTaskInstance : historicTaskInstances) {
+                        taskInstIds.add(historicTaskInstance.getId());
+                        resp.setTaskDefinitionKey(historicTaskInstance.getTaskDefinitionKey());
+                    }
+                    resp.setTaskInstIds(taskInstIds);
+                    fallBackTaskRespList.add(resp);
+                }
+                return fallBackTaskRespList;
+            } catch (Exception e) {
+                log.error("获取回退任务列表出错 ,task:{}, processInstanceId: {}", task.getId(), fallBackTaskReq.getProcessInstId());
+                log.error(e.getMessage());
+            }
+        }
+        return fallBackTaskRespList;
+
+    }
+
+    @Override
+    public List<HistoricTaskInstance> getDoneList(SimpleUser simpleUser) {
+        //1.代办人是自己的
+        String tenantId = String.valueOf(simpleUser.getGroupId());
+        String assignee = simpleUser.getUserId();
+        List<HistoricTaskInstance> list = historyService.createHistoricTaskInstanceQuery()
+                .processDefinitionKey(procDefKey)
+                //.processVariableValueEquals(WorkOrderConstant.orderType, "workOrder")
+                .taskTenantId(tenantId)
+                .taskAssignee(assignee)
+                .list();
+
+
+        //集合合并
+        List<HistoricTaskInstance> taskList = new ArrayList<>();
+
+        //查询到流程id集合
+        List<String> processInstanceIds = new ArrayList<>();
+        for (HistoricTaskInstance historicTaskInstance : list) {
+            boolean flag = processInstanceIds.contains(historicTaskInstance.getProcessInstanceId());
+            if (!flag) {
+                processInstanceIds.add(historicTaskInstance.getProcessInstanceId());
+            }
+        }
+
+        //根据流程id遍历查询
+        for (String processInstanceId : processInstanceIds) {
+            List<HistoricTaskInstance> historicTaskInstanceList = historyService.createHistoricTaskInstanceQuery()
+                    .processDefinitionKey(procDefKey)
+                    .taskTenantId(tenantId)
+                    .processInstanceId(processInstanceId)
+                    .list();
+            taskList.addAll(historicTaskInstanceList);
+        }
+
+        return taskList;
+    }
+
+    @Override
+    public List<TaskDone> getDoneListFromTask(List<HistoricTaskInstance> taskList, DoListTaskReq doListTaskReq) {
+        // 一个流程实例对应多个任务,汇总拿到流程实例
+        Map<String, WorkOrderRespVO> procInstIdsMap = new HashMap<>();
+        for (HistoricTaskInstance task : taskList) {
+            String procInstKey = task.getProcessInstanceId();
+            //减少查询次数
+            if (!procInstIdsMap.containsKey(procInstKey)) {
+                //找到流程所对应的流程id
+                String processInstanceId = task.getProcessInstanceId();
+                WorkOrderRespVO workOrder = new WorkOrderRespVO();
+                if (doListTaskReq != null && doListTaskReq.getTitle() != null) {
+                    workOrder = workOrderService.findByProcInstIdAndTitle(processInstanceId, doListTaskReq.getTitle());
+                } else {
+                    workOrder = workOrderService.findByProcInstId(processInstanceId);
+                }
+                //一个任务一个发起人,所以再去查发起人对应的人名
+                if (workOrder != null) {
+                    procInstIdsMap.put(procInstKey, workOrder);
+                }
+            }
+        }
+        List<TaskDone> doneList = new ArrayList<>();
+
+        List<QueryUserReqVO> queryUserReqVOS = new ArrayList<>();
+
+        for (HistoricTaskInstance task : taskList) {
+            WorkOrderRespVO workOrder = procInstIdsMap.get(task.getProcessInstanceId());
+            if (workOrder != null) {
+                //创建taskDone对象并填充属性
+                TaskDone taskDone = new TaskDone();
+                taskDone.setId(workOrder.getId().toString());
+                taskDone.setOrderType(workOrder.getOrderType());
+                taskDone.setTitle(workOrder.getTitle());
+                taskDone.setPlanTitle(workOrder.getPlanTitle());
+                taskDone.setStartUserId(workOrder.getUserId());
+                //根据任务id和流程id查询节点变量
+                HistoricVariableInstance historicVariableInstance = historyService.createHistoricVariableInstanceQuery()
+                        .taskId(task.getId())
+                        .processInstanceId(task.getProcessInstanceId())
+                        .variableName(WorkOrderConstant.sender)
+                        .singleResult();
+                if (historicVariableInstance != null) {
+                    Object value = historicVariableInstance.getValue();
+                    if (value.toString() != null) {
+                        taskDone.setStartUserId(value.toString());
+                        //把用户id添加到集合中
+                        QueryUserReqVO queryUserReqVO = new QueryUserReqVO();
+                        queryUserReqVO.setUserId(value.toString());
+                        taskDone.setStartUserId(value.toString());
+                        queryUserReqVOS.add(queryUserReqVO);
+                    }
+                }
+                if (task.getEndTime() != null) {
+                    taskDone.setStartTime(task.getEndTime());
+                } else {
+                    taskDone.setStartTime(task.getStartTime());
+                }
+                taskDone.setProcessInstanceId(task.getProcessInstanceId());
+                if (!doneList.contains(taskDone)) {
+                    doneList.add(taskDone);
+                }
+            }
+        }
+
+        //根据id查询到用户集合
+        DataResult<List<SysUser>> result = userFeignClient.queryUser(queryUserReqVOS);
+        List<SysUser> users = new ArrayList<>();
+        if (result.getData() != null) {
+            users = result.getData();
+        }
+
+        //查询任务状态并给发起人赋值
+        for (TaskDone taskDone : doneList) {
+            if (taskDone.getStartUserId() != null) {
+                if (!users.isEmpty()) {
+                    for (SysUser user : users) {
+                        if (user.getId().equals(taskDone.getStartUserId())) {
+                            taskDone.setStartUserName(user.getRealName());
+                            break;
+                        }
+                    }
+                }
+            }
+            Task task = taskService.createTaskQuery()
+                    .processInstanceId(taskDone.getProcessInstanceId())
+                    .singleResult();
+            if (task != null) {
+                taskDone.setStatus(WorkOrderConstant.WorkOrderStatus.processing);
+            } else {
+                taskDone.setStatus(WorkOrderConstant.WorkOrderStatus.completed);
+            }
+        }
+        return doneList;
+    }
+
+    @Override
+    public List<HisTaskResp> getCirculationTask(CirculationTaskReq taskReq) {
+        //创建返回对象
+        List<HisTaskResp> hisTaskRespList = new ArrayList<>();
+        //获取所有历史节点任务
+        List<HistoricTaskInstance> historicTaskInstanceList = historyService.createHistoricTaskInstanceQuery()
+                .processInstanceId(taskReq.getProcessInstId())
+                .orderByHistoricTaskInstanceStartTime().asc().list();
+
+
+        //循环遍历赋值
+        for (HistoricTaskInstance historicTaskInstance : historicTaskInstanceList) {
+            HisTaskResp hisTaskResp = new HisTaskResp();
+
+            hisTaskResp.setName(historicTaskInstance.getName());
+            if (WorkOrderConstant.create.equals(historicTaskInstance.getName())) {
+                hisTaskResp.setStartTime(historicTaskInstance.getStartTime());
+            }
+            if (historicTaskInstance.getClaimTime() != null) {
+                hisTaskResp.setStartTime(historicTaskInstance.getClaimTime());
+            }
+            String processInstanceId = historicTaskInstance.getProcessInstanceId();
+
+            //根据任务id和流程id查询complete变量
+            HistoricVariableInstance historicVariableInstance = historyService.createHistoricVariableInstanceQuery()
+                    .taskId(historicTaskInstance.getId())
+                    .processInstanceId(processInstanceId)
+                    .variableName(WorkOrderConstant.completeKey)
+                    .singleResult();
+            if (historicVariableInstance != null) {
+                String value = historicVariableInstance.getValue().toString();
+                Integer complete = Integer.valueOf(value);
+                //为0表示同意
+                if (WorkOrderConstant.complete.equals(complete)) {
+                    hisTaskResp.setStatus(WorkOrderConstant.WorkOrderStatus.agree);
+                } else if (complete == null) {
+                    hisTaskResp.setStatus(null);
+                } else {
+                    hisTaskResp.setStatus(WorkOrderConstant.WorkOrderStatus.refuse);
+                }
+            }
+
+
+            String userId = historicTaskInstance.getAssignee();
+            //历史任务中执行人id为不为空直接查询
+            if (userId != null) {
+                DataResult<SysUser> result = userFeignClient.getUserById(userId);
+                SysUser user = result.getData();
+                if (user != null) {
+                    hisTaskResp.setUserName(user.getRealName());
+                } else {
+                    hisTaskResp.setUserName("");
+                }
+            }
+            //为空则需要去查询流程变量
+            else {
+                //根据任务id和流程id查询候选人列表变量
+                HistoricVariableInstance candidateUsers = historyService.createHistoricVariableInstanceQuery()
+                        .taskId(historicTaskInstance.getId())
+                        .processInstanceId(processInstanceId)
+                        .variableName(WorkOrderConstant.CandidateUser.nodeOneUsers)
+                        .singleResult();
+                JsonNode value = (JsonNode) candidateUsers.getValue();
+                if (value != null) {
+                    for (JsonNode jsonNode : value) {
+                        String id = jsonNode.asText();
+                        //遍历赋值给执行人
+                        DataResult<SysUser> result = userFeignClient.getUserById(id);
+                        if (result.getData() != null) {
+                            //第一个直接赋值
+                            if (hisTaskResp.getUserName() == null) {
+                                hisTaskResp.setUserName(result.getData().getRealName());
+                            }
+                            //后续的用逗号隔开继续添加
+                            else {
+                                String userName = hisTaskResp.getUserName();
+                                boolean flag = userName.contains(result.getData().getRealName());
+                                if (!flag) {
+                                    userName = userName + "," + result.getData().getRealName();
+                                    hisTaskResp.setUserName(userName);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            //建议需要去流程变量去查
+            HistoricVariableInstance value = historyService.createHistoricVariableInstanceQuery()
+                    .taskId(historicTaskInstance.getId())
+                    .processInstanceId(historicTaskInstance.getProcessInstanceId())
+                    .variableName(WorkOrderConstant.suggestion)
+                    .singleResult();
+            if (value != null) {
+                String suggestion = (String) value.getValue();
+                hisTaskResp.setSuggestion(suggestion);
+            }
+            if (historicTaskInstance.getEndTime() != null) {
+                hisTaskResp.setEndTime(hisTaskResp.getEndTime());
+                long l = DateUtil.betweenMs(historicTaskInstance.getStartTime(), historicTaskInstance.getEndTime());
+                BigDecimal ms = new BigDecimal(l);
+                BigDecimal taskTime = ms.divide(new BigDecimal("3600000"), 2, BigDecimal.ROUND_HALF_UP);
+                hisTaskResp.setTaskTime(taskTime);
+                hisTaskResp.setEndTime(historicTaskInstance.getEndTime());
+            } else {
+                hisTaskResp.setEndTime(null);
+                hisTaskResp.setTaskTime(BigDecimal.ZERO);
+                //没有结束时间,则没有对应的状态和建议实则为空
+                hisTaskResp.setStatus(null);
+                hisTaskResp.setSuggestion(null);
+            }
+
+            hisTaskRespList.add(hisTaskResp);
+        }
+        return hisTaskRespList;
+    }
+
+    @Override
+    public void planAddWorkOrder(WorkOrderPlan workOrderPlan, List<String> userIds,List<WorkOrderSub> workOrderSubs) {
+        //先创建工单
+        WorkOrderAddReqVO reqVO = new WorkOrderAddReqVO();
+        BeanUtils.copyProperties(workOrderPlan,reqVO);
+        reqVO.setWorkOrderSubs(workOrderSubs);
+        String processInstanceId = saveOrderAndStartProcess(reqVO);
+        //在对工单进行流转
+        DoTaskReq doTaskReq = new DoTaskReq();
+        doTaskReq.setProcessInstId(processInstanceId);
+        //设置发送者的id
+        doTaskReq.setSenderId(workOrderPlan.getUserId());
+        doTaskReq.setTenantId(String.valueOf(workOrderPlan.getGroupId()));
+        doTaskReq.setCandidateUserList(userIds);
+        //完成任务的责任人必须和自己相同,否则需要给出提示
+        doTaskReq.setAssigneeUser(workOrderPlan.getUserId());
+        doCompleteTask(doTaskReq);
+    }
+
+    /**
+     * 根据集团id部署工作流
+     * @param groupId
+     */
+    @Override
+    public void deploymentWorkflow(Integer groupId) {
+        String fileName = "processes/workOrder.bpmn20.xml";
+        if (groupId != null) {
+            Deployment deployment = repositoryService.createDeployment()
+                    .addClasspathResource(fileName)
+                    .name("工单流程")
+                    .tenantId(groupId.toString())
+                    //.category("workOrder")
+                    .deploy();
+        }else {
+            throw new BusinessException(BaseResponseCode.GROUP_ID_IS_NULL);
+        }
+    }
+
+    //获取下一个节点的任务名
+    @Override
+    public String getNextTaskName(String processInstId) {
+        //当前任务信息
+        Task task = taskService.createTaskQuery().processInstanceId(processInstId).singleResult();
+        if (task == null) {
+            return "";
+        }
+        //流程实例id
+        String processInstanceId = task.getProcessInstanceId();
+        //获取
+        // 流程发布Id信息
+        String definitionId = runtimeService.createProcessInstanceQuery()
+                .processInstanceId(processInstanceId).singleResult().getProcessDefinitionId();
+        //获取bpm对象
+        BpmnModel bpmnModel = repositoryService.getBpmnModel(definitionId);
+        //传节点定义key 获取当前节点
+        FlowNode flowNode = (FlowNode) bpmnModel.getFlowElement(task.getTaskDefinitionKey());
+        //输出连线
+        List<SequenceFlow> outgoingFlows = flowNode.getOutgoingFlows();
+
+        //当前任务id  d1 d2
+        String currentTaskId = task.getTaskDefinitionKey();
+        String currentNode = currentTaskId.substring(1);
+        //遍历返回下一个节点信息
+        for (SequenceFlow outgoingFlow : outgoingFlows) {
+            //类型自己判断
+            FlowElement targetFlowElement = outgoingFlow.getTargetFlowElement();
+            //用户任务
+            if (targetFlowElement instanceof UserTask) {
+                //找 name比它大的
+                String nextTaskId = targetFlowElement.getId();
+                nextTaskId = nextTaskId.substring(1);
+                if (nextTaskId.compareTo(currentNode) > 0) {
+                    log.info("下一任务id: {}", nextTaskId);
+                    return targetFlowElement.getName();
+                }
+            } else if (targetFlowElement instanceof ExclusiveGateway) {
+                //排他网关,继续
+                //setExclusiveGateway(targetFlowElement);
+                continue;
+            } else if (targetFlowElement instanceof EndEvent) {
+                //结束事件,返回结束点名称
+                return targetFlowElement.getName();
+            }
+        }
+        return "";
+    }
+
+
+    private void setExclusiveGateway(FlowElement targetFlow) {
+        //排他网关，获取连线信息
+        List<SequenceFlow> targetFlows = ((ExclusiveGateway) targetFlow).getOutgoingFlows();
+        for (SequenceFlow sequenceFlow : targetFlows) {
+            //目标节点信息
+            FlowElement targetFlowElement = sequenceFlow.getTargetFlowElement();
+            if (targetFlowElement instanceof UserTask) {
+                // do something
+            } else if (targetFlowElement instanceof EndEvent) {
+                // do something
+            } else if (targetFlowElement instanceof ServiceTask) {
+                // do something
+            } else if (targetFlowElement instanceof ExclusiveGateway) {
+                //递归寻找
+                setExclusiveGateway(targetFlowElement);
+            } else if (targetFlowElement instanceof SubProcess) {
+                // do something
+            }
+        }
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/service/impl/SendSmsConfigImpl.java

@@ -0,0 +1,144 @@
+package com.ho.flow.service.impl;
+
+import com.alibaba.fastjson.JSONObject;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.ho.common.tools.constant.CommonConstant;
+import com.ho.common.tools.util.AliSendSmsUtils;
+import com.ho.common.tools.util.PageResult;
+import com.ho.common.tools.util.PageUtils;
+import com.ho.flow.entity.SendSmsConfig;
+import com.ho.flow.mapper.SendSmsConfigMapper;
+import com.ho.flow.service.SendSmsConfigService;
+import com.ho.flow.vo.req.SendSmsConfig.SendSmsConfigQueryReq;
+import com.ho.flow.vo.resp.SendSmsConfig.SendSmsConfigRsp;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+@Service
+@Slf4j
+public class SendSmsConfigImpl implements SendSmsConfigService {
+
+    @Autowired
+    SendSmsConfigMapper sendSmsConfigMapper;
+
+    @Override
+    public PageResult<SendSmsConfigRsp> getPageList(SendSmsConfigQueryReq vo) {
+        PageHelper.startPage(vo.getPageNum(), vo.getPageSize());
+        List<SendSmsConfigRsp> sendSmsConfigs = sendSmsConfigMapper.selectList(vo);
+        sendSmsConfigs.stream().forEach(i -> i.setLevelList((i.getAlarmLevel() == null || i.getAlarmLevel().isEmpty()) ? new ArrayList<>() : Arrays.asList(i.getAlarmLevel().split(","))));
+        return PageUtils.getPageResult(new PageInfo<>(sendSmsConfigs));
+    }
+
+    @Override
+    public List<SendSmsConfigRsp> getList(SendSmsConfigQueryReq vo) {
+        List<SendSmsConfigRsp> sendSmsConfigs = sendSmsConfigMapper.selectList(vo);
+        return sendSmsConfigs;
+    }
+
+    @Override
+    public void insertList(List<SendSmsConfig> list) {
+        for (SendSmsConfig sendSmsConfig : list) {
+            //1）是否立即发送（默认是）（isSendNow）、延迟发送时间（下拉选择）(delayTime 延迟时间)  "是否立即发送:是1否2  默认是1"
+            if (sendSmsConfig.getIsSendNow() == null) {
+                sendSmsConfig.setIsSendNow(CommonConstant.ONE);
+            }
+            //2）当是否立即发送选择为否时，延迟发送时间必须选择，否则延迟发送时间默认存0）
+            if (CommonConstant.TWO.equals(sendSmsConfig.getIsSendNow())) {
+                if (sendSmsConfig.getDelayData() == null) {
+                    sendSmsConfig.setDelayData(CommonConstant.ZERO);
+                }
+            }
+        }
+        sendSmsConfigMapper.insertList(list);
+    }
+
+    @Override
+    public int updateById(SendSmsConfig vo) {
+        //判断是否为延迟发送
+        if (CommonConstant.TWO.equals(vo.getIsSendNow())) {
+            //是的情况下，查看延长时间是否为空，为空的情况下默认存0
+            if (vo.getDelayData() == null) {
+                vo.setDelayData(CommonConstant.ZERO);
+            }
+        }
+        return sendSmsConfigMapper.updateById(vo);
+    }
+
+    @Override
+    public int updateByUserId(SendSmsConfig vo) {
+        int count = sendSmsConfigMapper.updateByUserId(vo);
+        return count;
+    }
+
+    @Override
+    public int deleteList(List<Integer> ids) {
+        return sendSmsConfigMapper.deleteBatch(ids);
+    }
+
+    @Override
+    public void sendSms(SendSmsConfigQueryReq vo) {
+     /*   JSONObject jsonObject = new JSONObject();
+        jsonObject.put(CommonConstant.SMS.SITE_NAME, "浙江慈溪");
+        jsonObject.put(CommonConstant.SMS.CONTENT, "111111");
+        vo.setParam(jsonObject);*/
+        List<SendSmsConfigRsp> list = sendSmsConfigMapper.selectList(vo);
+        if (null == list || list.isEmpty()) {
+            return;
+        }
+        Map<Integer, List<SendSmsConfigRsp>> collect = list.stream().collect(Collectors.groupingBy(SendSmsConfigRsp::getIsSendNow));
+        //筛选延迟发送的筛选条件 是否立即发送:是1否2  默认是1
+        List<SendSmsConfigRsp> sendSmsConfigs = collect.get(CommonConstant.ONE);//立即发送
+        List<SendSmsConfigRsp> delaySMSList = collect.get(CommonConstant.TWO);//延迟发送
+        if (null != delaySMSList) {
+            log.info("delay send message,{}",vo.getParam().toJSONString());
+            getDelaySMS(delaySMSList, vo.getParam());
+        }
+        if (sendSmsConfigs == null) {
+            return;
+        }
+        if (sendSmsConfigs != null || !sendSmsConfigs.isEmpty()) {
+            log.info("common send message,{}",vo.getParam().toJSONString());
+            for (SendSmsConfigRsp s : sendSmsConfigs) {
+                try {
+                    JSONObject param = vo.getParam();
+                    param.put(CommonConstant.SMS.NAME, s.getRealName());
+                    AliSendSmsUtils.sendMessage(vo.getParam().toJSONString(), s.getPhone());
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    log.error("sendSms :{}", e.getMessage());
+                }
+            }
+        }
+    }
+
+    public void getDelaySMS(List<SendSmsConfigRsp> list, JSONObject params) {
+        list.sort(((o1, o2) -> {
+            //从小到大
+            return o1.getDelayData() - o2.getDelayData();//此处定义比较规则，o2.age-o1.age即为从大到小
+        }));
+        for (SendSmsConfigRsp sendSmsConfigRsp : list) {
+            long milliseconds = TimeUnit.MINUTES.toMillis(sendSmsConfigRsp.getDelayData());
+            Timer t = new Timer();
+            t.schedule(new TimerTask() {
+                @Override
+                public void run() {
+                    try {
+                        JSONObject param = params;
+                        param.put(CommonConstant.SMS.NAME, sendSmsConfigRsp.getRealName());
+                        AliSendSmsUtils.sendMessage(params.toJSONString(), sendSmsConfigRsp.getPhone());
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                        log.error("sendSms :{}", e.getMessage());
+                    }
+
+                }
+            }, milliseconds);
+        }
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/service/impl/WorkOrderCirculationServiceImpl.java

@@ -0,0 +1,102 @@
+package com.ho.flow.service.impl;
+
+
+import com.ho.common.tools.exception.DataResult;
+import com.ho.flow.feignclient.UserFeignClient;
+import com.ho.flow.mapper.WorkOrderCirculationMapper;
+import com.ho.flow.service.WorkOrderCirculationService;
+import com.ho.flow.vo.WorkOrderCirculation;
+import com.ho.flow.vo.resp.workorder.WorkOrderCirculationRespVO;
+import com.ho.user.api.entity.SysUser;
+import com.ho.user.api.vo.req.QueryUserReqVO;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @Description 针对表【work_order_circulation】的数据库操作Service实现
+ * Author yule
+ * Date 2022/10/14 15:40
+ */
+@Service
+@Slf4j
+public class WorkOrderCirculationServiceImpl implements WorkOrderCirculationService {
+
+    @Autowired
+    WorkOrderCirculationMapper workOrderCirculationMapper;
+
+    @Autowired
+    UserFeignClient userFeignClient;
+
+    @Override
+    public void add(WorkOrderCirculation workOrderCirculation) {
+        int insert = workOrderCirculationMapper.insert(workOrderCirculation);
+    }
+
+    @Override
+    public int insertEventBatch(List<WorkOrderCirculation> workOrderCirculations) {
+        int i = workOrderCirculationMapper.insertBatch(workOrderCirculations);
+        return i;
+    }
+
+    @Override
+    public List<WorkOrderCirculationRespVO> selectByOrderId(String orderId) {
+        List<WorkOrderCirculationRespVO> list = workOrderCirculationMapper.selectByOrderId(orderId);
+        //发起人id集合
+        List<QueryUserReqVO> fromIds = new ArrayList<>();
+        //执行人id集合
+        List<QueryUserReqVO> toIds = new ArrayList<>();
+
+
+        //遍历集合给发起人id 执行人id 增加元素
+        for (WorkOrderCirculationRespVO workOrderCirculationRespVO : list) {
+            if (workOrderCirculationRespVO.getFromId() != null) {
+                QueryUserReqVO queryFrom = new QueryUserReqVO();
+                queryFrom.setUserId(workOrderCirculationRespVO.getFromId());
+                fromIds.add(queryFrom);
+            }
+            if (workOrderCirculationRespVO.getToId() != null) {
+                QueryUserReqVO queryTo = new QueryUserReqVO();
+                queryTo.setUserId(workOrderCirculationRespVO.getToId());
+                toIds.add(queryTo);
+            }
+        }
+
+        //查询发起人用户集合
+        List<SysUser> fromUsers = new ArrayList<>();
+        if (!fromIds.isEmpty()) {
+            DataResult<List<SysUser>> fromResult = userFeignClient.queryUser(fromIds);
+            fromUsers = fromResult.getData();
+        }
+        //查询执行人用户集合
+        List<SysUser> toUsers = new ArrayList<>();
+        if (!toIds.isEmpty()) {
+            DataResult<List<SysUser>> toResult = userFeignClient.queryUser(toIds);
+            toUsers = toResult.getData();
+        }
+
+        for (int i = 0; i < list.size(); i++) {
+            //遍历发起人用户集合获取到发起人名字,给工单的发起人名字赋值
+            if ((list.get(i).getFromId() != null)) {
+                for (SysUser fromUser : fromUsers) {
+                    if (list.get(i).getFromId().equals(fromUser.getId())) {
+                        list.get(i).setFromName(fromUser.getUsername());
+                        break;
+                    }
+                }
+            }
+            if (list.get(i).getToId() != null) {
+                for (SysUser toUser : toUsers) {
+                    if (list.get(i).getToId().equals(toUser.getId())) {
+                        list.get(i).setToName(toUser.getUsername());
+                        break;
+                    }
+                }
+            }
+        }
+        return list;
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/service/impl/WorkOrderHisServiceImpl.java

@@ -0,0 +1,419 @@
+package com.ho.flow.service.impl;
+
+import cn.hutool.core.lang.Snowflake;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.ho.business.entity.Station;
+import com.ho.common.tools.entity.SimpleUser;
+import com.ho.common.tools.exception.BaseResponseCode;
+import com.ho.common.tools.exception.BusinessException;
+import com.ho.common.tools.exception.DataResult;
+import com.ho.common.tools.util.PageResult;
+import com.ho.common.tools.util.PageUtils;
+import com.ho.flow.constant.WorkOrderConstant;
+import com.ho.flow.feignclient.BusinessFeignClient;
+import com.ho.flow.feignclient.UserFeignClient;
+import com.ho.flow.mapper.WorkOrderCirculationMapper;
+import com.ho.flow.mapper.WorkOrderHisMapper;
+import com.ho.flow.service.FlowWorkOrderService;
+import com.ho.flow.service.WorkOrderHisService;
+import com.ho.flow.vo.WorkOrderOld;
+import com.ho.flow.vo.WorkOrderCirculation;
+import com.ho.flow.vo.req.workorder.*;
+import com.ho.flow.vo.resp.workorder.WorkOrderOldPageRespVO;
+import com.ho.user.api.entity.SysUser;
+import com.ho.user.api.vo.req.QueryUserReqVO;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+
+/**
+ * @Description 工单管理
+ * Author yule
+ * Date 2022/10/14 10:43
+ */
+@Service
+@Slf4j
+public class WorkOrderHisServiceImpl implements WorkOrderHisService {
+
+    @Autowired
+    WorkOrderHisMapper workOrderHisMapper;
+
+    @Autowired
+    Snowflake snowflake;
+
+    @Autowired
+    WorkOrderCirculationMapper workOrderCirculationMapper;
+
+    @Autowired
+    BusinessFeignClient businessFeignClient;
+
+    @Autowired
+    UserFeignClient userFeignClient;
+
+    //工作流
+    @Autowired
+    FlowWorkOrderService flowWorkOrderService;
+
+    //流程定义key
+    @Value("${flow.workOrder.procDefKey}")
+    String procDefKey;
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void insertStation(WorkOrderAddReq vo, SimpleUser simpleUser, String workOrderId) {
+        //工单表,工单流转表分别新增一个数据
+        WorkOrderOld workOrderOld = new WorkOrderOld();
+        //工单id
+        workOrderOld.setId(snowflake.nextId());
+        workOrderOld.setOrderId(workOrderId);
+        //station所属dept会发生变化,deptId不再记录,只记录stationId
+        //workOrder.setDeptId(simpleUser.getDeptId());
+        workOrderOld.setGroupId(simpleUser.getGroupId());
+        workOrderOld.setStationId(vo.getStationId());
+        workOrderOld.setFromId(simpleUser.getUserId());
+        workOrderOld.setDesc(vo.getDesc());
+        workOrderOld.setWorkOrderType(vo.getWorkOrderType());
+        workOrderOld.setWorkOrderStatus(WorkOrderConstant.WorkOrderStatus.toBeAllocate);
+        workOrderHisMapper.insertSelective(workOrderOld);
+        WorkOrderCirculation workOrderCirculation = new WorkOrderCirculation();
+        BeanUtils.copyProperties(workOrderOld, workOrderCirculation);
+        workOrderCirculation.setWorkOrderAction(WorkOrderConstant.WorkOrderAction.workOrderCreate);
+        workOrderCirculationMapper.insert(workOrderCirculation);
+        //启动一个工作流, 传入 流程定义key ,租户id, businessKey, 变量
+        Map<String,Object> variables = new HashMap<>();
+        variables.put("stationId", vo.getStationId().toString());
+        //给分配的assignee 和 验收的assignee赋值
+        //variables.put(WorkOrderConstant.canDistributeOrder, WorkOrderConstant.canDistributeOrder);
+        //variables.put(WorkOrderConstant.canCheckOrder, WorkOrderConstant.canCheckOrder);
+        flowWorkOrderService.startProcess(procDefKey ,workOrderId ,variables, simpleUser.getGroupId().toString());
+    }
+
+    @Override
+    public void updateWorkOrder(WorkOrderUpdateReq vo, SimpleUser simpleUser) {
+        WorkOrderOld workOrderOld = new WorkOrderOld();
+        workOrderOld.setOrderId(vo.getOrderId());
+        workOrderOld.setPhone(vo.getPhone());
+        workOrderOld.setStationId(vo.getStationId());
+        workOrderOld.setToId(vo.getToId());
+        workOrderOld.setDesc(vo.getDesc());
+        workOrderHisMapper.updateByPrimaryKeySelective(workOrderOld);
+    }
+
+    //分配工单
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void allocateOrder(WorkOrderApplyReqVO applyReqVO, SimpleUser simpleUser) {
+        //判断工单
+        WorkOrderOld workOrderOld = findByOrderId(applyReqVO.getOrderId());
+        if (workOrderOld == null) {
+            //没找到数据
+            throw new BusinessException(BaseResponseCode.DATA_NOT_EXISTS);
+        }
+        //工单状态必须是待分配
+        if (!WorkOrderConstant.WorkOrderStatus.toBeAllocate.equals(workOrderOld.getWorkOrderStatus())) {
+            throw new BusinessException(BaseResponseCode.WORK_ORDER_STATUS_MUST_BE_NOT_ALLOCATED);
+        }
+        //todo 判断taskId 和 orderId(businessKey)是否对应,不对应报错
+        //修改工单状态
+        WorkOrderOld workOrderOldAllocate = new WorkOrderOld();
+        workOrderOldAllocate.setOrderId(applyReqVO.getOrderId());
+        //fromId已经在流程发起时设置了
+        // workOrderAllocate.setFromId(simpleUser.getUserId());
+        workOrderOldAllocate.setToId(applyReqVO.getToId());
+        workOrderOldAllocate.setPhone(applyReqVO.getPhone());
+        //工单改为已分配
+        workOrderOldAllocate.setWorkOrderStatus(WorkOrderConstant.WorkOrderStatus.allocated);
+        workOrderHisMapper.updateByPrimaryKeySelective(workOrderOldAllocate);
+        //生成流转记录
+        WorkOrderCirculation circulation = new WorkOrderCirculation();
+        circulation.setId(snowflake.nextId());
+        circulation.setOrderId(applyReqVO.getOrderId());
+        circulation.setFromId(simpleUser.getUserId());
+        circulation.setToId(applyReqVO.getToId());
+        circulation.setDesc(applyReqVO.getDistributionDesc());
+        //动作是:分配工单
+        circulation.setWorkOrderAction(WorkOrderConstant.WorkOrderAction.workOrderApply);
+        workOrderCirculationMapper.insert(circulation);
+        //增加下一节点参数
+        OrderReq orderReq = new OrderReq();
+        //下一个代办人
+        orderReq.setWorkerId(applyReqVO.getToId());
+        Map<String,Object> variables = new HashMap<>();
+        variables.put("orderReq", orderReq);
+        flowWorkOrderService.completeTask(applyReqVO.getTaskId(), variables);
+
+    }
+
+    @Override
+    public PageResult<WorkOrderOldPageRespVO> selectPage(WorkOrderPageReq vo, SimpleUser simpleUser) {
+        //根据执行人查询
+        /*QueryUserReqVO userReqVO = new QueryUserReqVO();
+        userReqVO.setGroupId(simpleUser.getGroupId());
+        userReqVO.setUserName(vo.getToName());
+        DataResult<List<SysUser>> sysUserDataResult = userFeignClient.getUserByNameConcat(userReqVO);
+        List<SysUser> users = sysUserDataResult.getData();
+
+        if (!users.isEmpty()) {
+            users.stream().forEach(u -> toIdList.add(u.getId()));
+        }
+        List<String> toIdList = new ArrayList<>();*/
+        // d设置为list
+        //vo.setToIds(toIdList);
+        PageHelper.startPage(vo.getPageNum(), vo.getPageSize());
+        List<WorkOrderOldPageRespVO> workOrders = workOrderHisMapper.selectByPageInfo(vo);
+        //发起人id集合
+        List<QueryUserReqVO> fromIds = new ArrayList<>();
+        //执行人id集合
+        List<QueryUserReqVO> toIds = new ArrayList<>();
+        //电站id集合
+        //List<Integer> stationIds = new ArrayList<>();
+        //遍历集合给发起人id 执行人id 电站id 增加元素
+        for (WorkOrderOldPageRespVO workOrderPageRespVO : workOrders) {
+            if (workOrderPageRespVO.getFromId() != null) {
+                QueryUserReqVO queryFrom = new QueryUserReqVO();
+                queryFrom.setUserId(workOrderPageRespVO.getFromId());
+                fromIds.add(queryFrom);
+            }
+            if (workOrderPageRespVO.getToId() != null) {
+                QueryUserReqVO queryTo = new QueryUserReqVO();
+                queryTo.setUserId(workOrderPageRespVO.getToId());
+                toIds.add(queryTo);
+            }
+            //没有再加入
+            /*if (!stationIds.contains(workOrderPageRespVO.getStationId())) {
+                stationIds.add(workOrderPageRespVO.getStationId());
+            }*/
+        }
+
+        //查询发起人用户集合
+        List<SysUser> fromUsers = new ArrayList<>();
+        if (!fromIds.isEmpty()) {
+            DataResult<List<SysUser>> fromResult = userFeignClient.queryUser(fromIds);
+            fromUsers = fromResult.getData();
+        }
+        //查询执行人用户集合
+        List<SysUser> toUsers = new ArrayList<>();
+        if (!toIds.isEmpty()) {
+            DataResult<List<SysUser>> toResult = userFeignClient.queryUser(toIds);
+            toUsers = toResult.getData();
+        }
+        //查询电站集合
+        List<Station> stations = new ArrayList<>();
+        if (!vo.getStationIds().isEmpty()) {
+            DataResult<List<Station>> listDataResult = businessFeignClient.selectByStationIds(vo.getStationIds());
+            if (listDataResult.isSuccess()) {
+                stations = listDataResult.getData();
+            }
+        }
+        for (int i = 0; i < workOrders.size(); i++) {
+            //遍历发起人用户集合获取到发起人名字,给工单的发起人名字赋值
+            if ((workOrders.get(i).getFromId() != null)) {
+                for (SysUser fromUser : fromUsers) {
+                    if (workOrders.get(i).getFromId().equals(fromUser.getId())) {
+                        workOrders.get(i).setFromName(fromUser.getUsername());
+                        break;
+                    }
+                }
+            }
+            if (workOrders.get(i).getToId() != null) {
+                for (SysUser toUser : toUsers) {
+                    if (workOrders.get(i).getToId().equals(toUser.getId())) {
+                        workOrders.get(i).setToName(toUser.getUsername());
+                        break;
+                    }
+                }
+            }
+            //电站名称
+            for (Station station : stations) {
+                if (workOrders.get(i).getStationId().equals(station.getId())) {
+                    workOrders.get(i).setStationName(station.getName());
+                    break;
+                }
+            }
+        }
+        for (WorkOrderOldPageRespVO workOrder : workOrders) {
+            //判断工单是否为新建并且发起人是登录人
+            if (WorkOrderConstant.WorkOrderStatus.toBeAllocate.equals(workOrder.getWorkOrderStatus())
+                    && workOrder.getFromId().equals(simpleUser.getUserId())) {
+                workOrder.setEdit(1);
+            } else {
+                workOrder.setEdit(0);
+            }
+            //判断执行人是否为登录人
+            String toId = workOrder.getToId();
+            if (toId != null && toId.equals(simpleUser.getUserId())) {
+                //分配人是登陆人, 工单可操作, 否则不可以操作
+                workOrder.setOperation(1);
+            } else {
+                workOrder.setOperation(0);
+            }
+            //接收人为空,如果, todo 这个地方的逻辑还需要再核对一下, 有权限的人可以操作工单,应该和发起人是不是自己没关系
+            if (toId == null && workOrder.getFromId().equals(simpleUser.getUserId()) && vo.getRoleLeader() != null) {
+                workOrder.setOperation(1);
+            }
+            //判断是否能退回
+            //新建工单不能退回
+            if (WorkOrderConstant.WorkOrderStatus.toBeAllocate.equals(workOrder.getWorkOrderStatus())) {
+                workOrder.setReturnFlag(0);
+            }
+            //执行人不是登录人,不能退回
+            else if (toId != null && !toId.equals(simpleUser.getUserId())) {
+                workOrder.setReturnFlag(0);
+            } else {
+                workOrder.setReturnFlag(1);
+            }
+        }
+        PageResult pageResult = PageUtils.getPageResult(new PageInfo<>(workOrders));
+        return pageResult;
+    }
+
+    @Override
+    public PageResult<WorkOrderOldPageRespVO> selectHisPage(WorkOrderPageReq vo) {
+        PageHelper.startPage(vo.getPageNum(), vo.getPageSize());
+        List<WorkOrderOldPageRespVO> workOrders = workOrderHisMapper.selectByHisPageInfo(vo);
+
+        //发起人id集合
+        List<QueryUserReqVO> fromIds = new ArrayList<>();
+        //执行人id集合
+        List<QueryUserReqVO> toIds = new ArrayList<>();
+        //电站id集合
+        List<Integer> stationIds = vo.getStationIds();
+        //遍历集合给发起人id 执行人id 电站id 增加元素
+        for (WorkOrderOldPageRespVO workOrderPageRespVO : workOrders) {
+            QueryUserReqVO queryFrom = new QueryUserReqVO();
+            queryFrom.setUserId(workOrderPageRespVO.getFromId());
+            fromIds.add(queryFrom);
+            QueryUserReqVO queryTo = new QueryUserReqVO();
+            queryTo.setUserId(workOrderPageRespVO.getToId());
+            toIds.add(queryTo);
+            //stationIds.add(workOrderPageRespVO.getStationId());
+        }
+
+        //查询发起人用户集合
+        List<SysUser> fromUsers = new ArrayList<>();
+        if (!fromIds.isEmpty()) {
+            DataResult<List<SysUser>> fromResult = userFeignClient.queryUser(fromIds);
+            fromUsers = fromResult.getData();
+        }
+        //查询执行人用户集合
+        List<SysUser> toUsers = new ArrayList<>();
+        if (!toIds.isEmpty()) {
+            DataResult<List<SysUser>> toResult = userFeignClient.queryUser(toIds);
+            toUsers = toResult.getData();
+        }
+        //查询电站集合
+        List<Station> stations = new ArrayList<>();
+        //电站List为空
+        if (stationIds == null || stationIds.isEmpty()) {
+
+            stationIds.add(vo.getStationId());
+        }
+        DataResult<List<Station>> listDataResult = businessFeignClient.selectByStationIds(stationIds);
+        if (listDataResult.isSuccess()) {
+            stations = listDataResult.getData();
+        }
+        for (int i = 0; i < workOrders.size(); i++) {
+            //遍历发起人用户集合获取到发起人名字,给工单的发起人名字赋值
+            if ((workOrders.get(i).getFromId() != null)) {
+                for (SysUser fromUser : fromUsers) {
+                    if (workOrders.get(i).getFromId().equals(fromUser.getId())) {
+                        workOrders.get(i).setFromName(fromUser.getUsername());
+                        break;
+                    }
+                }
+            }
+            if (workOrders.get(i).getToId() != null) {
+                for (SysUser toUser : toUsers) {
+                    if (workOrders.get(i).getToId().equals(toUser.getId())) {
+                        workOrders.get(i).setToName(toUser.getUsername());
+                        break;
+                    }
+                }
+            }
+            for (Station station : stations) {
+                if (workOrders.get(i).getStationId().equals(station.getId())) {
+                    workOrders.get(i).setStationName(station.getName());
+                    break;
+                }
+            }
+        }
+        PageResult pageResult = PageUtils.getPageResult(new PageInfo<>(workOrders));
+        return pageResult;
+
+    }
+
+    @Override
+    public WorkOrderOld selectById(String orderId) {
+        WorkOrderOld workOrderOld = workOrderHisMapper.selectByOrderId(orderId);
+        return workOrderOld;
+    }
+
+    @Override
+    public List<WorkOrderOld> selectByEventIds(List<Long> eventIds) {
+        List<WorkOrderOld> workOrderOlds = workOrderHisMapper.selectByEventIds(eventIds);
+        return workOrderOlds;
+    }
+
+    @Override
+    public List<WorkOrderOld> selectByStationIds(List<Long> stationIds) {
+        return null;
+    }
+
+    @Override
+    public void deleteWorkOrder(List<String> orderIds) {
+        workOrderHisMapper.deleteByPrimaryKey(orderIds);
+    }
+
+    @Override
+    public void delete(String orderId) {
+        workOrderHisMapper.delete(orderId);
+    }
+
+    @Override
+    public WorkOrderOld findByOrderId(String orderId) {
+        return workOrderHisMapper.selectByOrderId(orderId);
+    }
+
+    @Override
+    public void acceptWorkOrder(WorkOrderOld workOrderOld, WorkOrderCirculation workOrderAllocate) {
+        //修改工单数据
+        workOrderOld.setReceiveTime(new Date());
+        workOrderHisMapper.updateByPrimaryKeySelective(workOrderOld);
+        // 新增工单流水
+        workOrderCirculationMapper.insertSelective(workOrderAllocate);
+
+    }
+
+
+    @Override
+    public void returnWorkOrder(WorkOrderOld workOrderOld, WorkOrderCirculation workOrderAllocate) {
+        //修改工单数据--- 退回状态 清空（执行人id 电话 接收时间）
+        workOrderHisMapper.updateReturnWorkOrder(workOrderOld);
+
+        // 新增工单流水
+        workOrderCirculationMapper.insertSelective(workOrderAllocate);
+    }
+
+
+    @Override
+    public void closeWorkOrder(WorkOrderOld workOrderOld, WorkOrderCirculation workOrderAllocate) {
+        //修改工单数据--- 完成状态
+        workOrderOld.setCompleteTime(new Date());
+        workOrderHisMapper.updateByPrimaryKeySelective(workOrderOld);
+        // 新增工单流水
+        workOrderCirculationMapper.insertSelective(workOrderAllocate);
+    }
+
+
+    @Override
+    public int insertEventBatch(List<WorkOrderOld> workOrderOlds) {
+        int i = workOrderHisMapper.insertBatch(workOrderOlds);
+        return i;
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/service/impl/WorkOrderPictureServiceImpl.java

@@ -0,0 +1,183 @@
+package com.ho.flow.service.impl;
+
+import cn.hutool.core.codec.Base64;
+import com.ho.common.tools.constant.CommonConstant;
+import com.ho.common.tools.entity.WorkOrderPicture;
+import com.ho.common.tools.exception.BaseResponseCode;
+import com.ho.common.tools.exception.BusinessException;
+import com.ho.common.tools.util.CommonBytesUtil;
+import com.ho.flow.mapper.WorkOrderPictureMapper;
+import com.ho.flow.service.WorkOrderPictureService;
+import com.ho.flow.vo.req.workorder.WorkOrderAddReqVO;
+import com.ho.flow.vo.req.workorder.WorkOrderUpdateReqVO;
+import com.ho.flow.vo.resp.workorder.PictureRespVO;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.io.FilenameUtils;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @Description 工单图片
+ * Author yule
+ * Date 2023/2/4 14:24
+ */
+@Service
+@Slf4j
+public class WorkOrderPictureServiceImpl implements WorkOrderPictureService {
+
+    @Autowired
+    WorkOrderPictureMapper pictureMapper;
+
+    @Autowired
+    CommonBytesUtil bytesUtil;
+
+
+    @Value("${flow.maxPicUploadNum}")
+    Integer maxPicUploadNum;
+
+
+    @Override
+    public WorkOrderPicture insertPicture(String url) {
+        //创建文件对象
+        File file = new File(url);
+        //把图片的地址转化为图片的实体类对象
+        WorkOrderPicture picture = new WorkOrderPicture();
+        picture.setUrl(url);
+        picture.setCreateTime(new Date());
+        picture.setFileName(file.getName());
+        //将实体对象入库存储
+        pictureMapper.insertSelective(picture);
+        //根据url查询到返回的实体对象
+        return picture;
+    }
+
+    @Override
+    public void insertWorkOrderIdAndType(WorkOrderAddReqVO vo) {
+        List<Integer> pictureIds = vo.getPictureIds();
+
+        if (pictureIds != null && !pictureIds.isEmpty()) {
+            if (pictureIds.size() > maxPicUploadNum) {
+                throw new BusinessException(BaseResponseCode.FILE_NOT_MORE_THAN_NINE);
+            }
+            for (Integer pictureId : pictureIds) {
+                WorkOrderPicture picture = new WorkOrderPicture();
+                picture.setId(pictureId);
+                picture.setWorkOrderId(vo.getId());
+                picture.setType(CommonConstant.PICTURE.STATION);
+                picture.setCreateTime(new Date());
+                pictureMapper.updateByPrimaryKeySelective(picture);
+            }
+        }
+    }
+
+    @Override
+    public WorkOrderPicture selectById(Integer id) {
+        WorkOrderPicture picture = pictureMapper.selectByPrimaryKey(id);
+        return picture;
+    }
+
+    @Override
+    public List<PictureRespVO> selectByOrderId(Long workOrderId) {
+
+        List<WorkOrderPicture> list = pictureMapper.selectByWorkOrderIdAndType(workOrderId, CommonConstant.PICTURE.WORK_ORDER);
+
+        List<PictureRespVO> pictureResps = list.stream().map(s -> {
+            byte[] bytes = null;
+            //读取图片字节
+            try {
+                bytes = bytesUtil.readBlock(s.getUrl(), 0);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+            //获取文件类型
+            File file = new File(s.getUrl());
+            //文件后缀名
+            String type = FilenameUtils.getExtension(file.getName());
+
+            PictureRespVO pictureResp = new PictureRespVO();
+            //图片才会设置base64
+            if (CommonConstant.PICTURE_TYPE.contains(type)) {
+                StringBuilder sb = new StringBuilder();
+                String base64 = sb.append("data:image/").append(type).append(";base64,").append(Base64.encode(bytes)).toString();
+                pictureResp.setBase(base64);
+            }
+            pictureResp.setPictureId(s.getId());
+            pictureResp.setPictureType(type);
+            pictureResp.setFileName(s.getFileName());
+            return pictureResp;
+        }).collect(Collectors.toList());
+        return pictureResps;
+    }
+
+    @Override
+    public void deletedById(Integer id) {
+        pictureMapper.deleteByPrimaryKey(id);
+    }
+
+    @Override
+    public void deletedByWorkOrderIds(List<Long> ids) {
+        if (!ids.isEmpty()) {
+            //先删除文件
+            List<WorkOrderPicture> pictures = new ArrayList<>();
+            for (Long id : ids) {
+                List<WorkOrderPicture> list = pictureMapper.selectByWorkOrderIdAndType(id, CommonConstant.PICTURE.WORK_ORDER);
+                pictures.addAll(list);
+            }
+            for (WorkOrderPicture picture : pictures) {
+                File file = new File(picture.getUrl());
+                if (!file.exists()) {
+                    file.delete();
+                }
+            }
+            //再删除数据库文件数据
+            pictureMapper.deletedBySrcIdsAndType(ids, CommonConstant.PICTURE.WORK_ORDER);
+        }
+    }
+
+    @Override
+    public void updatePicture(WorkOrderUpdateReqVO vo) {
+        //判断是否有图片更新
+        if (vo.getPictureIds() != null) {
+            if (!vo.getPictureIds().isEmpty()) {
+                //先对之前的图片workOrderId 进行赋空值
+                List<WorkOrderPicture> pictures = pictureMapper.selectByWorkOrderIdAndType(vo.getId(), CommonConstant.PICTURE.STATION);
+                List<Integer> pictureIds = pictures.stream().map(WorkOrderPicture::getId).collect(Collectors.toList());
+                if (!pictureIds.isEmpty()) {
+                    pictureMapper.setUpWorkOrderIdIdNUll(pictureIds);
+                }
+                //在新增
+                WorkOrderAddReqVO workOrderAddReqVO = new WorkOrderAddReqVO();
+                BeanUtils.copyProperties(vo, workOrderAddReqVO);
+                insertWorkOrderIdAndType(workOrderAddReqVO);
+            } else {
+                //直接之前的图片workOrderId 进行赋空值
+                List<WorkOrderPicture> pictures = pictureMapper.selectByWorkOrderIdAndType(vo.getId(), CommonConstant.PICTURE.STATION);
+                List<Integer> pictureIds = pictures.stream().map(WorkOrderPicture::getId).collect(Collectors.toList());
+                if (!pictureIds.isEmpty()) {
+                    pictureMapper.setUpWorkOrderIdIdNUll(pictureIds);
+                }
+            }
+        }
+    }
+
+    @Override
+    public List<WorkOrderPicture> selectAll() {
+        List<WorkOrderPicture> workOrderPictures = pictureMapper.selectAll();
+        return workOrderPictures;
+    }
+
+    @Override
+    public void deletedByIds(List<Long> workOrderPictureIds) {
+        if (workOrderPictureIds != null && !workOrderPictureIds.isEmpty()) {
+            pictureMapper.deletedBySrcIdsAndType(workOrderPictureIds, null);
+        }
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/service/impl/WorkOrderPlanServiceImpl.java

@@ -0,0 +1,280 @@
+package com.ho.flow.service.impl;
+
+import com.ho.common.tools.constant.CommonConstant;
+import com.ho.common.tools.exception.BaseResponseCode;
+import com.ho.common.tools.exception.BusinessException;
+import com.ho.flow.entity.WorkOrderPlan;
+import com.ho.flow.entity.WorkOrderPlanSub;
+import com.ho.flow.entity.WorkOrderSub;
+import com.ho.flow.feignclient.BusinessFeignClient;
+import com.ho.flow.feignclient.UserFeignClient;
+import com.ho.flow.mapper.WorkOrderPlanMapper;
+import com.ho.flow.mapper.WorkOrderPlanSubMapper;
+import com.ho.flow.service.ProcessFlowService;
+import com.ho.flow.service.WorkOrderPlanService;
+import com.ho.flow.vo.req.workorderplan.WorkOrderPlanAddReqVO;
+import com.ho.flow.vo.req.workorderplan.WorkOrderPlanReqVO;
+import com.ho.flow.vo.resp.workorderplan.WorkOrderPlanRespVO;
+import com.ho.user.api.vo.req.QueryUserReqVO;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * @Description 工单计划实现类
+ * Author yule
+ * Date 2023/3/16 15:53
+ */
+@Service
+@Slf4j
+public class WorkOrderPlanServiceImpl implements WorkOrderPlanService {
+
+    @Autowired
+    WorkOrderPlanMapper workOrderPlanMapper;
+
+    @Autowired
+    WorkOrderPlanSubMapper workOrderPlanSubMapper;
+
+    @Autowired
+    BusinessFeignClient businessFeignClient;
+
+    @Autowired
+    UserFeignClient userFeignClient;
+
+    @Autowired
+    ProcessFlowService processFlowService;
+
+    @Override
+    @Transactional
+    public void add(WorkOrderPlanAddReqVO vo) {
+        int i = workOrderPlanMapper.insertSelective(vo);
+        if (i < 0){
+            throw new BusinessException(BaseResponseCode.WORK_ORDER_PLAN_ADD_ERROR);
+        }
+        //新增子表数据
+        addWorkOrderPlanSub(vo);
+        //新增工单数据
+        //查询计划执行人(所有类型)
+        List<WorkOrderPlanSub> workOrderPlanSubs = workOrderPlanSubMapper.selectByPid(vo.getId());
+        List<String> userIds = workOrderPlanSubs.stream().filter(s -> {
+            return CommonConstant.WorkOrderPlanSubType.PERSON.equals(s.getType());
+        }).map(WorkOrderPlanSub::getUserId).collect(Collectors.toList());
+        //查询出电站以及设备的子表数据
+        List<WorkOrderSub> workOrderSubs = workOrderPlanSubs.stream().filter(s -> {
+            return !CommonConstant.WorkOrderPlanSubType.PERSON.equals(s.getType());
+        }).map(s -> {
+            WorkOrderSub workOrderSub = new WorkOrderSub();
+            BeanUtils.copyProperties(s, workOrderSub);
+            workOrderSub.setSrcId(s.getSrcId().longValue());
+            return workOrderSub;
+        }).collect(Collectors.toList());
+        processFlowService.planAddWorkOrder(vo, userIds, workOrderSubs);
+    }
+
+    @Override
+    @Transactional
+    public void delete(WorkOrderPlanReqVO vo) {
+        //先删除工单计划数据
+        int i = workOrderPlanMapper.deleteByPrimaryKey(vo.getId());
+        if (i < 0){
+            throw new BusinessException(BaseResponseCode.WORK_ORDER_PLAN_DELETED_ERROR);
+        }
+        //再删除工单计划子表数据
+        int count = workOrderPlanSubMapper.deleteByPid(vo.getId());
+        if (count < 0){
+            throw new BusinessException(BaseResponseCode.WORK_ORDER_PLAN_DELETED_ERROR);
+        }
+    }
+
+    @Override
+    @Transactional
+    public void update(WorkOrderPlanAddReqVO vo) {
+        int i = workOrderPlanMapper.updateByPrimaryKeySelective(vo);
+        if (i < 0){
+            throw new BusinessException(BaseResponseCode.WORK_ORDER_PLAN_UPDATE_ERROR);
+        }
+        //对于关联子表数据,先删除,在新增
+        int j = workOrderPlanSubMapper.deleteByPid(vo.getId());
+        if (j < 0){
+            throw new BusinessException(BaseResponseCode.WORK_ORDER_PLAN_UPDATE_ERROR);
+        }
+        //新增子表数据
+        addWorkOrderPlanSub(vo);
+
+    }
+
+    @Override
+    public WorkOrderPlanRespVO getOne(WorkOrderPlanReqVO vo) {
+        //查询工单计划数据
+        WorkOrderPlan workOrderPlan = workOrderPlanMapper.selectByPrimaryKey(vo.getId());
+        //创建返回值对象
+        WorkOrderPlanRespVO respVO = new WorkOrderPlanRespVO();
+       setName(workOrderPlan,respVO);
+        return respVO;
+    }
+
+    @Override
+    public List<WorkOrderPlanRespVO> getAll(WorkOrderPlanReqVO vo) {
+
+        //查询全部对象
+        List<WorkOrderPlan> list = workOrderPlanMapper.selectByGroupId(vo.getGroupId());
+
+        //创建返回值对象
+        List<WorkOrderPlanRespVO> workOrderPlanRespVOList = new ArrayList<>();
+        if (!list.isEmpty()) {
+            for (WorkOrderPlan workOrderPlan : list) {
+                WorkOrderPlanRespVO respVO = new WorkOrderPlanRespVO();
+                setName(workOrderPlan,respVO);
+                workOrderPlanRespVOList.add(respVO);
+            }
+        }
+
+        return workOrderPlanRespVOList;
+    }
+
+
+    /**
+     *
+     */
+
+    /**
+     * 新增工单计划子表数据
+     * @param vo
+     */
+    private void addWorkOrderPlanSub(WorkOrderPlanAddReqVO vo){
+        //入参中的电站id
+        List<Integer> stationIds = vo.getStationIds();
+        List<WorkOrderPlanSub> srcList = new ArrayList<>();
+        if (stationIds != null) {
+            if (!stationIds.isEmpty()) {
+                for (Integer stationId : stationIds) {
+                    WorkOrderPlanSub workOrderPlanSub = new WorkOrderPlanSub();
+                    workOrderPlanSub.setPid(vo.getId());
+                    workOrderPlanSub.setType(CommonConstant.WorkOrderPlanSubType.STATION);
+                    workOrderPlanSub.setSrcId(stationId);
+                    srcList.add(workOrderPlanSub);
+                }
+            }
+        }
+        //入参中的设备id
+        List<Integer> deviceIds = vo.getDeviceIds();
+        if (deviceIds != null) {
+            if (!deviceIds.isEmpty()) {
+                for (Integer deviceId : deviceIds) {
+                    WorkOrderPlanSub workOrderPlanSub = new WorkOrderPlanSub();
+                    workOrderPlanSub.setPid(vo.getId());
+                    workOrderPlanSub.setType(CommonConstant.WorkOrderPlanSubType.DEVICE);
+                    workOrderPlanSub.setSrcId(deviceId);
+                    srcList.add(workOrderPlanSub);
+                }
+            }
+        }
+        //批量新增
+        int count = workOrderPlanSubMapper.insertBatch(srcList);
+        if (count <= 0){
+            throw new BusinessException(BaseResponseCode.WORK_ORDER_PLAN_SUB_ADD_ERROR);
+        }
+        //入参中的用户id
+        List<WorkOrderPlanSub> userList = new ArrayList<>();
+        List<String> userIds = vo.getUserIds();
+        if (userIds != null) {
+            if (!userIds.isEmpty()) {
+                for (String userId : userIds) {
+                    WorkOrderPlanSub workOrderPlanSub = new WorkOrderPlanSub();
+                    workOrderPlanSub.setPid(vo.getId());
+                    workOrderPlanSub.setType(CommonConstant.WorkOrderPlanSubType.PERSON);
+                    workOrderPlanSub.setUserId(userId);
+                    userList.add(workOrderPlanSub);
+                }
+            }
+        }
+        int i = workOrderPlanSubMapper.insertUserBatch(userList);
+        if (i <= 0){
+            throw new BusinessException(BaseResponseCode.WORK_ORDER_PLAN_SUB_ADD_ERROR);
+        }
+    }
+
+    /**
+     * 给计划工单设置设备名字和电站名字
+     * @param workOrderPlan
+     * @param respVO
+     */
+    private void setName(WorkOrderPlan workOrderPlan,WorkOrderPlanRespVO respVO){
+        if (workOrderPlan != null) {
+            BeanUtils.copyProperties(workOrderPlan, respVO);
+            //查询工单计划所对应的子表数据
+            List<WorkOrderPlanSub> list = workOrderPlanSubMapper.selectByPid(workOrderPlan.getId());
+            //根据类型进行分组
+            Map<Integer, List<WorkOrderPlanSub>> map = list.stream().collect(Collectors.groupingBy(WorkOrderPlanSub::getType));
+            //电站类型
+            List<WorkOrderPlanSub> stationList = map.get(CommonConstant.WorkOrderPlanSubType.STATION);
+            if (stationList != null){
+                //获取电站id集合
+                List<Integer> stationIds = stationList.stream().map(WorkOrderPlanSub::getSrcId).collect(Collectors.toList());
+                respVO.setStationList(stationIds);
+             /*   //远程调用通过电站id查询电站
+                DataResult<List<Station>> result = businessFeignClient.selectByStationIds(stationIds);
+                List<Station> stations = result.getData();
+                if (stations != null){
+                    List<StationWorkOrder> stationWorkOrderList = stations.stream().map(s -> {
+                        StationWorkOrder stationWorkOrder = new StationWorkOrder();
+                        stationWorkOrder.setStationId(s.getId());
+                        stationWorkOrder.setName(s.getName());
+                        return stationWorkOrder;
+                    }).collect(Collectors.toList());
+                    respVO.setStationList(stationWorkOrderList);
+                }*/
+            }
+            //设备类型
+            List<WorkOrderPlanSub> deviceList = map.get(CommonConstant.WorkOrderPlanSubType.DEVICE);
+            if (deviceList != null){
+                //获取电站id集合
+                List<Integer> deviceIds = deviceList.stream().map(WorkOrderPlanSub::getSrcId).collect(Collectors.toList());
+                respVO.setDeviceList(deviceIds);
+                //远程调用通过电站id查询电站
+               /* DataResult<List<Device>> result = businessFeignClient.selectByDeviceIds(deviceIds);
+                List<Device> devices = result.getData();
+                if (devices != null){
+                    List<DeviceWorkOrder> deviceWorkOrderList = devices.stream().map(s -> {
+                        DeviceWorkOrder deviceWorkOrder = new DeviceWorkOrder();
+                        deviceWorkOrder.setDeviceId(s.getId());
+                        deviceWorkOrder.setName(s.getDeviceName());
+                        return deviceWorkOrder;
+                    }).collect(Collectors.toList());
+                    respVO.setDeviceList(deviceWorkOrderList);
+                }*/
+            }
+            //用户类型
+            List<WorkOrderPlanSub> userList = map.get(CommonConstant.WorkOrderPlanSubType.PERSON);
+            if (userList != null){
+                List<QueryUserReqVO> queryUserReqVOS = userList.stream().map(s -> {
+                    //把用户id添加到集合中
+                    QueryUserReqVO queryUserReqVO = new QueryUserReqVO();
+                    queryUserReqVO.setUserId(s.getUserId());
+                    return queryUserReqVO;
+                }).collect(Collectors.toList());
+                List<String> userIds = queryUserReqVOS.stream().map(QueryUserReqVO::getUserId).collect(Collectors.toList());
+                respVO.setUserList(userIds);
+               /* //远程调用通过用户id查询电站
+                DataResult<List<SysUser>> result = userFeignClient.queryUser(queryUserReqVOS);
+                List<SysUser> users = result.getData();
+                if (users != null){
+                    List<UserWorkOrder> userWorkOrderList = users.stream().map(s -> {
+                        UserWorkOrder userWorkOrder = new UserWorkOrder();
+                        userWorkOrder.setUserId(s.getId());
+                        userWorkOrder.setName(s.getRealName());
+                        return userWorkOrder;
+                    }).collect(Collectors.toList());
+                    respVO.setUserList(userWorkOrderList);
+                }*/
+            }
+        }
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/service/impl/WorkOrderServiceImpl.java

@@ -0,0 +1,401 @@
+package com.ho.flow.service.impl;
+
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.ho.business.entity.Station;
+import com.ho.business.vo.resp.DeviceRespVO;
+import com.ho.common.tools.constant.CommonConstant;
+import com.ho.common.tools.entity.OrderDept;
+import com.ho.common.tools.exception.BaseResponseCode;
+import com.ho.common.tools.exception.BusinessException;
+import com.ho.common.tools.exception.DataResult;
+import com.ho.common.tools.util.PageResult;
+import com.ho.common.tools.util.PageUtils;
+import com.ho.flow.entity.WorkOrder;
+import com.ho.flow.entity.WorkOrderSub;
+import com.ho.flow.feignclient.BusinessFeignClient;
+import com.ho.flow.feignclient.UserFeignClient;
+import com.ho.flow.mapper.WorkOrderMapper;
+import com.ho.flow.mapper.WorkOrderSubMapper;
+import com.ho.flow.service.EventService;
+import com.ho.flow.service.WorkOrderPictureService;
+import com.ho.flow.service.WorkOrderService;
+import com.ho.flow.vo.Event;
+import com.ho.flow.vo.req.workorder.WorkOrderAddReqVO;
+import com.ho.flow.vo.req.workorder.WorkOrderPageReq;
+import com.ho.flow.vo.req.workorder.WorkOrderUpdateReqVO;
+import com.ho.flow.vo.resp.workorder.WorkOrderRespVO;
+import com.ho.user.api.vo.req.OrderUserSelectReqVo;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * @Description 工单业务
+ * Author yule
+ * Date 2023/2/4 12:46
+ */
+@Service
+@Slf4j
+public class WorkOrderServiceImpl implements WorkOrderService {
+
+    @Autowired
+    WorkOrderMapper workOrderMapper;
+
+    @Autowired
+    EventService eventService;
+
+    @Autowired
+    WorkOrderPictureService pictureService;
+
+    @Autowired
+    BusinessFeignClient businessFeignClient;
+
+    //注入自身, 防止事务失效
+    @Autowired
+    WorkOrderService workOrderService;
+
+    @Autowired
+    WorkOrderSubMapper workOrderSubMapper;
+
+    @Autowired
+    UserFeignClient userFeignClient;
+
+    @Override
+    @Transactional
+    public int add(WorkOrderAddReqVO vo) {
+        //先对图片进行赋值(类型和工单业务id)
+        //也可能没图片,所以入库前先判断
+        if (vo.getPictureIds() != null && !vo.getPictureIds().isEmpty()) {
+            pictureService.insertWorkOrderIdAndType(vo);
+        }
+
+        //对工单业务数据新增
+        int i = workOrderMapper.insertSelective(vo);
+        //新增子表数据
+        addWorkOrderSub(vo);
+        return i;
+    }
+
+    @Override
+    public int delete(List<Long> ids) {
+        int i = 0;
+        if (!ids.isEmpty()) {
+            i = workOrderMapper.deleteByIds(ids);
+        }
+        return i;
+    }
+
+    @Override
+    public int update(WorkOrder vo) {
+        int i = workOrderMapper.updateByPrimaryKeySelective(vo);
+        if (vo.getEventId() == null){
+            workOrderMapper.setEventNull(vo.getId());
+        }
+        return i;
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int updateWorkOrder(WorkOrderUpdateReqVO vo) {
+        //修改表单和图片
+        pictureService.updatePicture(vo);
+        //先删除子表信息在更新子表数据
+        workOrderSubMapper.deleteByPid(vo.getId());
+        //在新增
+        WorkOrderAddReqVO addReqVO = new WorkOrderAddReqVO();
+        BeanUtils.copyProperties(vo, addReqVO);
+        addWorkOrderSub(addReqVO);
+        //调用自己的
+        if (vo.getProcessId() != null) {
+            int i = workOrderService.update(vo);
+        }
+        return 0;
+    }
+
+    @Override
+    public WorkOrderRespVO getOne(Long id) {
+        if (id != null) {
+            WorkOrder workOrder = workOrderMapper.selectByPrimaryKey(id);
+            WorkOrderRespVO vo = new WorkOrderRespVO();
+            BeanUtils.copyProperties(workOrder, vo);
+            List<WorkOrderSub> workOrderSubs = workOrderSubMapper.selectByPid(vo.getId());
+            //根据类型对子表进行分组
+            Map<Integer, List<WorkOrderSub>> map = workOrderSubs.stream().collect(Collectors.groupingBy(WorkOrderSub::getType));
+            //电站类型
+            List<WorkOrderSub> stations = map.get(CommonConstant.WorkOrderPlanSubType.STATION);
+            if (stations != null) {
+                List<Integer> stationIds = stations.stream().map(s-> {
+                    return s.getSrcId().intValue();
+                }).collect(Collectors.toList());
+                if (stationIds != null && !stationIds.isEmpty()) {
+                    DataResult<List<Station>> stationDataResult = businessFeignClient.selectByStationIds(stationIds);
+                    if (stationDataResult.getData() != null) {
+                        List<Station> stationList = stationDataResult.getData();
+                        vo.setStationList(stationList);
+                    }
+                }
+            } else {
+                vo.setStationList(new ArrayList<>());
+            }
+            //设备类型
+            List<WorkOrderSub> devices = map.get(CommonConstant.WorkOrderPlanSubType.DEVICE);
+            if (devices != null) {
+                List<Integer> deviceIds = devices.stream().map(s-> {
+                    return s.getSrcId().intValue();
+                }).collect(Collectors.toList());
+                if (deviceIds != null && !deviceIds.isEmpty()) {
+                    DataResult<List<DeviceRespVO>> deviceDataResult = businessFeignClient.selectByDeviceIds(deviceIds);
+                    if (deviceDataResult.getData() != null) {
+                        List<DeviceRespVO> deviceList = deviceDataResult.getData();
+                        vo.setDeviceList(deviceList);
+                    }
+                }
+            } else {
+                vo.setDeviceList(new ArrayList<>());
+            }
+            return vo;
+        } else {
+            throw new BusinessException(BaseResponseCode.WORK_ORDER_INPUT_ID);
+        }
+    }
+
+    @Override
+    public WorkOrderRespVO findByOrderId(String orderId) {
+        WorkOrderRespVO workOrder = workOrderMapper.selectByOrderId(orderId);
+        return workOrder;
+    }
+
+    @Override
+    public WorkOrderRespVO findByOrderIdAndTitle(String orderId, String title) {
+        WorkOrderRespVO workOrder = workOrderMapper.selectByOrderIdAndTitle(orderId, title);
+        return workOrder;
+    }
+
+    @Override
+    public WorkOrderRespVO findByProcInstId(String orderId) {
+        WorkOrderRespVO workOrder = workOrderMapper.selectByProcessInstId(orderId);
+        return workOrder;
+    }
+
+    @Override
+    public WorkOrderRespVO findByProcInstIdAndTitle(String processInstanceId, String title) {
+        WorkOrderRespVO workOrder = workOrderMapper.selectByProcessInstIdAndTitle(processInstanceId, title);
+        return workOrder;
+    }
+
+    //工单列表
+    @Override
+    public List<WorkOrderRespVO> findList(WorkOrderPageReq vo) {
+        List<WorkOrderRespVO> workOrders = workOrderMapper.selectByInfo(vo);
+        return workOrders;
+    }
+
+    @Override
+    public PageResult<WorkOrderRespVO> getPage(WorkOrderPageReq vo) {
+        PageHelper.startPage(vo.getPageNum(), vo.getPageSize());
+        List<WorkOrderRespVO> workOrders = workOrderMapper.selectByInfo(vo);
+        for (WorkOrderRespVO workOrder : workOrders) {
+            List<WorkOrderSub> workOrderSubs = workOrderSubMapper.selectByPid(workOrder.getId());
+            //根据类型对子表进行分组
+            Map<Integer, List<WorkOrderSub>> map = workOrderSubs.stream().collect(Collectors.groupingBy(WorkOrderSub::getType));
+            //电站类型
+            List<WorkOrderSub> stations = map.get(CommonConstant.WorkOrderPlanSubType.STATION);
+            List<Integer> stationIds = stations.stream().map(s-> {
+                return s.getSrcId().intValue();
+            }).collect(Collectors.toList());
+            if (stationIds != null && !stationIds.isEmpty()) {
+                DataResult<List<Station>> stationDataResult = businessFeignClient.selectByStationIds(stationIds);
+                if (stationDataResult.getData() != null) {
+                    List<Station> stationList = stationDataResult.getData();
+                    workOrder.setStationList(stationList);
+                }
+
+            }
+            //设备类型
+            List<WorkOrderSub> devices = map.get(CommonConstant.WorkOrderPlanSubType.DEVICE);
+            List<Integer> deviceIds = stations.stream().map(s-> {
+                return s.getSrcId().intValue();
+            }).collect(Collectors.toList());
+            if (deviceIds != null && !deviceIds.isEmpty()) {
+                DataResult<List<DeviceRespVO>> deviceDataResult = businessFeignClient.selectByDeviceIds(deviceIds);
+                if (deviceDataResult.getData() != null) {
+                    List<DeviceRespVO> deviceList = deviceDataResult.getData();
+                    workOrder.setDeviceList(deviceList);
+                }
+            }
+        }
+        PageResult pageResult = PageUtils.getPageResult(new PageInfo<>(workOrders));
+        return pageResult;
+    }
+
+    @Override
+    public List<OrderDept> selectOrderUser(Integer groupId, List<String> postCodes) {
+        //根据postCodes 查询到人
+        OrderUserSelectReqVo vo = new OrderUserSelectReqVo();
+        vo.setGroupId(groupId);
+        vo.setPostCodes(postCodes);
+        DataResult<List<OrderDept>> listDataResult = userFeignClient.selectByPostCodeTree(vo);
+        if (!listDataResult.isSuccess() || listDataResult.getData() == null || listDataResult.getData().isEmpty()) {
+            //throw new BusinessException(BaseResponseCode.NO_QUALIFIED_PERSONNEL_IN_ALL_DEPARTMENTS);
+            return new ArrayList<>();
+        }
+        List<OrderDept> data = listDataResult.getData();
+        return data;
+    }
+
+    @Override
+    public WorkOrderRespVO selectByProcessInstId(String processInstId) {
+        if (processInstId != null) {
+            WorkOrderRespVO vo = workOrderMapper.selectByProcessInstId(processInstId);
+            List<WorkOrderSub> workOrderSubs = workOrderSubMapper.selectByPid(vo.getId());
+            //根据类型对子表进行分组
+            Map<Integer, List<WorkOrderSub>> map = workOrderSubs.stream().filter(s -> {
+                return s.getSrcId() != null;
+            }).collect(Collectors.groupingBy(WorkOrderSub::getType));
+            //电站类型
+            List<WorkOrderSub> stations = map.get(CommonConstant.WorkOrderPlanSubType.STATION);
+            if (stations != null) {
+                List<Integer> stationIds = stations.stream().map(s-> {
+                    return s.getSrcId().intValue();
+                }).collect(Collectors.toList());
+                if (stationIds != null && !stationIds.isEmpty()) {
+                    DataResult<List<Station>> stationDataResult = businessFeignClient.selectByStationIds(stationIds);
+                    if (stationDataResult.getData() != null) {
+                        List<Station> stationList = stationDataResult.getData();
+                        vo.setStationList(stationList);
+                    }
+                }
+            } else {
+                vo.setStationList(new ArrayList<>());
+            }
+            //设备类型
+            List<WorkOrderSub> devices = map.get(CommonConstant.WorkOrderPlanSubType.DEVICE);
+            if (devices != null) {
+                List<Long> deviceLongIds = devices.stream().filter(s->{
+                   return s.getSrcId() != null ;
+                }).map(s->{
+                    return s.getSrcId();
+                }).collect(Collectors.toList());
+                List<Integer> deviceIds = deviceLongIds.stream().map(Long::intValue).collect(Collectors.toList());
+                if (deviceIds != null && !deviceIds.isEmpty()) {
+                    DataResult<List<DeviceRespVO>> deviceDataResult = businessFeignClient.selectByDeviceIds(deviceIds);
+                    if (deviceDataResult.getData() != null) {
+                        List<DeviceRespVO> deviceList = deviceDataResult.getData();
+                        vo.setDeviceList(deviceList);
+                    }
+                }
+            } else {
+                vo.setDeviceList(new ArrayList<>());
+            }
+            //告警类型
+            List<WorkOrderSub> events = map.get(CommonConstant.WorkOrderPlanSubType.EVENT);
+            if (events != null) {
+                List<Long> eventIds = events.stream().map(s->{
+                    return s.getSrcId();
+                }).collect(Collectors.toList());
+                if (eventIds != null && !eventIds.isEmpty()) {
+                   List<Event> eventList =  eventService.selectByIds(eventIds);
+                    vo.setEventList(eventList);
+                }
+            } else {
+                vo.setEventList(new ArrayList<>());
+            }
+
+            /*log.info("selectByProcessInstId vo.getEventId:{}", vo.getEventId());
+            if (vo.getEventId() != null) {
+                Event event = eventService.selectById(vo.getEventId());
+                if (event != null) {
+                    log.info("selectByProcessInstId event :{}", event);
+                    vo.setDescription(event.getDescription());
+                    Event result = eventService.selectByParams(event);
+                    if (result != null) {
+                        log.info("selectByProcessInstId result.getIsRecovery :{}", result.getIsRecovery());
+                        vo.setFlag(result.getIsRecovery());
+                    }
+                }
+            }*/
+            //存什么值 就返回给你什么值
+            //查询字典表中优先级的值
+            /*DataResult<SysSubDict> result = userFeignClient.getDictById(vo.getPriority());
+            if (result.getData() != null){
+                vo.setPriority(Integer.valueOf(result.getData().getValue()));
+            }*/
+            return vo;
+        } else {
+            throw new BusinessException(BaseResponseCode.WORK_ORDER_INPUT_ID);
+        }
+    }
+
+    @Override
+    public Integer selectByStationId(Integer stationId) {
+        Integer orderNums = workOrderMapper.selectByStationId(stationId);
+        return orderNums;
+    }
+
+    private int addWorkOrderSub(WorkOrderAddReqVO vo) {
+        //已经配置好的集合
+        if (vo.getWorkOrderSubs() != null) {
+            List<WorkOrderSub> workOrderSubs = vo.getWorkOrderSubs();
+            for (WorkOrderSub workOrderSub : workOrderSubs) {
+                workOrderSub.setPid(vo.getId());
+            }
+            if (!workOrderSubs.isEmpty()) {
+                return workOrderSubMapper.insertBatch(vo.getWorkOrderSubs());
+            }
+        }
+        //生成一个工单子表对象
+        List<WorkOrderSub> list = new ArrayList<>();
+        if (vo.getStationIds() != null) {
+            if (!vo.getStationIds().isEmpty()) {
+                List<Integer> stationIds = vo.getStationIds();
+                for (Integer stationId : stationIds) {
+                    WorkOrderSub workOrderSub = new WorkOrderSub();
+                    workOrderSub.setPid(vo.getId());
+                    workOrderSub.setSrcId(stationId.longValue());
+                    workOrderSub.setType(CommonConstant.WorkOrderPlanSubType.STATION);
+                    list.add(workOrderSub);
+                }
+
+            }
+        }
+        if (vo.getDeviceIds() != null) {
+            if (!vo.getDeviceIds().isEmpty()) {
+                List<Integer> deviceIds = vo.getDeviceIds();
+                for (Integer deviceId : deviceIds) {
+                    WorkOrderSub workOrderSub = new WorkOrderSub();
+                    workOrderSub.setPid(vo.getId());
+                    workOrderSub.setSrcId(deviceId.longValue());
+                    workOrderSub.setType(CommonConstant.WorkOrderPlanSubType.DEVICE);
+                    list.add(workOrderSub);
+                }
+            }
+        }
+        if (vo.getEventIds() != null) {
+            if (!vo.getEventIds().isEmpty()) {
+                List<Long> eventIds = vo.getEventIds();
+                for (Long eventId : eventIds) {
+                    WorkOrderSub workOrderSub = new WorkOrderSub();
+                    workOrderSub.setPid(vo.getId());
+                    workOrderSub.setSrcId(eventId);
+                    workOrderSub.setType(CommonConstant.WorkOrderPlanSubType.EVENT);
+                    list.add(workOrderSub);
+                }
+            }
+        }
+        //批量新增子表数据
+        if (!list.isEmpty()) {
+            return workOrderSubMapper.insertBatch(list);
+        } else {
+            return 0;
+        }
+    }
+}
+

flowable-center-dao/src/main/java/com/ho/flow/service/process/service/IProcessDefinitionService.java

@@ -0,0 +1,74 @@
+package com.ho.flow.service.process.service;
+
+
+import com.ho.common.tools.util.PageResult;
+import com.ho.flow.entity.process.DefinitionIdDTO;
+import com.ho.flow.entity.process.ProcessDefinitionDTO;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+/**
+ *
+ * 创建日期:2020/10/22-16:34
+ * 版本   开发者     日期
+ * 1.0    Danny    2020/10/22
+ */
+public interface IProcessDefinitionService {
+    /**
+     * 获取流程定义集合
+     * @param processDefinition
+     * @return Page 分页信息
+     */
+    public PageResult<ProcessDefinitionDTO> selectProcessDefinitionList(ProcessDefinitionDTO processDefinition);
+
+    public DefinitionIdDTO getDefinitionsByInstanceId(String instanceId);
+    /**
+     * 删除流程定义
+     * @param id
+     * @return
+     */
+    public int deleteProcessDefinitionById(String id);
+    /**
+     * 上传并部署流程定义
+     * @param file
+     * @return
+     * @throws IOException
+     */
+    public void uploadStreamAndDeployment(MultipartFile file) throws IOException;
+    /**
+     * 启动挂起流程流程定义
+     * @param id 流程定义id
+     * @param suspendState 流程状态
+     * @return
+     */
+    public void suspendOrActiveApply(String id, Integer suspendState);
+
+/*    *//**
+     * 上传流程流程定义
+     * @param multipartFile
+     * @return
+     *//*
+    public String upload(MultipartFile multipartFile) throws IOException;*/
+
+    /**
+     * 通过stringBPMN添加流程定义
+     * @param stringBPMN
+     * @param tenantId
+     */
+    public void addDeploymentByString(String stringBPMN,String tenantId );
+
+    /**
+     * 获取流程定义XML
+     * @param response
+     * @param deploymentId
+     * @param resourceName
+     */
+    public void getProcessDefineXML(HttpServletResponse response, String deploymentId,String resourceName) throws IOException;
+
+    /**
+     * 初始化流程
+     */
+    void initDeploymentByString();
+}

flowable-center-dao/src/main/java/com/ho/flow/service/process/service/OrderFormService.java

@@ -0,0 +1,11 @@
+package com.ho.flow.service.process.service;
+
+/**
+ * @Author yule
+ * @Date 2023/9/7 20:39
+ * @desc ${}
+ */
+public interface OrderFormService {
+
+
+}

flowable-center-dao/src/main/java/com/ho/flow/service/process/service/ProcessFlowNewService.java

@@ -0,0 +1,171 @@
+package com.ho.flow.service.process.service;
+
+import com.ho.common.tools.entity.OrderForm;
+import com.ho.common.tools.entity.ProcessOrder;
+import com.ho.common.tools.entity.SimpleUser;
+import com.ho.flow.entity.process.PreDoUser;
+import com.ho.flow.entity.process.TaskOrderInfo;
+import com.ho.flow.vo.req.workorder.*;
+import com.ho.flow.vo.resp.workorder.FallBackTaskResp;
+import com.ho.flow.vo.resp.workorder.HisTaskResp;
+import com.ho.flow.vo.resp.workorder.TaskDone;
+import com.ho.user.api.entity.SysUser;
+import org.activiti.engine.history.HistoricTaskInstance;
+import org.activiti.engine.task.Task;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @Author yule
+ * @Date 2023/8/29 10:43
+ * @desc ${}
+ */
+public interface ProcessFlowNewService {
+    /**
+     * 流程部署
+     * @param processOrder 表单及流程管理id
+     * @return 流程部署id
+     */
+    String deployment(ProcessOrder processOrder);
+
+    /**
+     * 发起工单
+     * @param processOrder 表单及流程管理id
+     */
+    Integer initProcessInstance(ProcessOrder processOrder);
+
+    /**
+     * //查代办列表,根据用户名集团id查询
+     * @param simpleUser 当前用户
+     * @return 根据状态分组
+     */
+    Map<String, List<Task>> getTodoList(SimpleUser simpleUser);
+
+    /**
+     * 组装任务对象
+     * @param taskMap
+     * @param doListTaskReq
+     * @return
+     */
+    List<TaskDone> getToDoListFromTask(Map<String, List<Task>> taskMap, DoListTaskReq doListTaskReq);
+
+    /**
+     * 根据登录人查询已办任务变量集合
+     * @param simpleUser
+     * @return
+     */
+    List<HistoricTaskInstance> getDoneList(SimpleUser simpleUser);
+
+    /**
+     * 组装已办任务返回集合
+     * @param taskList 办任务变量集合
+     * @param doListTaskReq 已办任务入参
+     * @return
+     */
+    List<TaskDone> getDoneListFromTask(List<HistoricTaskInstance> taskList, DoListTaskReq doListTaskReq);
+
+    /**
+     * 审批通过
+     * @param doTaskReq
+     */
+    void approval(DoTaskReq doTaskReq);
+
+    /**
+     * 审批不通过
+     * @param doTaskReq
+     */
+    void approvalFailed(DoTaskReq doTaskReq);
+
+    /**
+     * 查询可回退节点
+     * @param fallBackTaskReq
+     * @return
+     */
+    List<FallBackTaskResp> getFallBackTask(FallBackTaskReq fallBackTaskReq);
+
+    /**
+     * 回退任务
+     * @param rejectTaskReq
+     */
+    void fallBackTask(RejectTaskReq rejectTaskReq);
+
+    /**
+     * 工单详情
+     * @param taskReq
+     * @return
+     */
+    List<HisTaskResp> detailsTask(CirculationTaskReq taskReq);
+
+    /**
+     * 转发工单
+     * @param taskDone
+     */
+    void forward(TaskDone taskDone);
+
+    /**
+     * 流转前查询人员
+     * @param taskUserReq
+     * @return
+     */
+    List<PreDoUser> getPreDo(TaskUserReq taskUserReq);
+
+    /**
+     * 根据流程id查询任务详情
+     * @param taskReq
+     * @return
+     */
+    TaskOrderInfo taskInfo(CirculationTaskReq taskReq);
+
+    /**
+     * 接收任务
+     * @param taskReq
+     */
+    void doClaimTask(TaskUserReq taskReq);
+
+    /**
+     * 保存保单信息
+     * @param taskReq
+     */
+    void save(TaskUserReq taskReq);
+
+    /**
+     * 作废
+     * @param taskReq
+     */
+    void cancel(TaskUserReq taskReq);
+
+    /**
+     * 转发前的候选人列表
+     */
+    List<PreDoUser> preForward(SimpleUser simpleUser);
+
+    /**
+     * 获取第一个节点饿流转人员列表
+     * @param taskUserReq
+     * @return
+     */
+    List<PreDoUser> getFristPreDo(TaskUserReq taskUserReq);
+
+    /**
+     * 第一次流转
+     * @param doTaskReq
+     */
+    void getFristApproval(DoTaskReq doTaskReq);
+
+    /**
+     * 第一次查询任务
+     * @param taskReq
+     * @return
+     */
+    TaskOrderInfo firstTaskInfo(CirculationTaskReq taskReq);
+
+    void saveOrderForm(TaskUserReq taskReq);
+
+    List<HisTaskResp> detailsFirstTask(CirculationTaskReq taskReq);
+
+    //查询第一节点的候选岗位
+    public List<SysUser> getFristUsers(String processKey);
+
+    List<OrderForm> getInspectionOrders(Integer stationId);
+}

flowable-center-dao/src/main/java/com/ho/flow/service/process/service/ProcessManagementService.java

@@ -0,0 +1,52 @@
+package com.ho.flow.service.process.service;
+
+import com.ho.common.tools.util.PageResult;
+import com.ho.flow.entity.ProcessTemplate;
+
+/**
+ * @Author yule
+ * @Date 2023/8/18 9:21
+ * @desc ${}
+ */
+public interface ProcessManagementService {
+
+    /**
+     * 新增流程模板对象
+     * @param processTemplate
+     */
+    void add(ProcessTemplate processTemplate);
+
+    /**
+     * 删除流程模板对象
+     * @param processTemplate
+     */
+    void delete(ProcessTemplate processTemplate);
+
+
+    /**
+     * 修改流程模板对象
+     * @param processTemplate
+     */
+    void edit(ProcessTemplate processTemplate);
+
+    /**
+     * 根据id查询流程模板
+     * @param id
+     * @return
+     */
+    ProcessTemplate getInfo(Integer id);
+
+    /**
+     * 分页查询流程模板对象
+     * @param processTemplate
+     * @return
+     */
+    PageResult<ProcessTemplate> selectPage(ProcessTemplate processTemplate);
+
+    /**
+     * 根据id获取流程图
+     * @param id
+     * @return
+     */
+    String getBpmn(Integer id);
+}

flowable-center-dao/src/main/java/com/ho/flow/service/process/service/ProcessTemplateService.java

@@ -0,0 +1,61 @@
+package com.ho.flow.service.process.service;
+
+
+import com.ho.common.tools.util.PageResult;
+import com.ho.flow.entity.ProcessTemplate;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.List;
+
+/**
+* @author yule
+* @description 针对表【process_template】的数据库操作Service
+* @createDate 2023-08-17 10:45:32
+*/
+public interface ProcessTemplateService {
+
+    /**
+     * 新增流程模板对象
+     * @param processTemplate
+     */
+    void add(ProcessTemplate processTemplate);
+
+    /**
+     * 删除流程模板对象
+     * @param processTemplate
+     */
+    void delete(ProcessTemplate processTemplate);
+
+
+    /**
+     * 修改流程模板对象
+     * @param processTemplate
+     */
+    void edit(ProcessTemplate processTemplate);
+
+    /**
+     * 根据id查询流程模板
+     * @param id
+     * @return
+     */
+    ProcessTemplate getInfo(Integer id);
+
+    /**
+     * 分页查询流程模板对象
+     * @param processTemplate
+     * @return
+     */
+    PageResult<ProcessTemplate> selectPage(ProcessTemplate processTemplate);
+
+
+
+    void getBpmn(HttpServletResponse response,Integer id) throws IOException;
+
+    /**
+     * 下拉查询
+     * @param processTemplate
+     * @return
+     */
+    List<ProcessTemplate> selectList(ProcessTemplate processTemplate);
+}

flowable-center-dao/src/main/java/com/ho/flow/service/process/service/impl/OrderFormServiceImpl.java

@@ -0,0 +1,20 @@
+package com.ho.flow.service.process.service.impl;
+
+import com.ho.flow.mapper.OrderFormMapper;
+import com.ho.flow.service.process.service.OrderFormService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+/**
+ * @Author yule
+ * @Date 2023/9/7 20:39
+ * @desc ${}
+ */
+@Service
+public class OrderFormServiceImpl implements OrderFormService {
+
+    @Autowired
+    OrderFormMapper orderFormMapper;
+
+
+}

flowable-center-dao/src/main/java/com/ho/flow/service/process/service/impl/ProcessDefinitionServiceImpl.java

@@ -0,0 +1,226 @@
+package com.ho.flow.service.process.service.impl;
+
+import com.github.pagehelper.Page;
+import com.github.pagehelper.PageInfo;
+import com.ho.common.tools.service.RedisService;
+import com.ho.common.tools.util.PageResult;
+import com.ho.common.tools.util.PageUtils;
+import com.ho.flow.entity.process.ActReDeploymentVO;
+import com.ho.flow.entity.process.DefinitionIdDTO;
+import com.ho.flow.entity.process.ProcessDefinitionDTO;
+import com.ho.flow.mapper.ActReDeploymentMapper;
+import com.ho.flow.service.process.service.IProcessDefinitionService;
+import com.ho.flow.util.XmlToJsonUtil;
+import com.ho.flow.vo.XmlBean;
+import org.activiti.engine.HistoryService;
+import org.activiti.engine.RepositoryService;
+import org.activiti.engine.RuntimeService;
+import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntityImpl;
+import org.activiti.engine.repository.Deployment;
+import org.activiti.engine.repository.ProcessDefinition;
+import org.activiti.engine.repository.ProcessDefinitionQuery;
+import org.activiti.engine.runtime.ProcessInstance;
+import org.apache.commons.io.FilenameUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.zip.ZipInputStream;
+
+/**
+ *
+ * 创建日期:2020/10/23-9:52
+ * 版本   开发者     日期
+ * 1.0    Danny    2020/10/23
+ */
+
+@Service
+public class ProcessDefinitionServiceImpl implements IProcessDefinitionService {
+    @Autowired
+    private RepositoryService repositoryService;
+
+    @Autowired
+    private ActReDeploymentMapper actReDeploymentMapper;
+
+    @Autowired
+    private HistoryService historyService;
+
+    @Autowired
+    private RuntimeService runtimeService;
+
+    @Override
+    public PageResult<ProcessDefinitionDTO> selectProcessDefinitionList(ProcessDefinitionDTO processDefinition) {
+        PageResult pageResult = new PageResult<>();
+        Page<ProcessDefinitionDTO> list = new Page<>();
+        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery().orderByProcessDefinitionId().orderByProcessDefinitionVersion().desc();
+        if (StringUtils.isNotBlank(processDefinition.getName())) {
+            processDefinitionQuery.processDefinitionNameLike("%" + processDefinition.getName() + "%");
+        }
+        if (StringUtils.isNotBlank(processDefinition.getKey())) {
+            processDefinitionQuery.processDefinitionKeyLike("%" + processDefinition.getKey() + "%");
+        }
+        List<ProcessDefinition> processDefinitions = processDefinitionQuery.processDefinitionTenantId(processDefinition.getTenantId()).listPage((processDefinition.getPageNum() - 1) * processDefinition.getPageSize(), processDefinition.getPageSize());
+        long count = processDefinitionQuery.count();
+        list.setTotal(count);
+        if (count!=0) {
+            Set<String> ids = processDefinitions.parallelStream().map(pdl -> pdl.getDeploymentId()).collect(Collectors.toSet());
+            List<ActReDeploymentVO> actReDeploymentVOS = actReDeploymentMapper.selectActReDeploymentByIds(ids);
+            List<ProcessDefinitionDTO> processDefinitionDTOS = processDefinitions.stream()
+                    .map(pd -> new ProcessDefinitionDTO((ProcessDefinitionEntityImpl) pd, actReDeploymentVOS.parallelStream().filter(ard -> pd.getDeploymentId().equals(ard.getId())).findAny().orElse(new ActReDeploymentVO())))
+                    .collect(Collectors.toList());
+            list.addAll(processDefinitionDTOS);
+        }
+        pageResult = PageUtils.getPageResult(new PageInfo<>(list));
+        pageResult.setPageNum(processDefinition.getPageNum());
+        pageResult.setPageSize(processDefinition.getPageSize());
+        pageResult.setTotalRows(count);
+        pageResult.setTotalPages((int) (count / processDefinition.getPageSize() + 1));
+        return pageResult;
+    }
+
+    @Override
+    public DefinitionIdDTO getDefinitionsByInstanceId(String instanceId) {
+        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(instanceId).singleResult();
+        String deploymentId = processInstance.getDeploymentId();
+        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().deploymentId(deploymentId).singleResult();
+        return new DefinitionIdDTO(processDefinition);
+    }
+
+    @Override
+    public int deleteProcessDefinitionById(String id) {
+        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
+                .deploymentId(id)
+                .singleResult();
+        if (redisService.hasKey(processDefinition.getKey())){
+            redisService.delete(processDefinition.getKey());
+        }
+        repositoryService.deleteDeployment(id, true);
+        return 1;
+    }
+
+    @Override
+    public void uploadStreamAndDeployment(MultipartFile file) throws IOException {
+        // 获取上传的文件名
+        String fileName = file.getOriginalFilename();
+        // 得到输入流（字节流）对象
+        InputStream fileInputStream = file.getInputStream();
+        // 文件的扩展名
+        String extension = FilenameUtils.getExtension(fileName);
+
+        if (extension.equals("zip")) {
+            ZipInputStream zip = new ZipInputStream(fileInputStream);
+            repositoryService.createDeployment()//初始化流程
+                    .addZipInputStream(zip)
+                    .deploy();
+        } else {
+            repositoryService.createDeployment()//初始化流程
+                    .addInputStream(fileName, fileInputStream)
+                    .deploy();
+        }
+    }
+
+    @Override
+    public void suspendOrActiveApply(String id, Integer suspendState) {
+        if (1==suspendState) {
+            // 当流程定义被挂起时，已经发起的该流程定义的流程实例不受影响（如果选择级联挂起则流程实例也会被挂起）。
+            // 当流程定义被挂起时，无法发起新的该流程定义的流程实例。
+            // 直观变化：act_re_procdef 的 SUSPENSION_STATE_ 为 2
+            repositoryService.activateProcessDefinitionById(id);
+        } else if (2==suspendState) {
+            repositoryService.suspendProcessDefinitionById(id);
+        }
+    }
+/*    @Override
+    public String upload(MultipartFile multipartFile) throws IOException {
+        R<SysFile> sysFileR =  remoteFileService.upload(multipartFile);
+       return sysFileR.getData().getUrl();
+//       return FileUploadUtils.upload(RuoYiConfig.getUploadPath()+"/processDefinition" , multipartFile);
+    }*/
+
+    @Autowired
+    RedisService redisService;
+
+    @Override
+    public void addDeploymentByString(String stringBPMN,String tenantId) {
+        Deployment deploy = repositoryService.createDeployment()
+                .addString("CreateWithBPMNJS.bpmn", stringBPMN)
+                .tenantId(tenantId)
+                .deploy();
+        //获取第一个任务节点的设置岗位
+        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
+                .deploymentId(deploy.getId())
+                .singleResult();
+        //Map<String, String> taskUsers = XmlToJsonUtil.getTaskUsers(stringBPMN);
+        //String postId = taskUsers.get("candidateGroups");
+        //redisService.set(processDefinition.getKey(),postId);
+        //Map<String,List<String>> map = new HashMap<>();
+        //List<String> one = new ArrayList<>();
+        //map.put("Activity_02mwyun",one);
+        //List<String> two = new ArrayList<>();
+        //two.add("Activity_02mwyun");
+        //map.put("Activity_1fqvk3w",two);
+        //List<String> three = new ArrayList<>();
+        //three.add("Activity_02mwyun");
+        //three.add("Activity_1fqvk3w");
+        //map.put("Activity_1re1on4",three);
+        //redisService.set(processDefinition.getKey()+"his",map);
+        redisService.set(processDefinition.getKey(),stringBPMN);
+
+        Map<String, Map<String, String>> allTaskUsers = XmlToJsonUtil.getAllTaskUsers(stringBPMN);
+        redisService.set(processDefinition.getKey()+XmlToJsonUtil.ALL_USER,allTaskUsers);
+
+        Map<String, String> taskUsers = XmlToJsonUtil.getTaskUsers(stringBPMN);
+        redisService.set(processDefinition.getKey()+XmlToJsonUtil.FIRST_USER,taskUsers);
+
+        LinkedList<String> preTaskNodes = XmlToJsonUtil.getPreTaskNodes(stringBPMN, "");
+        redisService.set(processDefinition.getKey()+XmlToJsonUtil.PRE_BACK,preTaskNodes);
+
+        List<XmlBean> otherNodeType = XmlToJsonUtil.getOtherNodeType(stringBPMN);
+        redisService.set(processDefinition.getKey()+XmlToJsonUtil.AS_NODE,otherNodeType);
+
+    }
+
+    @Override
+    public void getProcessDefineXML(HttpServletResponse response, String deploymentId, String resourceName) throws IOException {
+        InputStream inputStream = repositoryService.getResourceAsStream(deploymentId, resourceName);
+        int count = inputStream.available();
+        byte[] bytes = new byte[count];
+        response.setContentType("text/xml");
+        OutputStream outputStream = response.getOutputStream();
+        while (inputStream.read(bytes) != -1) {
+            outputStream.write(bytes);
+        }
+        inputStream.close();
+    }
+
+    @Override
+    public void initDeploymentByString() {
+        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
+                .deploymentId("72501")
+                .singleResult();
+        String stringBPMN = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bpmn2:definitions xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:bpmn2=\"http://www.omg.org/spec/BPMN/20100524/MODEL\" xmlns:bpmndi=\"http://www.omg.org/spec/BPMN/20100524/DI\" xmlns:dc=\"http://www.omg.org/spec/DD/20100524/DC\" xmlns:di=\"http://www.omg.org/spec/DD/20100524/DI\" xmlns:activiti=\"http://activiti.org/bpmn\" id=\"sample-diagram\" targetNamespace=\"http://activiti.org/bpmn\" xsi:schemaLocation=\"http://www.omg.org/spec/BPMN/20100524/MODEL BPMN20.xsd\">\n  <bpmn2:process id=\"Process_approve\" isExecutable=\"true\">\n    <bpmn2:startEvent id=\"StartEvent_1\">\n      <bpmn2:outgoing>Flow_0gr15at</bpmn2:outgoing>\n    </bpmn2:startEvent>\n    <bpmn2:userTask id=\"Activity_1ygdu8u\" name=\"处理工单\" activiti:candidateGroups=\"44\">\n      <bpmn2:incoming>Flow_0gr15at</bpmn2:incoming>\n      <bpmn2:outgoing>Flow_0abyi27</bpmn2:outgoing>\n    </bpmn2:userTask>\n    <bpmn2:sequenceFlow id=\"Flow_0gr15at\" sourceRef=\"StartEvent_1\" targetRef=\"Activity_1ygdu8u\" />\n    <bpmn2:userTask id=\"Activity_1kdd4k8\" name=\"领导审批\" activiti:candidateGroups=\"34\">\n      <bpmn2:incoming>Flow_0abyi27</bpmn2:incoming>\n      <bpmn2:outgoing>Flow_02izal9</bpmn2:outgoing>\n    </bpmn2:userTask>\n    <bpmn2:sequenceFlow id=\"Flow_0abyi27\" sourceRef=\"Activity_1ygdu8u\" targetRef=\"Activity_1kdd4k8\" />\n    <bpmn2:endEvent id=\"Event_0ptvnic\">\n      <bpmn2:incoming>Flow_02izal9</bpmn2:incoming>\n    </bpmn2:endEvent>\n    <bpmn2:sequenceFlow id=\"Flow_02izal9\" sourceRef=\"Activity_1kdd4k8\" targetRef=\"Event_0ptvnic\" />\n  </bpmn2:process>\n  <bpmndi:BPMNDiagram id=\"BPMNDiagram_1\">\n    <bpmndi:BPMNPlane id=\"BPMNPlane_1\" bpmnElement=\"Process_approve\">\n      <bpmndi:BPMNEdge id=\"Flow_0gr15at_di\" bpmnElement=\"Flow_0gr15at\">\n        <di:waypoint x=\"448\" y=\"258\" />\n        <di:waypoint x=\"500\" y=\"258\" />\n      </bpmndi:BPMNEdge>\n      <bpmndi:BPMNEdge id=\"Flow_0abyi27_di\" bpmnElement=\"Flow_0abyi27\">\n        <di:waypoint x=\"600\" y=\"258\" />\n        <di:waypoint x=\"660\" y=\"258\" />\n      </bpmndi:BPMNEdge>\n      <bpmndi:BPMNEdge id=\"Flow_02izal9_di\" bpmnElement=\"Flow_02izal9\">\n        <di:waypoint x=\"760\" y=\"258\" />\n        <di:waypoint x=\"822\" y=\"258\" />\n      </bpmndi:BPMNEdge>\n      <bpmndi:BPMNShape id=\"_BPMNShape_StartEvent_2\" bpmnElement=\"StartEvent_1\">\n        <dc:Bounds x=\"412\" y=\"240\" width=\"36\" height=\"36\" />\n      </bpmndi:BPMNShape>\n      <bpmndi:BPMNShape id=\"Activity_1ygdu8u_di\" bpmnElement=\"Activity_1ygdu8u\">\n        <dc:Bounds x=\"500\" y=\"218\" width=\"100\" height=\"80\" />\n      </bpmndi:BPMNShape>\n      <bpmndi:BPMNShape id=\"Activity_1kdd4k8_di\" bpmnElement=\"Activity_1kdd4k8\">\n        <dc:Bounds x=\"660\" y=\"218\" width=\"100\" height=\"80\" />\n      </bpmndi:BPMNShape>\n      <bpmndi:BPMNShape id=\"Event_0ptvnic_di\" bpmnElement=\"Event_0ptvnic\">\n        <dc:Bounds x=\"822\" y=\"240\" width=\"36\" height=\"36\" />\n      </bpmndi:BPMNShape>\n    </bpmndi:BPMNPlane>\n  </bpmndi:BPMNDiagram>\n</bpmn2:definitions>\n";
+        redisService.set(processDefinition.getKey(),stringBPMN);
+
+        Map<String, Map<String, String>> allTaskUsers = XmlToJsonUtil.getAllTaskUsers(stringBPMN);
+        redisService.set(processDefinition.getKey()+XmlToJsonUtil.ALL_USER,allTaskUsers);
+
+        Map<String, String> taskUsers = XmlToJsonUtil.getTaskUsers(stringBPMN);
+        redisService.set(processDefinition.getKey()+XmlToJsonUtil.FIRST_USER,taskUsers);
+
+        LinkedList<String> preTaskNodes = XmlToJsonUtil.getPreTaskNodes(stringBPMN, "");
+        redisService.set(processDefinition.getKey()+XmlToJsonUtil.PRE_BACK,preTaskNodes);
+
+        List<XmlBean> otherNodeType = XmlToJsonUtil.getOtherNodeType(stringBPMN);
+        redisService.set(processDefinition.getKey()+XmlToJsonUtil.AS_NODE,otherNodeType);
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/service/process/service/impl/ProcessManagementServiceImpl.java

@@ -0,0 +1,78 @@
+package com.ho.flow.service.process.service.impl;
+
+import cn.hutool.core.lang.Snowflake;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.ho.common.tools.util.PageResult;
+import com.ho.common.tools.util.PageUtils;
+import com.ho.flow.entity.ProcessTemplate;
+import com.ho.flow.mapper.ProcessManagementMapper;
+import com.ho.flow.service.process.service.ProcessManagementService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @Author yule
+ * @Date 2023/8/18 9:22
+ * @desc ${}
+ */
+@Service
+@Slf4j
+public class ProcessManagementServiceImpl implements ProcessManagementService {
+
+    @Autowired
+    ProcessManagementMapper processManagement;
+
+    @Autowired
+    Snowflake snowflake;
+
+    @Override
+    public void add(ProcessTemplate processTemplate) {
+        long serialNum = snowflake.nextId();
+        processTemplate.setSerialNum(serialNum);
+        int i =  processManagement.insert(processTemplate);
+    }
+
+    @Override
+    public void delete(ProcessTemplate processTemplate) {
+        Integer id = processTemplate.getId();
+        processManagement.delete(id);
+    }
+
+    @Override
+    public void edit(ProcessTemplate processTemplate) {
+        processManagement.update(processTemplate);
+    }
+
+    @Override
+    public ProcessTemplate getInfo(Integer id) {
+        ProcessTemplate processTemplate = processManagement.selectById(id);
+        return processTemplate;
+    }
+
+    @Override
+    public PageResult<ProcessTemplate> selectPage(ProcessTemplate processTemplate) {
+        PageHelper.startPage(processTemplate.getPageNum(),processTemplate.getPageSize());
+        List<ProcessTemplate> result = processManagement.selectList(processTemplate);
+        PageResult pageResult = new PageResult();
+        if (!result.isEmpty() && result != null) {
+            PageResult<ProcessTemplate> page = PageUtils.getPageResult(new PageInfo<>(result));
+            PageInfo<ProcessTemplate> pageInfo = new PageInfo<>(result);
+            pageInfo.setTotal(page.getTotalRows());
+            pageInfo.setPages(page.getTotalPages());
+            pageResult = PageUtils.getPageResult(pageInfo);
+        } else {
+            pageResult.setList(new ArrayList());
+        }
+        return pageResult;
+    }
+
+    @Override
+    public String getBpmn(Integer id) {
+        return processManagement.selectBpmnById(id);
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/service/process/service/impl/ProcessTemplateServiceImpl.java

@@ -0,0 +1,124 @@
+package com.ho.flow.service.process.service.impl;
+
+
+
+import cn.hutool.core.lang.Snowflake;
+import com.alibaba.druid.util.StringUtils;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.ho.common.tools.exception.DataResult;
+import com.ho.common.tools.util.PageResult;
+import com.ho.common.tools.util.PageUtils;
+import com.ho.flow.entity.ProcessTemplate;
+import com.ho.flow.feignclient.UserFeignClient;
+import com.ho.flow.mapper.ProcessTemplateMapper;
+import com.ho.flow.service.process.service.ProcessTemplateService;
+import com.ho.user.api.entity.SysSubDict;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+* @author yule
+* @description 针对表【process_template】的数据库操作Service实现
+* @createDate 2023-08-17 10:45:32
+*/
+@Service
+@Slf4j
+public class ProcessTemplateServiceImpl implements ProcessTemplateService {
+
+    @Autowired
+    ProcessTemplateMapper processTemplateMapper;
+
+    @Autowired
+    Snowflake snowflake;
+
+    @Autowired
+    UserFeignClient userFeignClient;
+
+    @Override
+    public void add(ProcessTemplate processTemplate) {
+        long serialNum = snowflake.nextId();
+        processTemplate.setSerialNum(serialNum);
+      int i =  processTemplateMapper.insert(processTemplate);
+    }
+
+    @Override
+    public void delete(ProcessTemplate processTemplate) {
+        Integer id = processTemplate.getId();
+        processTemplateMapper.delete(id);
+    }
+
+    @Override
+    public void edit(ProcessTemplate processTemplate) {
+        processTemplateMapper.update(processTemplate);
+    }
+
+    @Override
+    public ProcessTemplate getInfo(Integer id) {
+        ProcessTemplate processTemplate = processTemplateMapper.selectById(id);
+        return processTemplate;
+    }
+
+    @Override
+    public PageResult<ProcessTemplate> selectPage(ProcessTemplate processTemplate) {
+        PageHelper.startPage(processTemplate.getPageNum(),processTemplate.getPageSize());
+        List<ProcessTemplate> result = processTemplateMapper.selectList(processTemplate);
+        //模版类型
+        List<Integer> typeIds = result.stream().map(ProcessTemplate::getType).collect(Collectors.toList());
+        //查询模版类型
+        DataResult<List<SysSubDict>> dataResult = userFeignClient.getDictByIds(typeIds);
+        if (dataResult != null && !dataResult.getData().isEmpty()){
+            Map<Integer, List<SysSubDict>> map = dataResult.getData().stream().collect(Collectors.groupingBy(SysSubDict::getId));
+            for (ProcessTemplate template : result) {
+                if (!map.get(template.getType()).isEmpty()) {
+                    List<SysSubDict> sysSubDicts = map.get(template.getType());
+                    template.setTypeName(sysSubDicts.get(0).getLabel());
+                }
+            }
+        }
+        PageResult pageResult = new PageResult();
+        if (!result.isEmpty() && result != null) {
+            PageResult<ProcessTemplate> page = PageUtils.getPageResult(new PageInfo<>(result));
+            PageInfo<ProcessTemplate> pageInfo = new PageInfo<>(result);
+            pageInfo.setTotal(page.getTotalRows());
+            pageInfo.setPages(page.getTotalPages());
+            pageResult = PageUtils.getPageResult(pageInfo);
+        } else {
+            pageResult.setList(new ArrayList());
+        }
+        return pageResult;
+    }
+
+    @Override
+    public List<ProcessTemplate> selectList(ProcessTemplate processTemplate) {
+        return processTemplateMapper.selectList(processTemplate);
+    }
+
+    @Override
+    public void getBpmn(HttpServletResponse response,Integer id) throws IOException {
+        String bpmn = processTemplateMapper.selectBpmnById(id);
+        if (!StringUtils.isEmpty(bpmn)) {
+            byte[] bytes = bpmn.getBytes(StandardCharsets.UTF_8);
+            response.setContentType("text/xml");
+            OutputStream outputStream = response.getOutputStream();
+            outputStream.write(bytes);
+            outputStream.close();
+        }
+    }
+
+
+}
+
+
+
+

flowable-center-dao/src/main/java/com/ho/flow/threads/EventToProcessThread.java

@@ -0,0 +1,99 @@
+package com.ho.flow.threads;
+
+import cn.hutool.core.date.DateUtil;
+import com.ho.business.entity.Station;
+import com.ho.common.tools.entity.OrderForm;
+import com.ho.common.tools.entity.ProcessOrder;
+import com.ho.common.tools.exception.DataResult;
+import com.ho.flow.entity.process.MovementDTO;
+import com.ho.flow.entity.process.PreDoUser;
+import com.ho.flow.feignclient.BusinessFeignClient;
+import com.ho.flow.service.process.service.ProcessFlowNewService;
+import com.ho.flow.vo.Event;
+import com.ho.flow.vo.req.workorder.DoTaskReq;
+import com.ho.flow.vo.req.workorder.TaskUserReq;
+import com.ho.user.api.entity.SysUser;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Slf4j
+public class EventToProcessThread implements Runnable {
+    private ProcessFlowNewService processFlowNewService;
+
+    private BusinessFeignClient businessFeignClient;
+
+    private MovementDTO movementDTO;
+
+    public EventToProcessThread(ProcessFlowNewService processFlowNewService, MovementDTO movementDTO,BusinessFeignClient businessFeignClient) {
+        this.processFlowNewService = processFlowNewService;
+        this.movementDTO = movementDTO;
+        this.businessFeignClient = businessFeignClient;
+    }
+
+
+    public static final Integer offset = 6;
+
+    @Override
+    @Transactional
+    public void run() {
+        log.error("EventToProcessThread.run");
+        List<Event> events = movementDTO.getEvents();
+        for (Event event : events) {
+            // 流程模板id和告警等级暂时用写死来测试,之后改成读取数据库关联关系信息来创建
+            ProcessOrder processOrder = new ProcessOrder();
+            OrderForm orderForm = new OrderForm();
+            orderForm.setStationId(event.getStationId());
+            orderForm.setDeviceId(event.getTargetDevice());
+            orderForm.setEventId(event.getId());
+            orderForm.setTitle(event.getDescription());
+            Date afterAddingHours = DateUtil.offsetHour(new Date(), offset);
+            orderForm.setPlannedTime(afterAddingHours);
+            orderForm.setUserId(movementDTO.getUserId() == null ? "1" : movementDTO.getUserId());
+            orderForm.setPriority(movementDTO.getPriority() == null ? 1 : movementDTO.getPriority());
+            orderForm.setOrderType(movementDTO.getOrderType() == null ? 3 : movementDTO.getOrderType());
+            //todo 现只有一套流程定义模版
+            processOrder.setOrderForm(orderForm);
+            processOrder.setKey("Process_approve");
+            processOrder.setUserId(movementDTO.getUserId() == null ? "1" : movementDTO.getUserId());
+            /** todo:新建时不返回实例id **/
+            processFlowNewService.initProcessInstance(processOrder);
+
+            // 立刻执行
+            DoTaskReq doTaskReq = new DoTaskReq();
+            doTaskReq.setType("1");
+            doTaskReq.setOrderForm(orderForm);
+            /** todo: 候选人组 */
+            /** start */
+            //根据用户id查询对应表单数据
+            List<SysUser> users = processFlowNewService.getFristUsers(orderForm.getProcessInstanceKey());
+            DataResult<Station> stationDataResult = businessFeignClient.selectByStationId(event.getStationId());
+            //过滤其他公司的人
+            Integer deptId = stationDataResult.getData().getDeptId();
+            if (!deptId.equals(155)) {
+                users = users.stream().filter(s -> {
+                    if (s.getDeptId().equals(deptId)) {
+                        return true;
+                    } else {
+                        return false;
+                    }
+                }).collect(Collectors.toList());
+            }
+            List<String> candidateUserList = users.stream().map(SysUser::getId).collect(Collectors.toList());
+            /** end */
+            //设置发送者的id
+            doTaskReq.setSenderId(movementDTO.getUserId() == null ? "1" : movementDTO.getUserId());
+            //设置租户id
+            doTaskReq.setTenantId(String.valueOf(event.getGroupId()));
+            //完成任务的责任人必须和自己相同,否则需要给出提示
+            doTaskReq.setAssigneeUser(movementDTO.getUserId() == null ? "1" : movementDTO.getUserId());
+            doTaskReq.setCandidateUserList(candidateUserList);
+            doTaskReq.setSuggestion("");
+//            processFlowNewService.getFristApproval(doTaskReq);
+        }
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/util/EventToProcessThreadPoolUtils.java

@@ -0,0 +1,144 @@
+package com.ho.flow.util;
+
+import com.ho.flow.factory.Factory;
+import com.ho.flow.factory.ThreadRejectedExecutionHandler;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.List;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+@Slf4j
+public class EventToProcessThreadPoolUtils {
+    /**
+     * 系统可用计算资源
+     */
+    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
+
+    /**
+     * 核心线程数
+     */
+    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
+
+    /**
+     * 最大线程数
+     */
+    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
+
+    /**
+     * 空闲线程存活时间
+     */
+    private static final int KEEP_ALIVE_SECONDS = 30;
+
+    /**
+     * 工作队列
+     */
+    private static final BlockingQueue<Runnable> POOL_WORK_QUEUE = new LinkedBlockingQueue<>(128);
+
+    /**
+     * 工厂模式
+     */
+    private static final Factory MY_THREAD_FACTORY = new Factory();
+
+    /**
+     * 饱和策略
+     */
+    private static final ThreadRejectedExecutionHandler THREAD_REJECTED_EXECUTION_HANDLER = new ThreadRejectedExecutionHandler.CallerRunsPolicy();
+
+    /**
+     * 线程池对象
+     */
+    private static final ThreadPoolExecutor THREAD_POOL_EXECUTOR;
+
+    /**
+     * 声明式定义线程池工具类对象静态变量，在所有线程中同步
+     */
+    private static volatile EventToProcessThreadPoolUtils threadPoolUtils = null;
+
+
+    /**
+     * 初始化线程池静态代码块
+     */
+    static {
+        THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(
+                //核心线程数
+                CORE_POOL_SIZE,
+                //最大线程数
+                MAXIMUM_POOL_SIZE,
+                //空闲线程执行时间
+                KEEP_ALIVE_SECONDS,
+                //空闲线程执行时间单位
+                TimeUnit.SECONDS,
+                //工作队列（或阻塞队列）
+                POOL_WORK_QUEUE,
+                //工厂模式
+                MY_THREAD_FACTORY,
+                //饱和策略
+                THREAD_REJECTED_EXECUTION_HANDLER
+        );
+    }
+
+
+    /**
+     * 线程池工具类空参构造方法
+     */
+    private EventToProcessThreadPoolUtils() {}
+
+    /**
+     * 获取线程池工具类实例
+     * @return
+     */
+    public static EventToProcessThreadPoolUtils getNewInstance(){
+        if (threadPoolUtils == null) {
+            synchronized (EventToProcessThreadPoolUtils.class) {
+                if (threadPoolUtils == null) {
+                    threadPoolUtils = new EventToProcessThreadPoolUtils();
+                }
+            }
+        }
+        return threadPoolUtils;
+    }
+
+
+    /**
+     * 执行线程任务
+     * @param runnable 任务线程
+     */
+    public void executor(Runnable runnable) {
+        THREAD_POOL_EXECUTOR.execute(runnable);
+    }
+
+    /**
+     * 获取线程池状态
+     * @return 返回线程池状态
+     */
+    public boolean isShutDown(){
+        return THREAD_POOL_EXECUTOR.isShutdown();
+    }
+
+    /**
+     * 停止正在执行的线程任务
+     * @return 返回等待执行的任务列表
+     */
+    public List<Runnable> shutDownNow(){
+        return THREAD_POOL_EXECUTOR.shutdownNow();
+    }
+
+    /**
+     * 关闭线程池
+     */
+    public void showDown(){
+        THREAD_POOL_EXECUTOR.shutdown();
+    }
+
+
+    /**
+     * 关闭线程池后判断所有任务是否都已完成
+     * @return
+     */
+    public boolean isTerminated(){
+        return THREAD_POOL_EXECUTOR.isTerminated();
+    }
+}

flowable-center-dao/src/main/java/com/ho/flow/util/PDFutil.java

@@ -0,0 +1,225 @@
+package com.ho.flow.util;
+
+import com.itextpdf.text.*;
+import com.itextpdf.text.pdf.PdfPCell;
+import com.itextpdf.text.pdf.PdfPTable;
+import org.springframework.stereotype.Component;
+
+import java.io.IOException;
+
+@Component
+public class PDFutil {
+
+    /**
+     * 设置标题
+     * @param table PTable表格
+     * @param textFont 字体样式
+     * @param value 添加的内容
+     * @param cols 合并几列
+     * @param rows 合并几行
+     * @param middleType 居中类型 0:不居中, 1:水平居中 2:垂直居中
+     * @return PTable表格
+     */
+    public PdfPTable getTitle(PdfPTable table, Font textFont, String value, Integer cols, Integer rows, Integer middleType){
+        PdfPCell cell = new PdfPCell();
+        Paragraph p = new Paragraph(value, textFont);
+        cell.setColspan(cols);
+        cell.setRowspan(rows);
+        if(middleType == 1){
+            p.setAlignment(1);
+            getHorizontalCenter(cell);
+        }else if(middleType == 2){
+            p.setAlignment(1);
+            getVerticalCenter(cell);
+        }
+        cell.setBorderColor(BaseColor.WHITE);// 设置方向后会失效
+        cell.addElement(p);
+        table.addCell(cell);
+        return table;
+    }
+
+    /**
+     * 设置单元格
+     * @param table PTable表格
+     * @param textFont 字体样式
+     * @param value 添加的内容
+     * @param middleType 居中类型 0:不居中, 1:水平居中 2:垂直居中
+     * @return PTable表格
+     */
+    public PdfPTable getPdfCell(PdfPTable table, Font textFont, String value, Integer middleType){
+        PdfPCell cell = new PdfPCell();
+        Paragraph p = new Paragraph(value, textFont);
+        if(middleType == 1){
+            p.setAlignment(1);
+            getHorizontalCenter(cell);
+        }else if(middleType == 2){
+            p.setAlignment(1); // -1:未定义，0:左，1:中，2:右，3:合适的，4:上，5:中，6:下，7:底线
+            getVerticalCenter(cell);
+        }
+        cell.addElement(p);
+        table.addCell(cell);
+        return table;
+    }
+
+    /**
+     * 合并行（合并行(上下合并)时，设置为垂直居中）
+     * @param table PTable表格
+     * @param textFont 字体样式
+     * @param value 添加的内容
+     * @param rows 合并几行
+     * @param middleType 居中类型 0:不居中, 1:水平居中 2:垂直居中
+     * @return PTable表格
+     */
+    public PdfPTable getRowSpan(PdfPTable table, Font textFont, String value, Integer rows, Integer middleType){
+        PdfPCell cell = new PdfPCell();
+        Paragraph p = new Paragraph(value, textFont);
+        cell.setRowspan(rows);
+        if(middleType == 2){
+            p.setAlignment(1);
+            getVerticalCenter(cell);
+        }
+        cell.addElement(p);
+        table.addCell(cell);
+        return table;
+    }
+
+    /**
+     * 合并列（合并列(左右合并)时，设置为水平居中）
+     * @param table PTable表格
+     * @param textFont 字体样式
+     * @param value 添加的内容
+     * @param cols 合并几列
+     * @param middleType 居中类型 0:不居中, 1:水平居中 2:垂直居中
+     * @return PTable表格
+     */
+    public PdfPTable getColSpan(PdfPTable table, Font textFont, String value, Integer cols, Integer middleType){
+        PdfPCell cell = new PdfPCell();
+        Paragraph p = new Paragraph(value, textFont);
+        cell.setColspan(cols);
+        if(middleType == 1){
+            p.setAlignment(1);
+            getHorizontalCenter(cell);
+        }else if(middleType == 2){
+            p.setAlignment(1);
+            getVerticalCenter(cell);
+        }
+        cell.addElement(p);
+        table.addCell(cell);
+        return table;
+    }
+
+    /**
+     * 合并行和列
+     * @param table PTable表格
+     * @param textFont 字体样式
+     * @param value 添加的内容
+     * @param cols 合并几列
+     * @param rows 合并几行
+     * @param middleType 居中类型 0:不居中, 1:水平居中 2:垂直居中
+     * @return PTable表格
+     */
+    public PdfPTable getRowAndColSpan(PdfPTable table, Font textFont, String value,
+                                      Integer cols, Integer rows, Integer middleType){
+        PdfPCell cell = new PdfPCell();
+        Paragraph p = new Paragraph(value, textFont);
+        cell.setColspan(cols);
+        cell.setRowspan(rows);
+        if(middleType == 1){
+            p.setAlignment(1);
+            getHorizontalCenter(cell);
+        }else if(middleType == 2){
+            p.setAlignment(1);
+            getVerticalCenter(cell);
+        }
+        cell.addElement(p);
+        table.addCell(cell);
+        return table;
+    }
+
+    /**
+     * 水平居中
+     * @param cell PdfPCell单元格
+     * @return PdfPCell单元格
+     */
+    public PdfPCell getHorizontalCenter(PdfPCell cell){
+        cell.setHorizontalAlignment(PdfPCell.ALIGN_CENTER);// 水平居中
+        return cell;
+    }
+
+    /**
+     * 垂直居中
+     * @param cell PdfPCell单元格
+     * @return PdfPCell单元格
+     */
+    public PdfPCell getVerticalCenter(PdfPCell cell){
+        cell.setHorizontalAlignment(PdfPCell.ALIGN_CENTER);
+        cell.setVerticalAlignment(PdfPCell.ALIGN_MIDDLE);
+        cell.setPaddingTop(-2f);//把字垂直居中
+        cell.setPaddingBottom(8f);//把字垂直居中
+        return cell;
+    }
+
+    /**
+     * 填充数据
+     * @param table 表
+     * @param str 填充的数据
+     * @param font 字体设置
+     */
+    public void cellFillChar(PdfPTable table,String str,Font font){
+        //如果str为空，不会报错，这个单元格为空
+        PdfPCell cell = new PdfPCell(new Paragraph(str,font));
+        cell.setHorizontalAlignment(Element.ALIGN_CENTER);
+        cell.setVerticalAlignment(PdfPCell.ALIGN_MIDDLE);
+        table.addCell(cell);
+    }
+
+    /**
+     * 图片填充方法
+     * @param table 表
+     * @param path 图片存在路径
+     */
+    public void cellFillImage(PdfPTable table,String path){
+        // 创建图片对象
+        Image image = null;
+        try {
+            image = Image.getInstance(path);
+            image.setScaleToFitHeight(true);
+            image.setScaleToFitLineWhenOverflow(true);
+            if (image != null){
+                // 创建包含图片的单元格
+                PdfPCell cellWithImage = new PdfPCell(image,true);
+                cellWithImage.setFixedHeight(50f);
+                cellWithImage.setHorizontalAlignment(Element.ALIGN_CENTER);
+                cellWithImage.setVerticalAlignment(PdfPCell.ALIGN_MIDDLE);
+                table.addCell(cellWithImage);
+
+            }
+        } catch (BadElementException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * 图片填充方法
+     * @param table 表
+     * @param path 图片存在路径
+     * @param fileName 文件名
+     * @param font 字体
+     */
+    public void cellFillFile(PdfPTable table,String path,String fileName,Font font){
+        // 创建图片对象
+        Chunk imdb = new Chunk(fileName);
+            if (imdb != null){
+                PdfPCell fileCell = new PdfPCell();
+                // 创建包含图片的单元格
+                imdb.setFont(font);
+                imdb.setAnchor(path);
+                fileCell.setHorizontalAlignment(Element.ALIGN_CENTER);
+                fileCell.addElement(imdb);
+                table.addCell(fileCell);
+            }
+    }
+
+}

flowable-center-dao/src/main/java/com/ho/flow/util/XmlToJsonUtil.java

@@ -0,0 +1,384 @@
+package com.ho.flow.util;
+
+
+
+import com.alibaba.fastjson2.JSONArray;
+import com.alibaba.fastjson2.JSONObject;
+import com.github.pagehelper.util.StringUtil;
+import com.ho.flow.vo.XmlBean;
+import org.dom4j.Attribute;
+import org.dom4j.Document;
+import org.dom4j.Element;
+import org.dom4j.io.SAXReader;
+
+import java.io.StringReader;
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class XmlToJsonUtil {
+
+    public static final String ALL_USER = "_allUser";
+
+    public static final String FIRST_USER = "_firstUser";
+
+    public static final String PRE_BACK = "_preBack";
+
+    public static final String AS_NODE = "_asNode";
+
+    public static Map<String,String> getTaskUsers(String xmlStr){
+        Map<String,String> result = new HashMap<String,String>();
+        JSONObject jsonObject = xmlToJson(xmlStr);
+        JSONObject process = null;
+        if ( jsonObject.containsKey("process") ){
+            process = JSONObject.from(jsonObject.get("process"));
+        }
+        JSONObject content = null;
+        if ( process.containsKey("content") ) {
+            content = JSONObject.from(process.get("content"));
+        }
+        JSONArray userTask = null;
+        if ( content.containsKey("userTask") ) {
+            userTask = JSONArray.from(content.get("userTask"));
+        }
+        List<Map<String, String>> collect = null;
+        if ( userTask != null ) {
+            collect = userTask.stream().map( task -> {
+                Map<String, String> map = new HashMap<String, String>();
+                JSONObject from = JSONObject.from(task);
+                if( from.containsKey("candidateUsers") ){
+                    map.put("candidateUsers", from.get("candidateUsers").toString());
+                }
+                if( from.containsKey("candidateGroups") ){
+                    map.put("candidateGroups",from.get("candidateGroups").toString());
+                }
+                return map;
+            }).collect(Collectors.toList());
+        }
+        if( collect != null && collect.size() > 0 ){
+            result = collect.get(0);
+        }
+        return result;
+    }
+
+    public static Map<String,Map<String,String>> getAllTaskUsers(String xmlStr){
+        Map<String,Map<String,String>> result = new HashMap<String,Map<String,String>>(0);
+        Map<String,String> dataMap = new HashMap<String,String>();
+        JSONObject jsonObject = xmlToJson(xmlStr);
+        JSONObject process = null;
+        if ( jsonObject.containsKey("process") ){
+            process = JSONObject.from(jsonObject.get("process"));
+        }
+        JSONObject content = null;
+        if ( process.containsKey("content") ) {
+            content = JSONObject.from(process.get("content"));
+        }
+        JSONArray userTask = null;
+        if ( content.containsKey("userTask") ) {
+            userTask = JSONArray.from(content.get("userTask"));
+        }
+        List<Map<String, String>> collect = null;
+        if ( userTask != null ) {
+            collect = userTask.stream().map( task -> {
+                Map<String, String> map = new HashMap<String, String>();
+                JSONObject from = JSONObject.from(task);
+                if( from.containsKey("id") ){
+                    map.put("id", from.getString("id"));
+                }
+                if( from.containsKey("candidateUsers") ){
+                    map.put("candidateUsers", from.getString("candidateUsers"));
+                }
+                if( from.containsKey("candidateGroups") ){
+                    map.put("candidateGroups",from.getString("candidateGroups"));
+                }
+                return map;
+            }).collect(Collectors.toList());
+        }
+        for (Map<String, String> data : collect) {
+            result.put(data.get("id"),data);
+        }
+        return result;
+    }
+
+    /**
+     * 获取前面所有的用户节点
+     * @param xml   xml字符串
+     * @param key   当前节点的id
+     * @return
+     */
+    public static LinkedList<String> getPreTaskNodes(String xml, String key){
+        LinkedList<String> nodeKeys = new LinkedList<>();
+        JSONObject jsonObject = xmlToJson(xml);
+        // 取process节点
+        JSONObject process = jsonObject.getJSONObject("process");
+        // 取content节点
+        JSONObject content = process.getJSONObject("content");
+
+        // 取指向箭头
+        JSONArray sequenceFlows = content.getJSONArray("sequenceFlow");
+        // 取网关
+        JSONArray exclusiveGateway = content.getJSONArray("exclusiveGateway");
+        // 网关id map
+        Map<String,String> gateWayMap = getMapFromJsonArray(exclusiveGateway);
+
+        // 取用户节点
+        JSONArray userTask = content.getJSONArray("userTask");
+        // 用户节点id map
+        Map<String,String> taskMap = getMapFromJsonArray(userTask);
+
+        // 取开始节点
+        JSONObject startEvent = content.getJSONObject("startEvent");
+        int index = 1;
+        for (Object o : sequenceFlows) {
+            JSONObject sequenceFlow = JSONObject.from(o);
+            // 来
+            String sourceRef = sequenceFlow.getString("sourceRef");
+            if( taskMap.containsKey(sourceRef) ){
+                System.out.println("sourceRef = " + sourceRef + " -> index = " + index);
+                nodeKeys.add(sourceRef);
+                index++;
+            }
+            if( sourceRef.equals(key) ){
+                break;
+            }
+        }
+        return nodeKeys;
+    }
+
+    private static Map<String,String> getMapFromJsonArray(JSONArray jsonArray) {
+        Map<String,String> result = new HashMap<>();
+        if (jsonArray != null) {
+            for (Object o : jsonArray) {
+                JSONObject task = JSONObject.from(o);
+                String id = task.getString("id");
+                result.put(id, id);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * 获取当前节点之前和之后的节点是否是网关,开始或结束节点
+     * @param xml
+     */
+    public static List<XmlBean> getOtherNodeType(String xml){
+        JSONObject jsonObject = getProcess(xml);
+
+        // 流程id
+        String id = "";
+        if( jsonObject.containsKey("id") ){
+            id = jsonObject.getString("id");
+        }
+
+        JSONObject content = null;
+        if( jsonObject.containsKey("content") ){
+            content = jsonObject.getJSONObject("content");
+        }
+
+        if( content == null ){
+            System.out.println("content为空,直接跳出");
+            return null;
+        }
+
+        // 开始节点id
+        String startId = "";
+        if( content.containsKey("startEvent") ){
+            startId = content.getJSONObject("startEvent").getString("id");
+        }
+        //System.out.println("startId = " + startId);
+
+        // 结束节点id
+        String endId = "";
+        if( content.containsKey("endEvent") ){
+            endId = content.getJSONObject("endEvent").getString("id");
+        }
+        //System.out.println("endId = " + endId);
+
+        // 取所有网关
+        JSONArray exclusiveGateway = new JSONArray();
+        if( content.containsKey("exclusiveGateway") ){
+            exclusiveGateway = content.getJSONArray("exclusiveGateway");
+        }
+
+        Map<String,String> gateways = new HashMap<String,String>(0);
+
+        for (Object o : exclusiveGateway) {
+            JSONObject json = JSONObject.from(o);
+            gateways.put(getNodeValueFromObject(json,"id"),"");
+        }
+
+        // 指向箭头
+        JSONArray sequenceFlow = null;
+        if( content.containsKey("sequenceFlow") ){
+            sequenceFlow = content.getJSONArray("sequenceFlow");
+        }
+        Map<String,Map<String,String>> flowMap = new HashMap<String,Map<String,String>>(0);
+        Map<String,String> flow = null;
+
+        for (Object o : sequenceFlow) {
+            flow = new HashMap<String,String>(0);
+            JSONObject json = JSONObject.from(o);
+            // 来
+            String sourceRef = getNodeValueFromObject(json,"sourceRef");
+            // 去
+            String targetRef = getNodeValueFromObject(json,"targetRef");
+            flow.put("sourceRef",sourceRef);
+            flow.put("targetRef",targetRef);
+            flowMap.put(json.getString("id"),flow);
+        }
+
+        // 用户节点
+        JSONArray userTask = null;
+        if( content.containsKey("userTask") ){
+            userTask = content.getJSONArray("userTask");
+        }
+
+        List<XmlBean> beans = new ArrayList<XmlBean>(0);
+        XmlBean bean = null;
+
+        if(userTask != null){
+            for (Object o : userTask) {
+                bean = new XmlBean();
+                JSONObject json = JSONObject.from(o);
+                bean.setNodeKey(getNodeValueFromObject(json,"id"));
+                if( json.containsKey("content") ){
+                    JSONObject userTaskContent = json.getJSONObject("content");
+                    // 从哪里来
+                    String incoming = getNodeValueFromObject(userTaskContent, "incoming");
+                    // 到哪里去
+                    String outgoing = getNodeValueFromObject(userTaskContent, "outgoing");
+                    if( flowMap.containsKey(incoming) ){
+                        // 如果从这个箭头来,那么判断前一个节点是否是网关\开始
+                        String sourceRef = getValueFromMap(flowMap, incoming, "sourceRef");
+                        bean.setPreStart( sourceRef.equals(startId) );
+                        bean.setPreGateway( gateways.containsKey(sourceRef) );
+                        bean.setPreNodeKey(sourceRef);
+                    }
+
+                    if( flowMap.containsKey(outgoing) ){
+                        // 如果到这个箭头去,那么判断后一个节点是否是网关\结束
+                        String targetRef = getValueFromMap(flowMap, outgoing, "targetRef");
+                        bean.setAfterGateway( gateways.containsKey(targetRef) );
+                        bean.setAfterEnd( targetRef.equals(endId) );
+                        bean.setAfterNodeKey(targetRef);
+                    }
+                }
+                beans.add(bean);
+            }
+        }
+        //beans.stream().forEach(System.out::println);
+        return beans;
+    }
+
+    private static String getNodeValueFromObject(JSONObject json, String key){
+        String value = "";
+        if( json != null && json.containsKey(key) ){
+            value = json.getString(key);
+        }
+        return value;
+    }
+
+    private static String getValueFromMap(Map<String, Map<String, String>> map, String key, String innerKey){
+        String value = "";
+        if( map != null && map.containsKey(key) ){
+            Map<String,String> flow = map.get(key);
+            if( flow != null && flow.containsKey(innerKey) ){
+                value = flow.get(innerKey).toString();
+            }
+        }
+        return value;
+    }
+
+    public static JSONObject getProcess(String xml) {
+        JSONObject jsonObject = new JSONObject();
+        if (StringUtil.isEmpty(xml)) {
+            return jsonObject;
+        }
+        String xmlStr = replaceAllCahr(xml);
+        try {
+            jsonObject = xmlToJson(xmlStr);
+            if (jsonObject.containsKey("process")) {
+                jsonObject = JSONObject.from(jsonObject.get("process"));
+            }
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+        return jsonObject;
+    }
+
+    /**
+     * XML字符串转换JSON对象
+     *
+     * @param xmlStr XML字符串
+     * @return JSON对象
+     */
+    public static JSONObject xmlToJson(String xmlStr) {
+        JSONObject result = new JSONObject(1);
+        SAXReader xmlReader = new SAXReader();
+        try {
+            Document document = xmlReader.read(new StringReader(xmlStr));
+            Element element = document.getRootElement();
+            return xmlToJson(element, result);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return result;
+    }
+
+    /**
+     * XML节点转换JSON对象
+     *
+     * @param element 节点
+     * @param object  新的JSON存储
+     * @return JSON对象
+     */
+    private static JSONObject xmlToJson(Element element, JSONObject object) {
+        List<Element> elements = element.elements();
+        for (Element child : elements) {
+            Object value = object.get(child.getName());
+            Object newValue;
+
+            if (child.elements().size() > 0) {
+                JSONObject jsonObject = xmlToJson(child, new JSONObject(1));
+                if (!jsonObject.isEmpty()) {
+                    newValue = jsonObject;
+                } else {
+                    newValue = child.getText();
+                }
+            } else {
+                newValue = child.getText();
+            }
+
+            List<Attribute> attributes = child.attributes();
+            if (!attributes.isEmpty()) {
+                JSONObject attrJsonObject = new JSONObject();
+                for (Attribute attribute : attributes) {
+                    attrJsonObject.put(attribute.getName(), attribute.getText());
+                    attrJsonObject.put("content", newValue);
+                }
+                newValue = attrJsonObject;
+            }
+
+            if (newValue != null) {
+                if (value != null) {
+                    if (value instanceof JSONArray) {
+                        ((JSONArray) value).add(newValue);
+                    } else {
+                        JSONArray array = new JSONArray();
+                        array.add(value);
+                        array.add(newValue);
+                        object.put(child.getName(), array);
+                    }
+                } else {
+                    object.put(child.getName(), newValue);
+                }
+            }
+        }
+        return object;
+    }
+
+    public static String replaceAllCahr(String str) {
+        return str.replaceAll("\r", "").replaceAll("\n", "")
+                .replaceAll("\t", "");
+    }
+
+}

flowable-center-dao/src/main/resources/mapper/ActReDeploymentMapper.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper
+PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.ho.flow.mapper.ActReDeploymentMapper">
+
+	<resultMap type="com.ho.flow.entity.process.ActReDeploymentVO" id="ActReDeploymentResult">
+		<id     property="id"       column="id"      />
+		<result property="deployTime"       column="deploy_time"      />
+	</resultMap>
+	
+
+	<sql id="selectDeploymentVo">
+       select ID_ id,DEPLOY_TIME_ deploy_time from `ACT_RE_DEPLOYMENT`
+    </sql>
+
+	
+	<select id="selectActReDeploymentByIds"  parameterType="String" resultMap="ActReDeploymentResult">
+	    <include refid="selectDeploymentVo"/>
+		where ID_  in
+		<foreach collection="ids" item="id" index="index" open="(" separator="," close=")">
+			#{id}
+		</foreach>
+	</select>
+
+
+</mapper> 

flowable-center-dao/src/main/resources/mapper/AlarmConfigMapper.xml

@@ -0,0 +1,318 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.ho.flow.mapper.AlarmConfigMapper">
+
+    <resultMap id="BaseResultMap" type="com.ho.flow.vo.AlarmConfig">
+        <id property="id" column="id" jdbcType="INTEGER"/>
+        <result property="groupId" column="group_id" jdbcType="INTEGER"/>
+        <result property="stationId" column="station_id" jdbcType="INTEGER"/>
+        <result property="colDefineId" column="col_define_id" jdbcType="INTEGER"/>
+        <result property="deviceTypeId" column="device_type_id" jdbcType="INTEGER"/>
+        <result property="deviceType" column="device_type" jdbcType="VARCHAR"/>
+        <result property="col" column="col" jdbcType="VARCHAR"/>
+        <result property="colName" column="col_name" jdbcType="VARCHAR"/>
+        <result property="sensType" column="sens_type" jdbcType="VARCHAR"/>
+        <result property="info0" column="info0" jdbcType="VARCHAR"/>
+        <result property="info1" column="info1" jdbcType="VARCHAR"/>
+        <result property="upperLimit" column="upper_limit" jdbcType="DECIMAL"/>
+        <result property="lowerLimit" column="lower_limit" jdbcType="DECIMAL"/>
+        <result property="alarmLevel" column="alarm_level" jdbcType="DECIMAL"/>
+        <result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
+        <result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
+        <result property="deleted" column="deleted" jdbcType="VARCHAR"/>
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        id
+        ,group_id,station_id,`scope`,
+        col_define_id,device_type_id,device_name,device_type,
+        col,col_name,sens_type,info0,info1,
+        upper_limit,lower_limit,alarm_level,
+        create_time,update_time,deleted
+    </sql>
+
+    <sql id="Insert_Batch_Column_List">
+        group_id
+        ,station_id,`scope`,
+        col_define_id,device_type_id,device_name,device_type,
+        col,col_name,sens_type,info0,info1,upper_limit,lower_limit,alarm_level,
+        create_time,deleted
+    </sql>
+
+
+    <insert id="insert" keyColumn="id" keyProperty="id">
+        insert into alarm_config
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+            <if test="record.groupId != null">group_id,</if>
+            <if test="record.stationId != null">station_id,</if>
+            <if test="record.scope != null">scope,</if>
+            <if test="record.colDefineId != null">col_define_id,</if>
+            <if test="record.deviceTypeId != null">device_type_id ,</if>
+            <if test="record.deviceName != null">device_name ,</if>
+            <if test="record.deviceType != null">device_type,</if>
+            <if test="record.col != null">col,</if>
+            <if test="record.colName != null">col_name,</if>
+            <if test="record.sensType != null">sens_type,</if>
+            <if test="record.info0 != null">info0,</if>
+            <if test="record.info1 != null">info1,</if>
+            <if test="record.upperLimit != null">upper_limit,</if>
+            <if test="record.lowerLimit != null">lower_limit,</if>
+            <if test="record.alarmLevel != null">alarm_level,</if>
+            <if test="record.createTime != null">create_time,</if>
+            <if test="record.updateTime != null">update_time,</if>
+            <if test="record.deleted != null">deleted,</if>
+        </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+            <if test="record.groupId != null">#{record.groupId,jdbcType=INTEGER},</if>
+            <if test="record.stationId!= null">#{record.stationId,jdbcType=INTEGER},</if>
+            <if test="record.scope!= null">#{record.scope,jdbcType=INTEGER},</if>
+            <if test="record.colDefineId != null">#{record.colDefineId},</if>
+            <if test="record.deviceTypeId != null">#{record.deviceTypeId},</if>
+            <if test="record.deviceName != null">#{record.deviceName},</if>
+            <if test="record.deviceType != null">#{record.deviceType},</if>
+            <if test="record.col != null">#{record.col},</if>
+            <if test="record.colName != null">#{record.colName},</if>
+            <if test="record.sensType != null">#{record.sensType},</if>
+            <if test="record.info0 != null">#{record.info0},</if>
+            <if test="record.info1 != null">#{record.info1},</if>
+            <if test="record.upperLimit != null">#{record.upperLimit},</if>
+            <if test="record.lowerLimit != null">#{record.lowerLimit},</if>
+            <if test="record.alarmLevel != null">#{record.alarmLevel},</if>
+            <if test="record.createTime != null">#{record.createTime},</if>
+            <if test="record.updateTime != null">#{record.updateTime},</if>
+            <if test="record.deleted != null">#{record.deleted},</if>
+
+        </trim>
+    </insert>
+
+    <insert id="insertBatch" useGeneratedKeys="true" keyColumn="id" keyProperty="id">
+        insert into alarm_config (<include refid="Insert_Batch_Column_List"/>)
+        values
+        <foreach item="item" collection="list" index="index" separator=",">
+            (
+            #{item.groupId},#{item.stationId},#{item.scope},
+            #{item.colDefineId},#{item.deviceTypeId},#{item.deviceName},#{item.deviceType},
+            #{item.col},#{item.colName},#{item.sensType},#{item.info0},#{item.info1},#{item.upperLimit},#{item.lowerLimit},
+            #{item.alarmLevel},now(),1
+            )
+        </foreach>
+    </insert>
+
+    <update id="updateBatch" keyColumn="id" keyProperty="id" parameterType="java.util.List" useGeneratedKeys="true">
+        <foreach collection="list" item="item" index="index" separator=";">
+            update alarm_config set device_name = #{item.deviceName},col_name = #{item.colName},sens_type = #{item.sensType},
+            info0 = #{item.info0},info1 = #{item.info1},upper_limit = #{item.upperLimit},lower_limit = #{item.lowerLimit},
+            alarm_level = #{item.alarmLevel}, update_time = #{item.updateTime}
+            where id = #{item.id}
+        </foreach>
+    </update>
+
+    <update id="updateByPrimaryKeySelective">
+        update alarm_config
+        <set>
+            <if test="record.groupId != null">
+                group_id = #{record.groupId,jdbcType=INTEGER},
+            </if>
+            <if test="record.stationId != null">
+                station_id = #{record.stationId,jdbcType=INTEGER},
+            </if>
+            <if test="record.colDefineId != null">
+                col_define_id = #{record.colDefineId},
+            </if>
+            <if test="record.deviceTypeId != null">
+                device_type_id = #{record.deviceTypeId},
+            </if>
+
+            <if test="record.deviceType != null">
+                device_type = #{record.deviceType},
+            </if>
+            <if test="record.deviceName != null">
+                device_name = #{record.deviceName},
+            </if>
+            <if test="record.col != null">
+                col = #{record.col},
+            </if>
+            <if test="record.colName != null">
+                col_name = #{record.colName},
+            </if>
+            <if test="record.sensType != null">
+                sens_type = #{record.sensType},
+            </if>
+            <if test="record.upperLimit != null">
+                upper_limit = #{record.upperLimit},
+            </if>
+            <if test="record.lowerLimit != null">
+                lower_limit = #{record.lowerLimit},
+            </if>
+            <if test="record.alarmLevel != null">
+                alarm_level = #{record.alarmLevel},
+            </if>
+            <if test="record.createTime != null">
+                create_time = #{record.createTime},
+            </if>
+            <if test="record.updateTime != null">
+                update_time = #{record.updateTime},
+            </if>
+            <if test="record.deleted != null">
+                deleted = #{record.deleted},
+            </if>
+        </set>
+        where id = #{record.id,jdbcType=INTEGER}
+    </update>
+
+    <select id="selectById" resultType="com.ho.flow.vo.AlarmConfig">
+        select
+        <include refid="Base_Column_List"/>
+        from alarm_config
+        where id = #{id,jdbcType=INTEGER}
+    </select>
+
+    <select id="selectList" resultType="com.ho.flow.vo.AlarmConfig">
+        select
+        <include refid="Base_Column_List"/>
+        from alarm_config
+        <where>
+            <if test="record.groupId != null">
+                and group_id = #{record.groupId}
+            </if>
+            <if test="record.stationId != null">
+                and station_id = #{record.stationId}
+            </if>
+            <if test="record.deviceType != null">
+                and device_type = #{record.deviceType}
+            </if>
+            <if test="record.sensType != null">
+                and sens_type = #{record.sensType}
+            </if>
+            <if test="record.alarmLevel != null">
+                and alarm_level = #{record.alarmLevel}
+            </if>
+            <if test="record.otherAlarmLevel != null">
+                and alarm_level != #{record.otherAlarmLevel}
+            </if>
+            <if test="record.scope != null">
+                and `scope` = #{record.scope}
+            </if>
+            <if test="record.colIds!=null and record.colIds.size()!=0">
+                and col_define_id in
+                <foreach collection="record.colIds" item="item" open="(" close=")" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="record.colName != null and record.colName !=''">
+                and `col_name` LIKE CONCAT('%',#{record.colName},'%')
+            </if>
+            <if test="record.colNameList != null and record.colNameList.size >0 ">
+                <foreach collection="record.colNameList" item="item" open=" " close=" " separator=" ">
+                    and `col_name` LIKE CONCAT('%',#{item},'%')
+                </foreach>
+            </if>
+            <if test="record.deviceTypeList != null and record.deviceTypeList.size > 0">
+                and device_type in
+                <foreach collection="record.deviceTypeList" item="item" open="(" close=")" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="record.deviceTypeSuffix != null">
+                and device_type like concat('%',#{record.deviceTypeSuffix})
+            </if>
+            and deleted = 1
+        </where>
+        order by group_id,station_id, col, scope
+    </select>
+
+    <select id="selectRepeatValue" resultType="com.ho.flow.vo.AlarmConfig">
+        select
+        <include refid="Base_Column_List"/>
+        from alarm_config
+        <where>
+            <if test="groupId != null">
+                and group_id = #{groupId}
+            </if>
+            <if test="stationId != null">
+                and station_id = #{stationId}
+            </if>
+            <if test="scope != null">
+                and scope = #{scope}
+            </if>
+            <if test="colDefineId != null">
+                and col_define_id = #{colDefineId}
+            </if>
+            and deleted = 1
+        </where>
+    </select>
+
+    <select id="selectListByParams" resultType="com.ho.flow.vo.AlarmConfig">
+        select
+        <include refid="Base_Column_List"/>
+        from alarm_config
+        <where>
+            <if test="stationId != null">
+                and station_id = #{stationId}
+            </if>
+            <if test="deviceType != null">
+                and device_type = #{deviceType}
+            </if>
+        </where>
+    </select>
+
+    <delete id="deleteByPrimaryKey">
+        delete
+        from alarm_config
+        where id = #{id,jdbcType=INTEGER}
+    </delete>
+
+    <delete id="deleteByParam">
+        delete
+        from alarm_config
+        where station_id = #{stationId} or device_type like concat('%',#{deviceType})
+    </delete>
+
+    <delete id="deleteBatch">
+        delete
+        from alarm_config
+        <where>
+            and id in
+            <foreach collection="list" open="(" close=")" separator="," item="item">
+                #{item}
+            </foreach>
+        </where>
+    </delete>
+
+    <update id="updateByParams">
+        update alarm_config
+        <set>
+            <if test="record.upperLimit != null">
+                upper_limit = #{record.upperLimit},
+            </if>
+            <if test="record.lowerLimit != null">
+                lower_limit = #{record.lowerLimit},
+            </if>
+            <if test="record.alarmLevel != null">
+                alarm_level = #{record.alarmLevel},
+            </if>
+            <if test="record.updateTime != null">
+                update_time = #{record.updateTime},
+            </if>
+            <if test="record.deleted != null">
+                deleted = #{record.deleted},
+            </if>
+        </set>
+        <where>
+            <if test="record.scope != null">
+                and `scope` = #{record.scope}
+            </if>
+            <if test="record.stationId != null">
+                and station_id = #{record.stationId,jdbcType=INTEGER}
+            </if>
+            <if test="record.id != null">
+                and col_define_id = #{record.id}
+            </if>
+            <if test="record.deviceType != null">
+                and device_type = #{record.deviceType}
+            </if>
+        </where>
+    </update>
+</mapper>

flowable-center-dao/src/main/resources/mapper/BusiIdControlMapper.xml

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.ho.flow.mapper.BusiIdControlMapper">
+
+    <sql id="Base_Column_List">
+        id
+        ,id_type,current_value
+    </sql>
+
+    <select id="selectByType" resultType="com.ho.flow.vo.BusiIdControl">
+        select
+        <include refid="Base_Column_List"/>
+        from busi_id_control
+        <where>
+            <if test="idType != null">
+                and id_type = #{idType}
+            </if>
+        </where>
+    </select>
+
+    <insert id="insert" keyColumn="id" keyProperty="id"
+            useGeneratedKeys="true">
+        insert into busi_id_control
+            (id_type, current_value)
+        values (#{idType}, #{currentValue})
+    </insert>
+
+    <update id="update">
+        update busi_id_control
+                set current_value = #{currentValue}
+        where id = #{id}
+    </update>
+
+</mapper>

flowable-center-dao/src/main/resources/mapper/DeviceColDefineMapper.xml

@@ -0,0 +1,195 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.ho.flow.mapper.DeviceColDefineMapper">
+
+
+    <sql id="Base_Column_List">
+        `id`
+        , `device_type_id`, `device_name`, `device_type`, `col`,
+        `col_name`, `sens_type`,info0,info1
+    </sql>
+
+
+    <select id="selectPage" resultType="com.ho.flow.vo.DeviceColDefine">
+        select
+        <include refid="Base_Column_List"/>
+        from device_col_define
+        <where>
+            <!--<if test="deviceType != null">
+                and `device_type` LIKE CONCAT('%',#{deviceType},'%')
+            </if>-->
+            <if test="deviceType != null">
+                and `device_type` = #{deviceType}
+            </if>
+            <if test="sensType != null">
+                and sens_type = #{sensType}
+            </if>
+            <if test="col != null and col!=''">
+                and `col` LIKE CONCAT('%',#{col},'%')
+            </if>
+            <if test="colName != null and colName!=''">
+                and `col_name` LIKE CONCAT('%',#{colName},'%')
+            </if>
+            <if test="colNameList != null and colNameList.size >0 ">
+                <foreach collection="colNameList" item="item" open=" " close=" " separator=" ">
+                    and `col_name` LIKE CONCAT('%',#{item},'%')
+                </foreach>
+            </if>
+            <if test="name != null and name!=''">
+                and (col_name LIKE concat('%',#{name},'%') or col LIKE concat('%',#{name},'%'))
+            </if>
+            <if test="deviceTypeList != null and deviceTypeList.size > 0">
+                and device_type in
+                <foreach collection="deviceTypeList" item="item" open="(" close=")" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="deviceTypeSuffix !=null and deviceTypeSuffix !='' ">
+                and device_type like concat('%',#{deviceTypeSuffix})
+            </if>
+        </where>
+    </select>
+
+    <select id="selectById" resultType="com.ho.flow.vo.DeviceColDefine">
+        select
+        <include refid="Base_Column_List"/>
+        from device_col_define
+        where id = #{id}
+    </select>
+
+    <select id="selectByIdList" resultType="com.ho.flow.vo.DeviceColDefine">
+        select
+        <include refid="Base_Column_List"/>
+        from device_col_define
+        <where>
+            <if test="deviceType!=null">
+                and device_type = #{deviceType}
+            </if>
+            <if test="ids!=null and ids.size()!=0">
+                and id in
+                <foreach collection="ids" item="item" open="(" close=")" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+        </where>
+
+    </select>
+
+    <select id="selectByIdAndDeviceTypeId" resultType="com.ho.flow.vo.DeviceColDefine">
+        select
+        <include refid="Base_Column_List"/>
+        from device_col_define
+        <where>
+            <if test="id != null">
+                and id = #{id}
+            </if>
+            <if test="deviceTypeId != null">
+                and device_type_id = #{deviceTypeId}
+            </if>
+        </where>
+    </select>
+
+    <select id="selectByColAndDeviceType" resultType="com.ho.flow.vo.DeviceColDefine">
+        select
+        <include refid="Base_Column_List"/>
+        from device_col_define
+        <where>
+            <if test="col != null">
+                and col = #{col}
+            </if>
+            <if test="deviceType != null">
+                and device_type = #{deviceType}
+            </if>
+
+        </where>
+    </select>
+    <select id="selectByDeviceType" resultType="com.ho.flow.vo.DeviceColDefine">
+        select
+        <include refid="Base_Column_List"/>
+        from device_col_define
+        where
+        `device_type` LIKE CONCAT('%',#{deviceType},'%')
+    </select>
+
+    <insert id="insertList" keyColumn="id" keyProperty="id" parameterType="java.util.List" useGeneratedKeys="true">
+        insert into device_col_define (device_type_id,device_name,device_type,col,col_name,col_en,lang,sens_type,info0,info1) values
+        <foreach collection="list" item="item" index="index" separator=",">
+            (#{item.deviceTypeId},#{item.deviceName},#{item.deviceType},#{item.col},#{item.colName},#{item.colEn},#{item.lang},#{item.sensType},#{item.info0},#{item.info1})
+        </foreach>
+    </insert>
+
+    <update id="updateList" keyColumn="id" keyProperty="id" parameterType="java.util.List" useGeneratedKeys="true">
+        <foreach collection="list" item="item" index="index" separator=";">
+            update device_col_define set device_type_id = #{item.deviceTypeId}, device_name = #{item.deviceName},
+            device_type = #{item.deviceType}, col = #{item.col},col_name = #{item.colName},
+            col_en = #{item.colEn},lang = #{item.lang}, sens_type = #{item.sensType}, info0 = #{item.info0}, info1 = #{item.info1}
+            where id = #{item.id}
+        </foreach>
+    </update>
+
+    <insert id="insertDeviceColDefine" keyColumn="id" keyProperty="id" parameterType="com.ho.flow.vo.DeviceColDefine"
+            useGeneratedKeys="true">
+        insert into device_col_define
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+            <if test="deviceTypeId != null">device_type_id,</if>
+            <if test="deviceName != null">device_name,</if>
+            <if test="deviceType != null">device_type,</if>
+            <if test="col != null">col,</if>
+            <if test="colName != null">col_name,</if>
+            <if test="sensType != null">sens_type,</if>
+            <if test="info0 != null">info0,</if>
+            <if test="info1 != null">info1,</if>
+        </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+            <if test="deviceTypeId != null">#{deviceTypeId},</if>
+            <if test="deviceName != null">#{deviceName},</if>
+            <if test="deviceType != null">#{deviceType},</if>
+            <if test="col != null">#{col},</if>
+            <if test="colName != null">#{colName},</if>
+            <if test="sensType != null">#{sensType},</if>
+            <if test="info0 != null">#{info0},</if>
+            <if test="info1 != null">#{info1},</if>
+        </trim>
+    </insert>
+
+    <update id="updateDeviceColDefine" parameterType="com.ho.flow.vo.DeviceColDefine">
+        update device_col_define
+        <set>
+            <if test="deviceName != null">
+                device_name = #{deviceName},
+            </if>
+            <if test="deviceType != null">
+                device_type = #{deviceType},
+            </if>
+            <if test="colName != null">
+                col_name = #{colName},
+            </if>
+            <if test="sensType != null">
+                sens_type = #{sensType},
+            </if>
+            <if test="info0 != null">
+                info0 = #{info0},
+            </if>
+            <if test="info1 != null">
+                info1 =#{info1},
+            </if>
+        </set>
+        where id = #{id}
+    </update>
+
+    <delete id="deleteDeviceColDefine">
+        delete
+        from device_col_define
+        <where>
+            <if test="ids != null and ids.size !=0">
+                and id in
+                <foreach collection="ids" open="(" close=")" separator="," item="item">
+                    #{item}
+                </foreach>
+            </if>
+        </where>
+    </delete>
+
+</mapper>

flowable-center-dao/src/main/resources/mapper/EventMapper.xml

@@ -0,0 +1,781 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.ho.flow.mapper.EventMapper">
+
+    <select id="selectByInfo" resultType="com.ho.flow.vo.resp.event.EventRespVO">
+        select
+        <include refid="Base_Column_List"/>
+        from event
+        <where>
+            <if test="record.targetDevice != null">
+                and target_device = #{record.targetDevice}
+            </if>
+            <if test="record.srcIdList != null and record.srcIdList.size != 0 ">
+                and target_device in
+                <foreach collection="record.srcIdList" open="(" close=")" separator="," item="item">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="record.eventColReqList != null and record.eventColReqList.size != 0 ">
+                and
+                <foreach collection="record.eventColReqList" open="(" close=")" separator=" or " item="item">
+                    ( target_device = #{item.srcId}
+                    <if test="item.colList != null">
+                        and `signal` in
+                        <foreach collection="item.colList" open="(" close=")" separator="," item="st">
+                            #{st}
+                        </foreach>
+                    </if>
+                    )
+                </foreach>
+
+            </if>
+            <if test="record.description != null and record.description != ''">
+                and description LIKE concat('%',#{record.description},'%')
+            </if>
+            <if test="record.stationIds != null and record.stationIds.size != 0">
+                and station_id in
+                <foreach collection="record.stationIds" open="(" close=")" separator="," item="item">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="record.deviceTypeList != null and record.deviceTypeList.size != 0">
+                and device_type in
+                <foreach collection="record.deviceTypeList" open="(" close=")" separator="," item="deviceType">
+                    #{deviceType.deviceType}
+                </foreach>
+            </if>
+            <if test="record.startTime != null">
+                and time_stamp &gt;= #{record.startTime}
+            </if>
+            <if test="record.endTime != null">
+                and time_stamp &lt;= #{record.endTime}
+            </if>
+            <if test="depts != null and depts.size != 0">
+                and dept_id in
+                <foreach collection="depts" open="(" close=")" separator="," item="item">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="record.status != null">
+                and status = #{record.status}
+            </if>
+            <trim prefix="and (" suffix=")">
+                <if test="record.eventTypes != null and record.eventTypes.size != 0">
+                    event_type in
+                    <foreach collection="record.eventTypes" open="(" close=")" separator="," item="type">
+                        #{type}
+                    </foreach>
+                </if>
+                <if test="record.eventTypes != null and record.eventTypes.size != 0
+             and record.eventLevels != null and record.eventLevels.size != 0">
+                    or
+                </if>
+                <if test="record.eventLevels != null and record.eventLevels.size != 0">
+                    event_level in
+                    <foreach collection="record.eventLevels" open="(" close=")" separator="," item="level">
+                        #{level}
+                    </foreach>
+                </if>
+            </trim>
+            <if test="record.userLevel != null and record.userLevel>0">
+                and (`signal` = 'polymerization' or device_type ='accesspoint')
+            </if>
+            <if test="record.userLevel == null or record.userLevel==0">
+                and `signal` != 'polymerization'
+            </if>
+            order by time_stamp desc
+            <!--限制的查询记录数,防止记录集过大-->
+            <if test="record.limitCount!=null">
+                limit #{record.limitCount}
+            </if>
+        </where>
+
+    </select>
+
+    <select id="selectCountStatusByInfo" resultType="java.lang.Integer">
+        select count(1)
+        from event
+        where status = 0
+        <if test="record.targetDevice != null">
+            and target_device = #{record.targetDevice}
+        </if>
+        <if test="record.description != null and record.description != ''">
+            and description LIKE concat('%',#{record.description},'%')
+        </if>
+        <if test="record.stationIds != null and record.stationIds.size != 0">
+            and station_id in
+            <foreach collection="record.stationIds" open="(" close=")" separator="," item="item">
+                #{item}
+            </foreach>
+        </if>
+        <if test="record.deviceTypeList != null and record.deviceTypeList.size != 0">
+            and device_type in
+            <foreach collection="record.deviceTypeList" open="(" close=")" separator="," item="deviceType">
+                #{deviceType.deviceType}
+            </foreach>
+        </if>
+        <if test="record.startTime != null">
+            and time_stamp &gt;= #{record.startTime}
+        </if>
+        <if test="record.endTime != null">
+            and time_stamp &lt;= #{record.endTime}
+        </if>
+        <trim prefix="and (" suffix=")">
+            <if test="record.eventTypes != null and record.eventTypes.size != 0">
+                event_type in
+                <foreach collection="record.eventTypes" open="(" close=")" separator="," item="type">
+                    #{type}
+                </foreach>
+            </if>
+            <if test="record.eventTypes != null and record.eventTypes.size != 0
+             and record.eventLevels != null and record.eventLevels.size != 0">
+                or
+            </if>
+            <if test="record.eventLevels != null and record.eventLevels.size != 0">
+                event_level in
+                <foreach collection="record.eventLevels" open="(" close=")" separator="," item="level">
+                    #{level}
+                </foreach>
+            </if>
+        </trim>
+        <if test="record.userLevel != null and record.userLevel>0">
+            and (`signal` = 'polymerization' or device_type ='accesspoint')
+        </if>
+        <if test="record.userLevel == null or record.userLevel==0">
+            and `signal` != 'polymerization'
+        </if>
+    </select>
+
+    <sql id="Base_Column_List">
+        id
+        ,station_id,dept_id,group_id,
+        event_type,event_level,time_stamp,
+        target_device,device_type, device_type_id, `signal`,`status`,
+        value,description,confirm_status,
+        confirm_man,confirm_time,remark,
+        suggestion,create_time,update_time,
+        category,type,sub_type,sens_type,is_recovery,before_event_id
+    </sql>
+
+
+    <select id="selectByPrimaryKey" resultType="com.ho.flow.vo.Event">
+        select
+        <include refid="Base_Column_List"/>
+        from event
+        where id = #{id}
+    </select>
+
+    <select id="selectByBeforeEventId" resultType="com.ho.flow.vo.Event">
+        select
+        <include refid="Base_Column_List"/>
+        from event
+        where before_event_id = #{id}
+    </select>
+
+    <select id="selectNumByType" resultType="com.ho.flow.vo.resp.event.EventTypeNum">
+        SELECT event_type,COUNT(event_type) AS COUNT
+        FROM event
+        where
+        event_type IS NOT NULL
+        <if test="record.startTime != null">
+            and time_stamp &gt;= #{record.startTime}
+        </if>
+        <if test="record.endTime != null">
+            and time_stamp &lt;= #{record.endTime}
+        </if>
+        <if test="record.status != null">
+            and status = #{record.status}
+        </if>
+        <if test="record.srcIdList != null and record.srcIdList.size !=0 ">
+            and target_device in
+            <foreach collection="record.srcIdList" open="(" close=")" separator="," item="item">
+                #{item}
+            </foreach>
+        </if>
+        <if test="record.eventColReqList != null and record.eventColReqList.size != 0 ">
+            and
+            <foreach collection="record.eventColReqList" open="(" close=")" separator=" or " item="item">
+                ( target_device = #{item.srcId}
+                <if test="item.colList != null">
+                    and `signal` in
+                    <foreach collection="item.colList" open="(" close=")" separator="," item="st">
+                        #{st}
+                    </foreach>
+                </if>
+                )
+            </foreach>
+
+        </if>
+        <if test="record.description != null">
+            and description like concat('%',#{record.description},'%')
+        </if>
+        <if test="record.stationIds != null and record.stationIds.size != 0">
+            and station_id in
+            <foreach collection="record.stationIds" open="(" close=")" separator="," item="item">
+                #{item}
+            </foreach>
+        </if>
+        <if test="depts != null and depts.size != 0">
+            and dept_id in
+            <foreach collection="depts" open="(" close=")" separator="," item="item">
+                #{item}
+            </foreach>
+        </if>
+        <!--选中的deviceTypeIds-->
+        <if test="record.deviceTypeList != null and record.deviceTypeList.size != 0">
+            and device_type in
+            <foreach collection="record.deviceTypeList" open="(" close=")" separator="," item="deviceType">
+                #{deviceType.deviceType}
+            </foreach>
+        </if>
+        <if test="record.userLevel != null and record.userLevel>0">
+            and (`signal` = 'polymerization' or device_type ='accesspoint')
+        </if>
+        <if test="record.userLevel == null or record.userLevel==0">
+            and `signal` != 'polymerization'
+        </if>
+        GROUP BY event_type
+    </select>
+    <select id="selectNumByLevel" resultType="com.ho.flow.vo.resp.event.EventLevelNum">
+        SELECT event_level,COUNT(event_level) AS COUNT
+        FROM `event`
+        where
+        event_level IS NOT NULL
+        <if test="record.startTime != null">
+            and time_stamp &gt;= #{record.startTime}
+        </if>
+        <if test="record.endTime != null">
+            and time_stamp &lt;= #{record.endTime}
+        </if>
+        <if test="record.status != null">
+            and status = #{record.status}
+        </if>
+        <if test="record.srcIdList != null and record.srcIdList.size !=0 ">
+            and target_device in
+            <foreach collection="record.srcIdList" open="(" close=")" separator="," item="item">
+                #{item}
+            </foreach>
+        </if>
+        <if test="record.eventColReqList != null and record.eventColReqList.size != 0 ">
+            and
+            <foreach collection="record.eventColReqList" open="(" close=")" separator=" or " item="item">
+                ( target_device = #{item.srcId}
+                <if test="item.colList != null">
+                    and `signal` in
+                    <foreach collection="item.colList" open="(" close=")" separator="," item="st">
+                        #{st}
+                    </foreach>
+                </if>
+                )
+            </foreach>
+
+        </if>
+        <if test="record.description != null">
+            and description like concat('%',#{record.description},'%')
+        </if>
+        <if test="record.stationIds != null and record.stationIds.size != 0">
+            and station_id in
+            <foreach collection="record.stationIds" open="(" close=")" separator="," item="item">
+                #{item}
+            </foreach>
+        </if>
+        <if test="depts != null and depts.size != 0">
+            and dept_id in
+            <foreach collection="depts" open="(" close=")" separator="," item="item">
+                #{item}
+            </foreach>
+        </if>
+        <!--选中的deviceTypeIds-->
+        <if test="record.deviceTypeList != null and record.deviceTypeList.size != 0">
+            and device_type in
+            <foreach collection="record.deviceTypeList" open="(" close=")" separator="," item="deviceType">
+                #{deviceType.deviceType}
+            </foreach>
+        </if>
+        <if test="record.userLevel != null and record.userLevel>0">
+            and (`signal` = 'polymerization' or device_type ='accesspoint')
+        </if>
+        <if test="record.userLevel == null or record.userLevel==0">
+            and `signal` != 'polymerization'
+        </if>
+        GROUP BY event_level
+    </select>
+
+    <select id="selectByIds" resultType="com.ho.flow.vo.Event">
+        SELECT
+        <include refid="Base_Column_List"/>
+        FROM `event`
+        where id in
+        <foreach collection="list" open="(" close=")" separator="," item="item">
+            #{item}
+        </foreach>
+        order by time_stamp desc
+    </select>
+
+    <delete id="deleteByPrimaryKey" parameterType="java.lang.Long">
+        delete
+        from event
+        where id = #{id,jdbcType=BIGINT}
+    </delete>
+    <insert id="insert" parameterType="com.ho.flow.vo.Event">
+        insert into event (
+            id,station_id,dept_id,group_id,
+            event_type,event_level,time_stamp,
+            target_device,device_type, device_type_id,`signal`,status,
+            `value`,`description`,confirm_status,
+            confirm_man,confirm_time,remark,
+            suggestion,category,type,sub_type,sens_type,is_recovery,before_event_id
+        ) values(
+            #{id},#{stationId},#{deptId},#{groupId},
+            #{eventType},#{eventLevel},#{timeStamp},
+            #{targetDevice},#{deviceType}, #{deviceTypeId},#{signal},#{status},
+            #{value},#{description},#{confirmStatus},
+            #{confirmMan},#{confirmTime},#{remark},
+            #{suggestion},#{category},#{type},#{subType},#{sensType},#{isRecovery},#{beforeEventId}
+        )
+    </insert>
+    <insert id="insertSelective" keyColumn="id" keyProperty="id" parameterType="com.ho.flow.vo.Event"
+            useGeneratedKeys="true">
+        insert into event
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+            <if test="id != null">id,</if>
+            <if test="deptId != null">dept_id,</if>
+            <if test="groupId != null">group_id,</if>
+            <if test="eventType != null">event_type,</if>
+            <if test="eventLevel!= null">event_level,</if>
+            <if test="timeStamp != null">time_stamp,</if>
+            <if test="targetDevice != null">target_device,</if>
+            <if test="deviceType != null">device_type,</if>
+            <if test="deviceTypeId != null">device_type_id,</if>
+            <if test="signal != null">signal,</if>
+            <if test="status != null">status,</if>
+            <if test="value != null">value,</if>
+            <if test="description != null">description,</if>
+            <if test="confirmStatus != null">confirm_status,</if>
+            <if test="confirmMan != null">confirm_man,</if>
+            <if test="confirmTime != null">confirm_time,</if>
+            <if test="remark != null">remark,</if>
+            <if test="suggestion != null">suggestion,</if>
+            <if test="createTime != null">create_time,</if>
+            <if test="updateTime != null">update_time,</if>
+            <if test="stationId != null">station_id,</if>
+            <if test="category != null">category,</if>
+            <if test="type != null">type,</if>
+            <if test="subType != null">sub_type,</if>
+            <if test="isRecovery != null">is_recovery,</if>
+            <if test="beforeEventId != null">before_event_id,</if>
+        </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+            <if test="id != null">#{id,jdbcType=BIGINT},</if>
+            <if test="deptId != null">#{deptId,jdbcType=BIGINT},</if>
+            <if test="groupId != null">#{groupId,jdbcType=BIGINT},</if>
+            <if test="eventType != null">#{eventType,jdbcType=TINYINT},</if>
+            <if test="eventLevel!= null">#{eventLevel,jdbcType=TINYINT},</if>
+            <if test="timeStamp != null">#{timeStamp,jdbcType=TIMESTAMP},</if>
+            <if test="targetDevice != null">#{targetDevice},</if>
+            <if test="deviceType != null">#{deviceType},</if>
+            <if test="deviceTypeId != null">#{deviceTypeId},</if>
+            <if test="signal != null">#{signal,jdbcType=VARCHAR},</if>
+            <if test="status != null">#{status,jdbcType=INTEGER},</if>
+            <if test="value != null">#{value,jdbcType=DECIMAL},</if>
+            <if test="description != null">#{description,jdbcType=VARCHAR},</if>
+            <if test="confirmStatus != null">#{confirmStatus,jdbcType=TINYINT},</if>
+            <if test="confirmMan != null">#{confirmMan,jdbcType=VARCHAR},</if>
+            <if test="confirmTime != null">#{confirmTime,jdbcType=TIMESTAMP},</if>
+            <if test="remark != null">#{remark,jdbcType=VARCHAR},</if>
+            <if test="suggestion != null">#{suggestion,jdbcType=VARCHAR},</if>
+            <if test="createTime != null">#{createTime,jdbcType=TIMESTAMP},</if>
+            <if test="updateTime != null">#{updateTime,jdbcType=TIMESTAMP},</if>
+            <if test="stationId != null">#{stationId,jdbcType=INTEGER},</if>
+            <if test="category != null">#{category,jdbcType=INTEGER},</if>
+            <if test="type != null">#{type,jdbcType=INTEGER},</if>
+            <if test="subType != null">#{subType,jdbcType=INTEGER},</if>
+            <if test="isRecovery != null">#{isRecovery},</if>
+            <if test="beforeEventId != null">#{beforeEventId},</if>
+        </trim>
+    </insert>
+
+    <insert id="insertBatch">
+        INSERT INTO event (
+        id,station_id,dept_id,group_id,
+        event_type,event_level,time_stamp,
+        target_device,device_type, device_type_id,`signal`,status,
+        `value`,`description`,confirm_status,
+        confirm_man,confirm_time,remark,
+        suggestion,category,type,sub_type,sens_type,is_recovery,before_event_id
+        )
+        VALUES
+        <foreach item="item" collection="list" index="index" separator=",">
+            (
+            #{item.id},#{item.stationId},#{item.deptId},#{item.groupId},
+            #{item.eventType},#{item.eventLevel},#{item.timeStamp},
+            #{item.targetDevice},#{item.deviceType}, #{item.deviceTypeId},#{item.signal},#{item.status},
+            #{item.value},#{item.description},#{item.confirmStatus},
+            #{item.confirmMan},#{item.confirmTime},#{item.remark},
+            #{item.suggestion},#{item.category},#{item.type},#{item.subType},#{item.sensType},#{item.isRecovery},#{item.beforeEventId}
+            )
+        </foreach>
+    </insert>
+    <update id="updateBatchById">
+        update `event`
+        <set>
+            <if test="event.timeStamp != null">
+                time_stamp = #{event.timeStamp,jdbcType=TIMESTAMP},
+            </if>
+            <if test="event.value != null">
+                `value` = #{event.value,jdbcType=DECIMAL},
+            </if>
+            <if test="event.description != null">
+                description = #{event.description,jdbcType=VARCHAR},
+            </if>
+            <if test="event.updateTime != null">
+                update_time = #{event.updateTime,jdbcType=TIMESTAMP},
+            </if>
+        </set>
+        WHERE id = #{event.id,jdbcType=BIGINT}
+    </update>
+    <update id="updateByPrimaryKey" parameterType="com.ho.flow.vo.Event">
+        update event
+        set dept_id     = #{deptId,jdbcType=INTEGER},
+            group_id    = #{groupId,jdbcType=INTEGER},
+            event_type  = #{eventType,jdbcType=TINYINT},
+            event_level = #{ eventLevel,jdbcType=TINYINT} time_stamp = #{timeStamp,jdbcType=TIMESTAMP},
+            target_device = #{targetDevice,jdbcType=INTEGER},
+            signal = #{signal,jdbcType=VARCHAR},
+            status = #{status,jdbcType=INTEGER},
+            value = #{value,jdbcType=DECIMAL},
+            description = #{description,jdbcType=VARCHAR},
+            confirm_status = #{confirmStatus,jdbcType=TINYINT},
+            confirm_man = #{confirmMan,jdbcType=VARCHAR},
+            confirm_time = #{confirmTime,jdbcType=TIMESTAMP},
+            remark = #{remark,jdbcType=VARCHAR},
+            suggestion = #{suggestion,jdbcType=VARCHAR},
+            create_time = #{createTime,jdbcType=TIMESTAMP},
+            update_time = #{updateTime,jdbcType=TIMESTAMP},
+            station_id = #{stationId,jdbcType=INTEGER},
+            category = #{category,jdbcType=INTEGER},
+            type = #{type,jdbcType=INTEGER},
+            sub_type = #{subType,jdbcType=INTEGER}
+        where id = #{id,jdbcType=BIGINT}
+    </update>
+    <update id="updateByPrimaryKeySelective">
+        update event
+        <set>
+            <if test="deptId != null">
+                dept_id = #{deptId,jdbcType=INTEGER},
+            </if>
+            <if test="groupId != null">
+                group_id = #{groupId,jdbcType=INTEGER},
+            </if>
+
+            <if test="eventType != null">
+                event_type = #{eventType,jdbcType=TINYINT},
+            </if>
+            <if test="eventLevel!= null">
+                event_level = #{eventLevel,jdbcType=TINYINT}
+            </if>
+            <if test="timeStamp != null">
+                time_stamp = #{timeStamp,jdbcType=TIMESTAMP},
+            </if>
+            <if test="targetDevice != null">
+                target_device = #{targetDevice,jdbcType=INTEGER},
+            </if>
+            <if test="signal != null">
+                signal = #{signal,jdbcType=VARCHAR},
+            </if>
+            <if test="status != null">
+                status = #{status,jdbcType=INTEGER},
+            </if>
+            <if test="value != null">
+                value = #{value,jdbcType=DECIMAL},
+            </if>
+            <if test="description != null">
+                description = #{description,jdbcType=VARCHAR},
+            </if>
+            <if test="confirmStatus != null">
+                confirm_status = #{confirmStatus,jdbcType=TINYINT},
+            </if>
+            <if test="confirmMan != null">
+                confirm_man = #{confirmMan,jdbcType=VARCHAR},
+            </if>
+            <if test="confirmTime != null">
+                confirm_time = #{confirmTime,jdbcType=TIMESTAMP},
+            </if>
+            <if test="remark != null">
+                remark = #{remark,jdbcType=VARCHAR},
+            </if>
+            <if test="suggestion != null">
+                suggestion = #{suggestion,jdbcType=VARCHAR},
+            </if>
+            <if test="createTime != null">
+                create_time = #{createTime,jdbcType=TIMESTAMP},
+            </if>
+            <if test="updateTime != null">
+                update_time = #{updateTime,jdbcType=TIMESTAMP},
+            </if>
+            <if test="stationId != null">
+                station_id = #{stationId,jdbcType=INTEGER},
+            </if>
+            <if test="category != null">
+                category = #{category,jdbcType=INTEGER},
+            </if>
+            <if test="type != null">
+                type = #{type,jdbcType=INTEGER},
+            </if>
+            <if test="subType != null">
+                sub_type = #{subType,jdbcType=INTEGER},
+            </if>
+        </set>
+        where id = #{id,jdbcType=BIGINT}
+    </update>
+
+    <update id="updateByIds">
+        update event
+        set
+        status = 1,
+        confirm_time = NOW(),
+        confirm_man=#{userDetail.username}
+        where id in
+        <if test="ids != null and ids.size() != 0">
+            <foreach collection="ids" open="(" close=")" separator="," item="item">
+                #{item}
+            </foreach>
+        </if>
+
+    </update>
+    <update id="updateConfirm">
+        update event
+        set
+        confirm_status = 1,
+        confirm_time = NOW(),
+        confirm_man = #{name,jdbcType=VARCHAR}
+        where id in
+        <if test="ids != null and ids.size() != 0">
+            <foreach collection="ids" open="(" close=")" separator="," item="item">
+                #{item}
+            </foreach>
+        </if>
+    </update>
+    <update id="setRemarkByIds">
+        update event
+        set
+        remark = "已转工单"
+        <where>
+            <if test="ids != null and ids.size() != 0">
+                and id in
+                <foreach collection="ids" open="(" close=")" separator="," item="item">
+                    #{item}
+                </foreach>
+            </if>
+        </where>
+    </update>
+    <!--    List<Event> selectByParams(@Param("stationId") Integer stationId,@Param("targetDevice") Integer targetDevice,@Param("signal") String signal,@Param("isRecovery") Integer isRecovery);-->
+    <select id="selectByParams" resultType="com.ho.flow.vo.Event">
+        SELECT
+        <include refid="Base_Column_List"/>
+        FROM `event`
+        <where>
+            <if test="stationId != null">
+                and station_id = #{stationId,jdbcType=INTEGER}
+            </if>
+            <if test="targetDevice != null">
+                and target_device = #{targetDevice,jdbcType=INTEGER}
+            </if>
+            <if test="signal != null">
+                and `signal` = #{signal,jdbcType=VARCHAR}
+            </if>
+            <if test="isRecovery != null">
+                and is_recovery = #{isRecovery,jdbcType=INTEGER}
+            </if>
+            order by time_stamp desc limit 1
+        </where>
+    </select>
+
+    <select id="selectByParam" resultType="com.ho.flow.vo.Event">
+        SELECT
+        <include refid="Base_Column_List"/>
+        FROM `event`
+        <where>
+            <if test="vo.stationId != null">
+                and station_id = #{vo.stationId,jdbcType=INTEGER}
+            </if>
+            <if test="vo.timeStamp != null">
+                and time_stamp &lt;= #{vo.timeStamp}
+            </if>
+            <if test="vo.targetDevice != null">
+                and target_device = #{vo.targetDevice,jdbcType=INTEGER}
+            </if>
+            <if test="vo.signal != null">
+                and `signal` = #{vo.signal,jdbcType=VARCHAR}
+            </if>
+            <if test="vo.isRecovery != null">
+                and is_recovery = #{vo.isRecovery,jdbcType=INTEGER}
+            </if>
+            <if test="vo.eventLevel != null">
+                and event_level = #{vo.eventLevel,jdbcType=INTEGER}
+            </if>
+            order by time_stamp desc limit 1
+        </where>
+    </select>
+
+    <select id="selectByTargetDevice" resultType="com.ho.flow.vo.Event">
+        SELECT
+        <include refid="Base_Column_List"/>
+        FROM `event`
+        <where>
+            <if test="alarmConfigQueryVo.groupId != null">
+                and group_id = #{alarmConfigQueryVo.groupId}
+            </if>
+            <if test="alarmConfigQueryVo.stationId != null">
+                and station_id = #{alarmConfigQueryVo.stationId}
+            </if>
+            <if test="alarmConfigQueryVo.deviceType != null">
+                and device_type = #{alarmConfigQueryVo.deviceType}
+            </if>
+            <if test="alarmConfigQueryVo.srcId != null">
+                and target_device = #{alarmConfigQueryVo.srcId}
+            </if>
+            <if test="alarmConfigQueryVo.startTime != null">
+                and time_stamp &gt;= #{alarmConfigQueryVo.startTime}
+            </if>
+            <if test="alarmConfigQueryVo.endTime != null">
+                and time_stamp &lt; #{alarmConfigQueryVo.endTime}
+            </if>
+            <if test="alarmConfigQueryVo.signal != null">
+                and `signal` = #{alarmConfigQueryVo.signal}
+            </if>
+            <if test="alarmConfigQueryVo.isRecovery != null">
+                and is_recovery = #{alarmConfigQueryVo.isRecovery}
+            </if>
+            <if test="alarmConfigQueryVo.eventLevelList != null and alarmConfigQueryVo.eventLevelList.size !=0 ">
+                and event_level in
+                <foreach collection="alarmConfigQueryVo.eventLevelList" open="(" close=")" separator="," item="item">
+                    #{item}
+                </foreach>
+            </if>
+        </where>
+        order by time_stamp desc
+    </select>
+
+    <select id="selectByTargetDeviceAsc" resultType="com.ho.flow.vo.Event">
+        SELECT
+        <include refid="Base_Column_List"/>
+        FROM `event`
+        <where>
+            <if test="alarmConfigQueryVo.groupId != null">
+                and group_id = #{alarmConfigQueryVo.groupId}
+            </if>
+            <if test="alarmConfigQueryVo.stationId != null">
+                and station_id = #{alarmConfigQueryVo.stationId}
+            </if>
+            <if test="alarmConfigQueryVo.deviceType != null">
+                and device_type = #{alarmConfigQueryVo.deviceType}
+            </if>
+            <if test="alarmConfigQueryVo.srcId != null">
+                and target_device = #{alarmConfigQueryVo.srcId}
+            </if>
+            <if test="alarmConfigQueryVo.eventLevelList != null and alarmConfigQueryVo.eventLevelList.size !=0 ">
+                and event_level in
+                <foreach collection="alarmConfigQueryVo.eventLevelList" open="(" close=")" separator="," item="item">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="alarmConfigQueryVo.startTime != null">
+                and time_stamp &gt;= #{alarmConfigQueryVo.startTime}
+            </if>
+            <if test="alarmConfigQueryVo.endTime != null">
+                and time_stamp &lt; #{alarmConfigQueryVo.endTime}
+            </if>
+            and `signal` != "polymerization"
+        </where>
+        order by time_stamp DESC
+    </select>
+
+    <select id="selectLastTime" resultType="com.ho.flow.vo.Event">
+        SELECT
+        <include refid="Base_Column_List"/>
+        FROM `event`
+        <where>
+            <if test="alarmConfigQueryVo.groupId != null">
+                and group_id = #{alarmConfigQueryVo.groupId}
+            </if>
+            <if test="alarmConfigQueryVo.stationId != null">
+                and station_id = #{alarmConfigQueryVo.stationId}
+            </if>
+            <if test="alarmConfigQueryVo.deviceType != null">
+                and device_type = #{alarmConfigQueryVo.deviceType}
+            </if>
+            <if test="alarmConfigQueryVo.srcId != null">
+                and target_device = #{alarmConfigQueryVo.srcId}
+            </if>
+            <if test="alarmConfigQueryVo.startTime != null">
+                and time_stamp &gt;= #{alarmConfigQueryVo.startTime}
+            </if>
+            <if test="alarmConfigQueryVo.endTime != null">
+                and time_stamp &lt; #{alarmConfigQueryVo.endTime}
+            </if>
+        </where>
+        order by time_stamp desc LIMIT 1
+    </select>
+
+    <select id="countEventByDay" resultType="com.ho.flow.vo.resp.event.EventDayNum">
+        SELECT DATE_FORMAT(time_stamp,'%Y-%m-%d') as day,COUNT(event_type) AS COUNT
+        FROM event
+        where event_type IS NOT NULL
+        <if test="record.startTime != null">
+            and time_stamp &gt;= #{record.startTime}
+        </if>
+        <if test="record.endTime != null">
+            and time_stamp &lt;= #{record.endTime}
+        </if>
+        <if test="record.stationIds != null and record.stationIds.size != 0">
+            and station_id in
+            <foreach collection="record.stationIds" open="(" close=")" separator="," item="item">
+                #{item}
+            </foreach>
+        </if>
+        <if test="record.userLevel != null and record.userLevel>0">
+            and (`signal` = 'polymerization' or device_type ='accesspoint')
+        </if>
+        <if test="record.userLevel == null or record.userLevel==0">
+            and `signal` != 'polymerization'
+        </if>
+        group by day
+    </select>
+
+    <delete id="deleteByParam" parameterType="java.lang.Long">
+        delete
+        FROM `event`
+        <where>
+            and status = 0
+            <if test="vo.stationId != null">
+                and station_id = #{vo.stationId,jdbcType=INTEGER}
+            </if>
+            <if test="vo.timeStamp != null">
+                and time_stamp &lt;= #{vo.timeStamp}
+            </if>
+            <if test="vo.targetDevice != null">
+                and target_device = #{vo.targetDevice,jdbcType=INTEGER}
+            </if>
+            <if test="vo.signal != null">
+                and `signal` = #{vo.signal,jdbcType=VARCHAR}
+            </if>
+            <if test="vo.isRecovery != null">
+                and is_recovery = #{vo.isRecovery,jdbcType=INTEGER}
+            </if>
+            <if test="vo.eventLevel != null">
+                and event_level = #{vo.eventLevel,jdbcType=INTEGER}
+            </if>
+            <if test="vo.excludeId != null">
+                and id != #{vo.excludeId}
+            </if>
+        </where>
+    </delete>
+
+    <select id="eventDeviceNum" resultType="java.lang.Integer">
+        SELECT count(0) faultDevice FROM event where status = 0 and station_id = #{vo.stationId} group by target_device
+    </select>
+</mapper>

flowable-center-dao/src/main/resources/mapper/OrderFormMapper.xml

@@ -0,0 +1,188 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.ho.flow.mapper.OrderFormMapper">
+
+    <resultMap type="com.ho.common.tools.entity.OrderForm" id="OrderForm">
+        <id property="id" column="id"/>
+        <result property="orderNum" column="order_num"/>
+        <result property="stationId" column="station_id"/>
+        <result property="userId" column="user_id"/>
+        <result property="eventId" column="event_id"/>
+        <result property="deviceId" column="device_id"/>
+        <result property="title" column="title"/>
+        <result property="remark" column="remark"/>
+        <result property="plannedTime" column="planned_time"/>
+        <result property="createTime" column="create_time"/>
+        <result property="priority" column="priority"/>
+        <result property="orderType" column="order_type"/>
+        <result property="status" column="status"/>
+        <result property="suggestion" column="suggestion"/>
+        <result property="processInstanceId" column="processInstance_id"/>
+        <result property="processInstanceKey" column="processInstance_key"/>
+        <collection property="orderFiles" javaType="java.util.List" resultMap="orderFile"/>
+    </resultMap>
+
+
+    <resultMap type="com.ho.common.tools.entity.file.OrderFile" id="orderFile">
+        <id property="url" column="url"/>
+        <result property="fileName" column="file_name"/>
+        <result property="orderFormId" column="order_form_id"/>
+        <result property="sort" column="sort"/>
+    </resultMap>
+
+    <insert id="insertOrderFormOne" useGeneratedKeys="true" keyProperty="id">
+        insert into order_form
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+            <if test="orderNum != null ">order_num,</if>
+            <if test="stationId != null ">station_id,</if>
+            <if test="userId != null ">user_id,</if>
+            <if test="eventId != null ">event_id,</if>
+            <if test="deviceId != null ">device_id,</if>
+            <if test="title != null ">title,</if>
+            <if test="remark != null ">remark,</if>
+            <if test="plannedTime != null ">planned_time,</if>
+            <if test="createTime != null ">create_time,</if>
+            <if test="priority != null ">priority,</if>
+            <if test="orderType != null ">order_type,</if>
+            <if test="processInstanceId != null ">processInstance_id,</if>
+            <if test="processInstanceKey != null ">processInstance_key,</if>
+        </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+            <if test="orderNum != null ">#{orderNum},</if>
+            <if test="stationId != null ">#{stationId},</if>
+            <if test="userId != null ">#{userId},</if>
+            <if test="eventId != null ">#{eventId},</if>
+            <if test="deviceId != null ">#{deviceId},</if>
+            <if test="title != null ">#{title},</if>
+            <if test="remark != null ">#{remark},</if>
+            <if test="plannedTime != null ">#{plannedTime},</if>
+            <if test="createTime != null ">#{createTime},</if>
+            <if test="priority != null ">#{priority},</if>
+            <if test="orderType != null ">#{orderType},</if>
+            <if test="processInstanceId != null ">#{processInstanceId},</if>
+            <if test="processInstanceKey != null ">#{processInstanceKey},</if>
+        </trim>
+    </insert>
+    <insert id="insertOrderFileOne">
+        insert into order_file
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+            <if test="url != null ">url,</if>
+            <if test="fileName != null ">file_name,</if>
+            <if test="orderFormId != null ">order_form_id,</if>
+            <if test="sort != null ">sort,</if>
+        </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+            <if test="url != null ">#{url},</if>
+            <if test="fileName != null ">#{fileName},</if>
+            <if test="orderFormId != null ">#{orderFormId},</if>
+            <if test="sort != null ">#{sort},</if>
+        </trim>
+    </insert>
+
+    <delete id="deleteFile">
+        delete
+        from order_file
+        where order_form_id = #{orderFormId}
+    </delete>
+    <update id="update">
+        update order_form
+        <set>
+            <if test="orderNum != null ">order_num = #{orderNum},</if>
+            <if test="stationId != null ">station_id = #{stationId},</if>
+            <if test="userId != null ">user_id = #{userId},</if>
+            <if test="eventId != null ">event_id = #{eventId},</if>
+            <if test="deviceId != null ">device_id = #{deviceId},</if>
+            <if test="title != null ">title = #{title},</if>
+            <if test="remark != null ">remark = #{remark},</if>
+            <if test="priority != null ">priority = #{priority},</if>
+            <if test="plannedTime != null ">planned_time = #{plannedTime},</if>
+            <if test="createTime != null ">create_time = #{createTime},</if>
+            <if test="orderType != null ">order_type = #{orderType},</if>
+            <if test="processInstanceId != null ">processInstance_id = #{processInstanceId},</if>
+            <if test="processInstanceKey != null ">processInstance_key = #{processInstanceKey},</if>
+        </set>
+        where id = #{id}
+    </update>
+    <update id="updateStatus">
+        update order_form
+        <set>
+            <if test="id != null">
+                status = 1,
+            </if>
+            <if test="suggestion != null and suggestion != ''">
+                suggestion = #{suggestion},
+            </if>
+        </set>
+        where id = #{id}
+    </update>
+
+
+    <select id="selectByProcessInstanceId" resultMap="OrderForm">
+        select form.*,file.url url ,file.file_name file_name,file.order_form_id order_form_id,file.sort sort
+        from order_form form
+        left join order_file file on form.id = file.order_form_id
+        <where>
+            <if test="processInstanceId != null and processInstanceId != ''">
+                form.processInstance_id = #{processInstanceId}
+            </if>
+        </where>
+    </select>
+    <select id="selectByUserId" resultMap="OrderForm">
+        select form.*,file.url url ,file.file_name file_name,file.order_form_id order_form_id,file.sort sort
+        from order_form form
+        left join order_file file on form.id = file.order_form_id
+        <where>
+            <if test="userId != null and userId != ''">
+               and form.user_id = #{userId}
+            </if>
+            <if test="userId != null and userId != ''">
+                and form.status = 0
+            </if>
+        </where>
+        limit 1
+    </select>
+
+    <select id="selectByOrderId" resultMap="OrderForm">
+        select form.*,file.url url ,file.file_name file_name,file.order_form_id order_form_id,file.sort sort
+        from order_form form
+        left join order_file file on form.id = file.order_form_id
+        where form.id = #{orderFormId}
+    </select>
+
+    <select id="selectFinishByUserId" resultMap="OrderForm">
+        select form.*,file.url url ,file.file_name file_name,file.order_form_id order_form_id,file.sort sort
+        from order_form form
+        left join order_file file on form.id = file.order_form_id
+        <where>
+            <if test="userId != null and userId != ''">
+                and form.user_id = #{userId}
+            </if>
+            <if test="userId != null and userId != ''">
+                and form.status = 1
+            </if>
+        </where>
+    </select>
+
+    <select id="getInspectionOrders" resultType="com.ho.common.tools.entity.OrderForm">
+        select  form.* from order_form form where id in (
+        select distinct a.order_id from business_db.inspection_fault a , business_db.inspection_report  b
+        where a.report_id = b.id and a.order_id is not null and b.station_id =#{stationId})
+    </select>
+
+    <select id="selectOrderFormList" resultType="com.ho.common.tools.entity.OrderForm">
+        select form.*,file.url url ,file.file_name file_name,file.order_form_id order_form_id,file.sort sort
+        from order_form form
+        left join order_file file on form.id = file.order_form_id
+        <where>
+            <if test="userId != null and userId != ''">
+                and form.user_id = #{userId}
+            </if>
+            <if test="userId != null and userId != ''">
+                and form.status = 0
+            </if>
+        </where>
+    </select>
+
+</mapper>

flowable-center-dao/src/main/resources/mapper/ProcessManagementMapper.xml

@@ -0,0 +1,91 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.ho.flow.mapper.ProcessManagementMapper">
+
+    <resultMap id="BaseResultMap" type="com.ho.flow.entity.ProcessTemplate">
+        <id property="id" column="id" jdbcType="INTEGER"/>
+        <result property="serialNum" column="serial_num" jdbcType="BIGINT"/>
+        <result property="name" column="name" jdbcType="VARCHAR"/>
+        <result property="type" column="type" jdbcType="INTEGER"/>
+        <result property="remark" column="remark" jdbcType="VARCHAR"/>
+        <result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
+        <result property="status" column="status" jdbcType="TINYINT"/>
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        id
+        ,serial_num,name,
+        type,remark,create_time,
+        status
+    </sql>
+    <insert id="insert" keyColumn="id" keyProperty="id" parameterType="com.ho.flow.entity.ProcessTemplate"
+            useGeneratedKeys="true">
+        insert into process_management
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+            <if test="serialNum != null">serial_num,</if>
+            <if test="name != null and name != ''">name,</if>
+            <if test="type != null">type,</if>
+            <if test="remark != null and remark != ''">remark,</if>
+            <if test="createTime != null">create_time,</if>
+            <if test="status != null ">status,</if>
+            <if test="processBpmn != null ">process_bpmn,</if>
+        </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+            <if test="serialNum != null">#{serialNum},</if>
+            <if test="name != null and name != ''">#{name},</if>
+            <if test="type != null">#{type},</if>
+            <if test="remark != null and remark != ''">#{remark},</if>
+            <if test="createTime != null">#{createTime},</if>
+            <if test="status != null ">#{status},</if>
+            <if test="processBpmn != null ">#{processBpmn},</if>
+        </trim>
+    </insert>
+    <update id="update">
+        update process_management
+        <set>
+            <if test="serialNum != null ">serial_num =  #{serialNum},</if>
+            <if test="name != null and name != ''">name = #{name},</if>
+            <if test="type != null">type = #{type},</if>
+            <if test="remark != null and remark != ''">remark = #{remark},</if>
+            <if test="createTime != null">create_time = #{createTime},</if>
+            <if test="status != null ">status = #{status},</if>
+            <if test="processBpmn != null ">process_bpmn = #{processBpmn},</if>
+        </set>
+        where id = #{id}
+    </update>
+
+    <delete id="delete">
+        delete
+        from process_management
+        where id = #{id,jdbcType=INTEGER}
+    </delete>
+
+    <select id="selectList" resultType="com.ho.flow.entity.ProcessTemplate">
+        select
+        <include refid="Base_Column_List"/>
+        from process_management
+        <where>
+            <if test="serialNum != null">and serial_num =  LIKE CONCAT('%',#{serialNum},'%'),</if>
+            <if test="name != null and name != ''">and name = LIKE CONCAT('%',#{name},'%'),</if>
+            <if test="type != null">and type = #{type},</if>
+            <if test="remark != null and remark != ''">and remark = #{remark},</if>
+            <if test="createTime != null">and create_time = #{createTime},</if>
+            <if test="status != null ">and status = #{status},</if>
+        </where>
+    </select>
+
+    <select id="selectById" resultType="com.ho.flow.entity.ProcessTemplate">
+        select
+        <include refid="Base_Column_List"/>
+        from process_management
+        where id = #{id}
+    </select>
+    <select id="selectBpmnById" resultType="java.lang.String">
+        select
+        process_bpmn
+        from process_management
+        where id = #{id}
+    </select>
+</mapper>

flowable-center-dao/src/main/resources/mapper/ProcessTemplateMapper.xml

@@ -0,0 +1,91 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.ho.flow.mapper.ProcessTemplateMapper">
+
+    <resultMap id="BaseResultMap" type="com.ho.flow.entity.ProcessTemplate">
+        <id property="id" column="id" jdbcType="INTEGER"/>
+        <result property="serialNum" column="serial_num" jdbcType="VARCHAR"/>
+        <result property="name" column="name" jdbcType="VARCHAR"/>
+        <result property="type" column="type" jdbcType="INTEGER"/>
+        <result property="remark" column="remark" jdbcType="VARCHAR"/>
+        <result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
+        <result property="status" column="status" jdbcType="TINYINT"/>
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        id
+        ,serial_num,name,
+        type,remark,create_time,
+        status
+    </sql>
+    <insert id="insert" keyColumn="id" keyProperty="id" parameterType="com.ho.flow.entity.ProcessTemplate"
+            useGeneratedKeys="true">
+        insert into process_template
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+            <if test="serialNum != null and serialNum != ''">serial_num,</if>
+            <if test="name != null and name != ''">name,</if>
+            <if test="type != null">type,</if>
+            <if test="remark != null and remark != ''">remark,</if>
+            <if test="createTime != null">create_time,</if>
+            <if test="status != null ">status,</if>
+            <if test="processBpmn != null ">process_bpmn,</if>
+        </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+            <if test="serialNum != null and serialNum != ''">#{serialNum},</if>
+            <if test="name != null and name != ''">#{name},</if>
+            <if test="type != null">#{type},</if>
+            <if test="remark != null and remark != ''">#{remark},</if>
+            <if test="createTime != null">#{createTime},</if>
+            <if test="status != null ">#{status},</if>
+            <if test="processBpmn != null ">#{processBpmn},</if>
+        </trim>
+    </insert>
+    <update id="update">
+        update process_template
+        <set>
+            <if test="serialNum != null and serialNum != ''">serial_num =  #{serialNum},</if>
+            <if test="name != null and name != ''">name = #{name},</if>
+            <if test="type != null">type = #{type},</if>
+            <if test="remark != null and remark != ''">remark = #{remark},</if>
+            <if test="createTime != null">create_time = #{createTime},</if>
+            <if test="status != null ">status = #{status},</if>
+            <if test="processBpmn != null ">process_bpmn = #{processBpmn},</if>
+        </set>
+        where id = #{id}
+    </update>
+
+    <delete id="delete">
+        delete
+        from process_template
+        where id = #{id,jdbcType=INTEGER}
+    </delete>
+
+    <select id="selectList" resultType="com.ho.flow.entity.ProcessTemplate">
+        select
+        <include refid="Base_Column_List"/>
+        from process_template
+        <where>
+            <if test="serialNum != null">and serial_num LIKE concat('%',#{serialNum},'%')</if>
+            <if test="name != null and name != ''">and `name`  LIKE concat('%',#{name},'%')</if>
+            <if test="type != null">and type = #{type}</if>
+            <if test="remark != null and remark != ''">and remark = #{remark}</if>
+            <if test="createTime != null">and create_time = #{createTime}</if>
+            <if test="status != null ">and status = #{status}</if>
+        </where>
+    </select>
+
+    <select id="selectById" resultType="com.ho.flow.entity.ProcessTemplate">
+        select
+        <include refid="Base_Column_List"/>
+        from process_template
+        where id = #{id}
+    </select>
+    <select id="selectBpmnById" resultType="java.lang.String">
+        select
+        process_bpmn
+        from process_template
+        where id = #{id}
+    </select>
+</mapper>

flowable-center-dao/src/main/resources/mapper/SendSmsConfigMapper.xml

@@ -0,0 +1,124 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.ho.flow.mapper.SendSmsConfigMapper">
+
+    <sql id="Base_Column_List">
+        id
+        ,station_id,user_id,username,phone,real_name,dept_name,email,
+        sms_type,alarm_level,create_id,update_id,create_time,update_time,is_send_now,delay_data
+    </sql>
+
+    <sql id="Insert_Batch_Column_List">
+        station_id
+        ,user_id,username,phone,real_name,dept_name,email,
+        sms_type,alarm_level,create_id,create_time,is_send_now,delay_data
+    </sql>
+
+    <select id="selectList" resultType="com.ho.flow.vo.resp.SendSmsConfig.SendSmsConfigRsp">
+        select
+        <include refid="Base_Column_List"/>
+        from send_sms_config
+        <where>
+            <if test="vo.stationId != null">
+                and station_id = #{vo.stationId}
+            </if>
+            <if test="vo.isSendNow != null">
+                and is_send_now = #{vo.isSendNow}
+            </if>
+            <if test="vo.username != null">
+                and username like concat('%',#{vo.username},'%')
+            </if>
+            <if test="vo.phone != null">
+                and phone like concat('%',#{vo.phone},'%')
+            </if>
+            <if test="vo.smsType != null">
+                and sms_type like concat('%',#{vo.smsType},'%')
+            </if>
+            <if test="vo.alarmLevel != null">
+                and alarm_level like concat('%',#{vo.alarmLevel},'%')
+            </if>
+            <if test="vo.userIds != null and vo.userIds.size > 0">
+                and user_id in
+                <foreach collection="vo.userIds" item="item" open="(" close=")" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+        </where>
+        order by create_time desc
+    </select>
+
+    <insert id="insertList">
+        insert into send_sms_config (<include refid="Insert_Batch_Column_List"/>)
+        values
+        <foreach item="item" collection="list" index="index" separator=",">
+            (
+            #{item.stationId},#{item.userId},#{item.username},#{item.phone},#{item.realName},
+            #{item.deptName},#{item.email},#{item.smsType},#{item.alarmLevel},#{item.createId},now(),#{item.isSendNow},#{item.delayData}
+            )
+        </foreach>
+    </insert>
+
+    <update id="updateById">
+        update send_sms_config
+        <set>
+            <if test="vo.smsType != null">
+                sms_type = #{vo.smsType},
+            </if>
+            <if test="vo.alarmLevel != null">
+                alarm_level = #{vo.alarmLevel},
+            </if>
+            <if test="vo.updateId != null">
+                update_id = #{vo.updateId},
+            </if>
+            <if test="vo.updateTime != null">
+                update_time = #{vo.updateTime},
+            </if>
+            <if test="vo.isSendNow != null">
+                is_send_now = #{vo.isSendNow},
+            </if>
+            <if test="vo.delayData != null">
+                delay_data = #{vo.delayData},
+            </if>
+        </set>
+        where id = #{vo.id}
+    </update>
+
+    <update id="updateByUserId">
+        update send_sms_config
+        <set>
+            <if test="vo.username != null">
+                username = #{vo.username},
+            </if>
+            <if test="vo.phone != null">
+                phone = #{vo.phone},
+            </if>
+            <if test="vo.realName != null">
+                real_name = #{vo.realName},
+            </if>
+            <if test="vo.deptName != null">
+                dept_name = #{vo.deptName},
+            </if>
+            <if test="vo.email != null">
+                email = #{vo.email},
+            </if>
+            <if test="vo.updateTime != null">
+                update_time = #{vo.updateTime},
+            </if>
+        </set>
+        where user_id = #{vo.userId}
+    </update>
+
+    <delete id="deleteBatch">
+        delete
+        from send_sms_config
+        <where>
+            and id in
+            <foreach collection="ids" open="(" close=")" separator="," item="item">
+                #{item}
+            </foreach>
+        </where>
+    </delete>
+
+</mapper>

flowable-center-dao/src/main/resources/mapper/WorkOrderCirculationMapper.xml

@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.ho.flow.mapper.WorkOrderCirculationMapper">
+
+
+    <sql id="Base_Column_List">
+        id
+        ,order_id,from_id,
+        to_id,create_time,work_order_action,`desc`
+    </sql>
+
+    <select id="selectByPrimaryKey" parameterType="java.lang.Long"
+            resultType="com.ho.flow.vo.WorkOrderCirculation">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order_circulation
+        where id = #{id,jdbcType=BIGINT}
+    </select>
+    <select id="selectByOrderId" resultType="com.ho.flow.vo.resp.workorder.WorkOrderCirculationRespVO">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order_circulation
+        where order_id LIKE concat('%',#{orderId},'%')
+    </select>
+
+    <insert id="insert" keyColumn="id" keyProperty="id" parameterType="com.ho.flow.vo.WorkOrderCirculation"
+            useGeneratedKeys="true">
+        insert into work_order_circulation
+        (id, order_id, from_id,
+         to_id, `desc`, work_order_action)
+        values ( #{id,jdbcType=BIGINT}, #{orderId,jdbcType=VARCHAR}, #{fromId,jdbcType=VARCHAR}
+               , #{toId,jdbcType=VARCHAR}, #{desc,jdbcType=VARCHAR}
+               , #{workOrderAction,jdbcType=INTEGER})
+    </insert>
+    <insert id="insertSelective" keyColumn="id" keyProperty="id"
+            parameterType="com.ho.flow.vo.WorkOrderCirculation" useGeneratedKeys="true">
+        insert into work_order_circulation
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+            <if test="id != null">id,</if>
+            <if test="orderId != null">order_id,</if>
+            <if test="fromId != null">from_id,</if>
+            <if test="toId != null">to_id,</if>
+            <if test="createTime != null">create_time,</if>
+            <if test="desc != null">`desc`,</if>
+            <if test="workOrderAction">work_order_action,</if>
+        </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+            <if test="id != null">#{id,jdbcType=BIGINT},</if>
+            <if test="orderId != null">#{orderId,jdbcType=VARCHAR},</if>
+            <if test="fromId != null">#{fromId,jdbcType=INTEGER},</if>
+            <if test="toId != null">#{toId,jdbcType=VARCHAR},</if>
+            <if test="createTime != null">#{createTime,jdbcType=TIMESTAMP},</if>
+            <if test="desc != null">#{desc,jdbcType=VARCHAR},</if>
+            <if test="workOrderAction">#{workOrderAction,jdbcType=INTEGER}</if>
+        </trim>
+    </insert>
+
+    <insert id="insertBatch">
+        insert into work_order_circulation
+        ( id,order_id, from_id,
+        to_id, `desc`, work_order_action)
+        values
+        <foreach item="item" collection="list" index="index" separator=",">
+         (
+            #{item.id},#{item.orderId},
+            #{item.fromId},#{item.toId},#{item.desc},
+            #{item.workOrderAction}
+            )
+        </foreach>
+    </insert>
+</mapper>

flowable-center-dao/src/main/resources/mapper/WorkOrderHisMapper.xml

@@ -0,0 +1,321 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.ho.flow.mapper.WorkOrderHisMapper">
+
+
+    <sql id="Base_Column_List">
+        `id`
+        , `order_id`, `group_id`, `dept_id`, `station_id`,
+        `from_id`, `phone`, `to_id`, `event_id`, `event_level`, `desc`, `create_time`,
+        `receive_time`, `complete_time`, `work_order_status`, `work_order_type`
+    </sql>
+
+    <select id="selectByPrimaryKey" parameterType="java.lang.Long" resultType="com.ho.flow.vo.WorkOrderOld">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order
+        where id = #{id,jdbcType=BIGINT}
+    </select>
+
+    <select id="selectByOrderId" resultType="com.ho.flow.vo.WorkOrderOld">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order
+        where order_id = #{orderId}
+    </select>
+
+    <select id="selectByStatus" resultType="com.ho.flow.vo.WorkOrderOld">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order
+        where order_id = #{orderId}
+    </select>
+
+    <select id="selectByPageInfo" resultType="com.ho.flow.vo.resp.workorder.WorkOrderOldPageRespVO">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order
+        <where>
+            and work_order_status != 4
+            <if test="orderId != null and orderId != ''">
+                and order_id LIKE concat('%',#{orderId},'%')
+            </if>
+            <if test="groupId != null">
+                and group_id = #{groupId}
+            </if>
+            <if test="stationId != null">
+                and station_id = #{stationId}
+            </if>
+            <if test="stationIds != null and stationIds.size() !=0">
+                and station_id in
+                <foreach collection="stationIds" item="item" open="(" close=")" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="orderIds != null and orderIds.size() !=0">
+                and order_id in
+                <foreach collection="orderIds" item="item" open="(" close=")" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="eventLevel != null">
+                and event_level = #{eventLevel}
+            </if>
+            <if test="workOrderStatus != null">
+                and work_order_status = #{workOrderStatus}
+            </if>
+            <if test="workOrderType != null">
+                and work_order_type = #{workOrderType}
+            </if>
+            <if test="beginTime != null and endTime != null">
+                and create_time between #{beginTime} and #{endTime}
+            </if>
+            <if test="toIds != null and toIds.size() != 0">
+                and to_id in
+                <foreach collection="toIds" open="(" close=")" separator="," item="item">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="roleLeader != null and roleLeader != ''">
+                and (to_id = #{toId}
+                or from_id = #{fromId})
+            </if>
+            <if test="roleWorker != null and roleWorker != ''">
+                and (to_id = #{toId}
+                or from_id = #{fromId})
+            </if>
+            <if test="roleOther != null and roleOther != ''">
+                and (to_id = #{toId}
+                or from_id = #{fromId})
+            </if>
+
+            order by create_time desc,receive_time desc
+        </where>
+    </select>
+
+    <select id="selectByHisPageInfo" resultType="com.ho.flow.vo.resp.workorder.WorkOrderOldPageRespVO">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order
+        <where>
+            work_order_status = 4
+            <if test="orderId != null and orderId != ''">
+                and order_id LIKE concat('%',#{orderId},'%')
+            </if>
+            <if test="stationId != null">
+                and station_id = #{stationId}
+            </if>
+            <if test="stationIds != null and stationIds.size() !=0">
+                and station_id in
+                <foreach collection="stationIds" item="item" open="(" close=")" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="eventLevel != null">
+                and event_level = #{eventLevel}
+            </if>
+            <if test="workOrderStatus != null">
+                and work_order_status = #{workOrderStatus}
+            </if>
+            <if test="workOrderType != null">
+                and work_order_type = #{workOrderType}
+            </if>
+            <if test="beginTime != null and endTime != null">
+                and create_time between #{beginTime} and #{endTime}
+            </if>
+            order by create_time desc,receive_time desc
+        </where>
+    </select>
+
+    <select id="selectByEventId" resultType="com.ho.flow.vo.WorkOrderOld">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order
+        where event_id = #{eventId,jdbcType=BIGINT}
+    </select>
+    <select id="selectByEventIds" resultType="com.ho.flow.vo.WorkOrderOld">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order
+        where event_id in
+        <foreach collection="eventIds" item="eventId" open="(" separator="," close=")">
+            #{eventId}
+        </foreach>
+    </select>
+
+    <select id="selectByOrderIds" resultType="com.ho.flow.vo.resp.workorder.WorkOrderOldPageRespVO">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order
+        where order_id in
+        <foreach collection="orderIds" item="item" open="(" separator="," close=")">
+            #{item}
+        </foreach>
+    </select>
+
+
+    <delete id="deleteByPrimaryKey">
+        Delete
+        from work_order
+        where order_id in
+        <foreach collection="orderIds" item="orderId" open="(" separator="," close=")">
+            #{orderId}
+        </foreach>
+    </delete>
+
+    <delete id="delete">
+        Delete
+        from work_order
+        where order_id = #{orderId}
+    </delete>
+
+    <insert id="insertSelective" keyColumn="id" keyProperty="id" parameterType="com.ho.flow.vo.WorkOrderOld"
+            useGeneratedKeys="true">
+        insert into work_order
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+            <if test="id != null">id,</if>
+            <if test="orderId != null">order_id,</if>
+            <if test="groupId != null">group_id,</if>
+            <if test="deptId != null">dept_id,</if>
+            <if test="stationId != null">station_id,</if>
+            <if test="fromId != null">from_id,</if>
+            <if test="phone != null">phone,</if>
+            <if test="toId != null">to_id,</if>
+            <if test="eventId != null">event_id,</if>
+            <if test="eventLevel != null">event_level,</if>
+            <if test="desc != null">`desc`,</if>
+            <if test="createTime != null">create_time,</if>
+            <if test="receiveTime != null">receive_time,</if>
+            <if test="completeTime != null">complete_time,</if>
+            <if test="workOrderStatus != null">work_order_status,</if>
+            <if test="workOrderType != null">work_order_type</if>
+        </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+            <if test="id != null">#{id,jdbcType=BIGINT},</if>
+            <if test="orderId != null">#{orderId,jdbcType=VARCHAR},</if>
+            <if test="groupId != null">#{groupId,jdbcType=INTEGER},</if>
+            <if test="deptId != null">#{deptId,jdbcType=INTEGER},</if>
+            <if test="stationId != null">#{stationId,jdbcType=INTEGER},</if>
+            <if test="fromId != null">#{fromId,jdbcType=VARCHAR},</if>
+            <if test="phone != null">#{phone,jdbcType=VARCHAR},</if>
+            <if test="toId != null">#{toId,jdbcType=VARCHAR},</if>
+            <if test="eventId != null">#{eventId,jdbcType=BIGINT},</if>
+            <if test="eventLevel != null">#{eventLevel,jdbcType=INTEGER},</if>
+            <if test="desc != null">#{desc,jdbcType=VARCHAR},</if>
+            <if test="createTime != null">#{createTime,jdbcType=TIMESTAMP},</if>
+            <if test="receiveTime != null">#{receiveTime,jdbcType=TIMESTAMP},</if>
+            <if test="completeTime != null">#{completeTime,jdbcType=TIMESTAMP},</if>
+            <if test="workOrderStatus != null">#{workOrderStatus,jdbcType=INTEGER},</if>
+            <if test="workOrderType != null">#{workOrderType,jdbcType=INTEGER},</if>
+        </trim>
+    </insert>
+
+    <insert id="insertBatch">
+        insert into work_order
+        ( id,order_id, group_id,
+        dept_id, station_id, from_id,
+        phone, to_id, event_id, event_level,
+        `desc`, receive_time, complete_time,
+        work_order_status, work_order_type)
+        values
+        <foreach item="item" collection="list" index="index" separator=",">
+            (
+            #{item.id},
+            #{item.orderId},#{item.stationId},#{item.deptId},#{item.groupId},
+            #{item.fromId},#{item.phone},#{item.toId},
+            #{item.eventId},#{item.eventLevel},#{item.desc},
+            #{item.receiveTime},#{item.completeTime},
+            #{item.workOrderStatus},#{item.workOrderType}
+            )
+        </foreach>
+    </insert>
+
+    <update id="updateReturnWorkOrder">
+        update work_order
+        <set>
+            <if test="workOrderStatus != null">
+                work_order_status = #{workOrderStatus,jdbcType=INTEGER},
+            </if>
+            <if test="phone != null">
+                phone = null,
+            </if>
+            <if test="toId != null">
+                to_id = null,
+            </if>
+            <if test="receiveTime != null">
+                receive_time = null,
+            </if>
+        </set>
+        where order_id = #{orderId}
+    </update>
+
+    <update id="updateByPrimaryKeySelective">
+        update work_order
+        <set>
+            <if test="groupId != null">
+                group_id = #{groupId,jdbcType=INTEGER},
+            </if>
+            <if test="deptId != null">
+                dept_id = #{deptId,jdbcType=INTEGER},
+            </if>
+            <if test="stationId != null">
+                station_id = #{stationId,jdbcType=INTEGER},
+            </if>
+            <if test="fromId != null">
+                from_id = #{fromId,jdbcType=VARCHAR},
+            </if>
+            <if test="phone != null">
+                phone = #{phone,jdbcType=VARCHAR},
+            </if>
+            <if test="toId != null">
+                to_id = #{toId,jdbcType=VARCHAR},
+            </if>
+            <if test="eventId != null">
+                event_id = #{eventId,jdbcType=BIGINT},
+            </if>
+            <if test="eventLevel != null">
+                event_level = #{eventLevel,jdbcType=INTEGER},
+            </if>
+            <if test="desc != null">
+                `desc` = #{desc,jdbcType=VARCHAR},
+            </if>
+            <if test="createTime != null">
+                create_time = #{createTime,jdbcType=TIMESTAMP},
+            </if>
+            <if test="receiveTime != null">
+                receive_time = #{receiveTime,jdbcType=TIMESTAMP},
+            </if>
+            <if test="completeTime != null">
+                complete_time = #{completeTime,jdbcType=TIMESTAMP},
+            </if>
+            <if test="workOrderStatus != null">
+                work_order_status = #{workOrderStatus,jdbcType=INTEGER},
+            </if>
+            <if test="workOrderType != null">
+                work_order_type = #{workOrderType,jdbcType=INTEGER}
+            </if>
+        </set>
+        where order_id = #{orderId}
+    </update>
+
+    <update id="updateByPrimaryKey" parameterType="com.ho.flow.vo.WorkOrderOld">
+        update work_order
+        set group_id          = #{groupId,jdbcType=INTEGER},
+            dept_id           = #{deptId,jdbcType=INTEGER},
+            station_id        = #{stationId,jdbcType=INTEGER},
+            from_id           = #{fromId,jdbcType=VARCHAR},
+            phone             = #{phone,jdbcType=VARCHAR},
+            to_id             = #{toId,jdbcType=VARCHAR},
+            event_id          = #{eventId,jdbcType=BIGINT},
+            event_level       = #{eventLevel,jdbcType=INTEGER},
+            `desc`            = #{desc,jdbcType=VARCHAR},
+            create_time       = #{createTime,jdbcType=TIMESTAMP},
+            receive_time      = #{receiveTime,jdbcType=TIMESTAMP},
+            complete_time     = #{completeTime,jdbcType=TIMESTAMP},
+            work_order_status = #{workOrderStatus,jdbcType=INTEGER},
+            work_order_order  = #{workOrderType,jdbcType=INTEGER}
+        where order_id = #{orderId,jdbcType=VARCHAR}
+    </update>
+</mapper>

flowable-center-dao/src/main/resources/mapper/WorkOrderMapper.xml

@@ -0,0 +1,240 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.ho.flow.mapper.WorkOrderMapper">
+
+
+    <sql id="Base_Column_List">
+        id
+        ,plan_title,title,
+        planned_time,create_time,update_time,
+        priority,phone,device_id,
+        station_id,user_id,`desc`,order_id,
+        process_id,group_id,event_id,order_type,deleted
+    </sql>
+
+    <select id="selectByPrimaryKey" resultType="com.ho.flow.entity.WorkOrder">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order
+        where id = #{id}
+    </select>
+
+    <select id="selectByOrderId" resultType="com.ho.flow.vo.resp.workorder.WorkOrderRespVO">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order
+        where order_id = #{orderId}
+    </select>
+
+    <select id="selectByOrderIdAndTitle" resultType="com.ho.flow.vo.resp.workorder.WorkOrderRespVO">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order
+        where order_id = #{orderId}
+        <if test="title != null and title != ''">
+            and title LIKE CONCAT('%',#{title},'%')
+        </if>
+    </select>
+
+    <select id="selectByProcessInstId" resultType="com.ho.flow.vo.resp.workorder.WorkOrderRespVO">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order
+        where process_id = #{processInstId}
+    </select>
+
+    <select id="selectByProcessInstIdAndTitle" resultType="com.ho.flow.vo.resp.workorder.WorkOrderRespVO">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order
+        where process_id = #{processInstanceId}
+        <if test="title != null and title != ''">
+            and title LIKE CONCAT('%',#{title},'%')
+        </if>
+    </select>
+
+    <select id="selectByInfo" resultType="com.ho.flow.vo.resp.workorder.WorkOrderRespVO">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order
+        <where>
+            <if test="stationId !=null">
+                and station_id = #{stationId}
+            </if>
+            <if test="processId !=null and processId != ''">
+                and process_id = #{processId}
+            </if>
+            <if test="orderType !=null ">
+                and order_type = #{orderType}
+            </if>
+            <if test="orderId !=null and orderId != ''">
+                and order_id LIKE CONCAT('%',#{orderId},'%')
+            </if>
+
+            <if test="orderIds != null and orderIds.size() !=0">
+                and order_id in
+                <foreach collection="orderIds" item="item" open="(" close=")" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+        </where>
+    </select>
+    <select id="selectByStationId" resultType="java.lang.Integer">
+        select count(1)
+        from work_order
+        where station_id = #{stationId}
+          and deleted = 1
+    </select>
+
+
+    <delete id="deleteByPrimaryKey">
+        delete
+        from work_order
+        where id = #{id,jdbcType=INTEGER}
+    </delete>
+
+    <delete id="deleteByIds">
+        delete
+        from work_order
+        where id in
+        <foreach collection="ids" item="item" open="(" close=")" separator=",">
+            #{item}
+        </foreach>
+    </delete>
+    <insert id="insert" keyColumn="id" keyProperty="id" parameterType="com.ho.flow.entity.WorkOrder"
+            useGeneratedKeys="true">
+        insert into work_order
+        ( id, plan_title, title
+        , planned_time, create_time, update_time
+        , priority, phone, device_id
+        , station_id, `desc`, order_id
+        , process_id, group_id, event_id, order_type)
+        values ( #{id}, #{planTitle,jdbcType=VARCHAR}, #{title,jdbcType=VARCHAR}
+               , #{plannedTime,jdbcType=TIMESTAMP}, #{createTime,jdbcType=TIMESTAMP}, #{updateTime,jdbcType=TIMESTAMP}
+               , #{priority,jdbcType=INTEGER}, #{phone}, #{deviceId,jdbcType=INTEGER}
+               , #{stationId,jdbcType=INTEGER}, #{desc,jdbcType=VARCHAR}, #{orderId,jdbcType=VARCHAR}
+               , #{processId,jdbcType=VARCHAR}, #{groupId,jdbcType=INTEGER}, #{eventId}, #{orderType,jdbcType=INTEGER})
+    </insert>
+    <insert id="insertSelective" parameterType="com.ho.flow.entity.WorkOrder">
+        insert into work_order
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+            <if test="id != null">id,</if>
+            <if test="planTitle != null">plan_title,</if>
+            <if test="title != null">title,</if>
+            <if test="plannedTime != null">planned_time,</if>
+            <if test="createTime != null">create_time,</if>
+            <if test="updateTime != null">update_time,</if>
+            <if test="priority != null">priority,</if>
+            <if test="phone != null">phone,</if>
+            <if test="deviceId != null">device_id,</if>
+            <if test="stationId != null">station_id,</if>
+            <if test="userId != null">user_id,</if>
+            <if test="desc != null">`desc`,</if>
+            <if test="orderId != null">order_id,</if>
+            <if test="processId != null">process_id,</if>
+            <if test="groupId != null">group_id,</if>
+            <if test="eventId != null">event_id,</if>
+            <if test="orderType != null">order_type,</if>
+            <if test="deleted != null">deleted,</if>
+        </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+            <if test="id != null">#{id},</if>
+            <if test="planTitle != null">#{planTitle,jdbcType=VARCHAR},</if>
+            <if test="title != null">#{title,jdbcType=VARCHAR},</if>
+            <if test="plannedTime != null">#{plannedTime,jdbcType=TIMESTAMP},</if>
+            <if test="createTime != null">#{createTime,jdbcType=TIMESTAMP},</if>
+            <if test="updateTime != null">#{updateTime,jdbcType=TIMESTAMP},</if>
+            <if test="priority != null">#{priority,jdbcType=INTEGER},</if>
+            <if test="phone != null">#{phone},</if>
+            <if test="deviceId != null">#{deviceId,jdbcType=INTEGER},</if>
+            <if test="stationId != null">#{stationId,jdbcType=INTEGER},</if>
+            <if test="userId != null">#{userId},</if>
+            <if test="desc != null">#{desc,jdbcType=VARCHAR},</if>
+            <if test="orderId != null">#{orderId,jdbcType=VARCHAR},</if>
+            <if test="processId != null">#{processId,jdbcType=VARCHAR},</if>
+            <if test="groupId != null">#{groupId,jdbcType=INTEGER},</if>
+            <if test="eventId != null">#{eventId},</if>
+            <if test="orderType != null">#{orderType,jdbcType=INTEGER},</if>
+            <if test="deleted != null">#{deleted},</if>
+        </trim>
+    </insert>
+    <update id="updateByPrimaryKeySelective" parameterType="com.ho.flow.entity.WorkOrder">
+        update work_order
+        <set>
+            <if test="planTitle != null">
+                plan_title = #{planTitle,jdbcType=VARCHAR},
+            </if>
+            <if test="title != null">
+                title = #{title,jdbcType=VARCHAR},
+            </if>
+            <if test="plannedTime != null">
+                planned_time = #{plannedTime,jdbcType=TIMESTAMP},
+            </if>
+            <if test="createTime != null">
+                create_time = #{createTime,jdbcType=TIMESTAMP},
+            </if>
+            <if test="updateTime != null">
+                update_time = #{updateTime,jdbcType=TIMESTAMP},
+            </if>
+            <if test="priority != null">
+                priority = #{priority,jdbcType=INTEGER},
+            </if>
+            <if test="phone != null">
+                phone = #{phone},
+            </if>
+            <if test="deviceId != null">
+                device_id = #{deviceId,jdbcType=INTEGER},
+            </if>
+            <if test="stationId != null">
+                station_id = #{stationId,jdbcType=INTEGER},
+            </if>
+            <if test="desc != null">
+                `desc` = #{desc,jdbcType=VARCHAR},
+            </if>
+            <if test="orderId != null">
+                order_id = #{orderId,jdbcType=VARCHAR},
+            </if>
+            <if test="processId != null">
+                process_id = #{processId,jdbcType=VARCHAR},
+            </if>
+            <if test="groupId != null">
+                group_id = #{groupId,jdbcType=INTEGER},
+            </if>
+            <if test="eventId != null">
+                event_id = #{eventId},
+            </if>
+            <if test="orderType != null">
+                order_type = #{orderType,jdbcType=INTEGER},
+            </if>
+            <if test="deleted != null">
+                deleted = #{deleted},
+            </if>
+        </set>
+
+        where id = #{id}
+    </update>
+    <update id="updateByPrimaryKey" parameterType="com.ho.flow.entity.WorkOrder">
+        update work_order
+        set plan_title   = #{planTitle,jdbcType=VARCHAR},
+            title        = #{title,jdbcType=VARCHAR},
+            planned_time = #{plannedTime,jdbcType=TIMESTAMP},
+            create_time  = #{createTime,jdbcType=TIMESTAMP},
+            update_time  = #{updateTime,jdbcType=TIMESTAMP},
+            priority     = #{priority,jdbcType=INTEGER},
+            phone        = #{phone,jdbcType=INTEGER},
+            device_id    = #{deviceId,jdbcType=INTEGER},
+            station_id   = #{stationId,jdbcType=INTEGER},
+            `desc`       = #{desc,jdbcType=VARCHAR},
+            order_id     = #{orderId,jdbcType=VARCHAR},
+            process_id   = #{processId,jdbcType=VARCHAR} group_id     = #{groupId,jdbcType=INTEGER}
+            event_id = #{eventId}
+            order_type = #{orderType,jdbcType=INTEGER}
+        where id = #{id}
+    </update>
+    <update id="setEventNull">
+        update work_order
+        set event_id = null
+    </update>
+</mapper>

flowable-center-dao/src/main/resources/mapper/WorkOrderPictureMapper.xml

@@ -0,0 +1,133 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.ho.flow.mapper.WorkOrderPictureMapper">
+
+    <resultMap id="BaseResultMap" type="com.ho.common.tools.entity.WorkOrderPicture">
+        <id property="id" column="id" jdbcType="INTEGER"/>
+        <result property="workOrderId" column="work_order_id" jdbcType="INTEGER"/>
+        <result property="fileName" column="file_name" jdbcType="VARCHAR"/>
+        <result property="url" column="url" jdbcType="VARCHAR"/>
+        <result property="type" column="type" jdbcType="INTEGER"/>
+        <result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        id
+        ,work_order_id,file_name,
+        url,type,create_time
+    </sql>
+
+    <select id="selectByPrimaryKey" resultMap="BaseResultMap">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order_picture
+        where id = #{id,jdbcType=INTEGER}
+    </select>
+
+    <select id="selectByWorkOrderIdAndType" resultType="com.ho.common.tools.entity.WorkOrderPicture">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order_picture
+        where work_order_id = #{workOrderId}
+        and type = #{type}
+    </select>
+    <select id="selectAll" resultType="com.ho.common.tools.entity.WorkOrderPicture">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order_picture
+    </select>
+
+    <delete id="deleteByPrimaryKey">
+        delete
+        from work_order_picture
+        where id = #{id,jdbcType=INTEGER}
+    </delete>
+
+    <delete id="deletedBySrcIdsAndType">
+        delete from work_order_picture
+        <where>
+            <if test="ids != null and ids.size() != 0">
+                and id in
+                <foreach collection="ids" open="(" close=")" separator="," item="item">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="type != null">
+                and type = #{type}
+            </if>
+        </where>
+    </delete>
+
+    <insert id="insert" keyColumn="id" keyProperty="id" parameterType="com.ho.common.tools.entity.WorkOrderPicture"
+            useGeneratedKeys="true">
+        insert into work_order_picture
+        ( id, work_order_id, file_name
+        , url, type, create_time)
+        values ( #{id,jdbcType=INTEGER}, #{workOrderId,jdbcType=INTEGER}, #{fileName,jdbcType=VARCHAR}
+               , #{url,jdbcType=VARCHAR}, #{type,jdbcType=INTEGER}, #{createTime,jdbcType=TIMESTAMP})
+    </insert>
+    <insert id="insertSelective" keyColumn="id" keyProperty="id"
+            parameterType="com.ho.common.tools.entity.WorkOrderPicture" useGeneratedKeys="true">
+        insert into work_order_picture
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+            <if test="id != null">id,</if>
+            <if test="workOrderId != null">work_order_id,</if>
+            <if test="fileName != null">file_name,</if>
+            <if test="url != null">url,</if>
+            <if test="type != null">type,</if>
+            <if test="createTime != null">create_time,</if>
+        </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+            <if test="id != null">#{id,jdbcType=INTEGER},</if>
+            <if test="workOrderId != null">#{workOrderId,jdbcType=INTEGER},</if>
+            <if test="fileName != null">#{fileName,jdbcType=VARCHAR},</if>
+            <if test="url != null">#{url,jdbcType=VARCHAR},</if>
+            <if test="type != null">#{type,jdbcType=INTEGER},</if>
+            <if test="createTime != null">now(),</if>
+        </trim>
+    </insert>
+    <update id="updateByPrimaryKeySelective" parameterType="com.ho.common.tools.entity.WorkOrderPicture">
+        update work_order_picture
+        <set>
+            <if test="workOrderId != null">
+                work_order_id = #{workOrderId,jdbcType=INTEGER},
+            </if>
+            <if test="fileName != null">
+                file_name = #{fileName,jdbcType=VARCHAR},
+            </if>
+            <if test="url != null">
+                url = #{url,jdbcType=VARCHAR},
+            </if>
+            <if test="type != null">
+                type = #{type,jdbcType=INTEGER},
+            </if>
+            <if test="createTime != null">
+                create_time = #{createTime,jdbcType=TIMESTAMP},
+            </if>
+        </set>
+        where id = #{id,jdbcType=INTEGER}
+    </update>
+    <update id="updateByPrimaryKey" parameterType="com.ho.common.tools.entity.WorkOrderPicture">
+        update work_order_picture
+        set work_order_id = #{workOrderId,jdbcType=INTEGER},
+            file_name     = #{fileName,jdbcType=VARCHAR},
+            url           = #{url,jdbcType=VARCHAR},
+            type          = #{type,jdbcType=INTEGER},
+            create_time   = #{createTime,jdbcType=TIMESTAMP}
+        where id = #{id,jdbcType=INTEGER}
+    </update>
+    <update id="setUpWorkOrderIdIdNUll">
+        update work_order_picture
+        set work_order_id = null
+        <where>
+            <if test="pictureIds != null and pictureIds.size() != 0">
+                and id in
+                <foreach collection="pictureIds" open="(" close=")" separator="," item="item">
+                    #{item}
+                </foreach>
+            </if>
+        </where>
+    </update>
+</mapper>

flowable-center-dao/src/main/resources/mapper/WorkOrderPlanMapper.xml

@@ -0,0 +1,136 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.ho.flow.mapper.WorkOrderPlanMapper">
+
+    <sql id="Base_Column_List">
+        id
+        ,user_id,group_id,
+        date_type,`day`,exec_day,effect_date,
+        expire_date,order_type,plan_title,
+        `desc`
+    </sql>
+
+    <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultType="com.ho.flow.entity.WorkOrderPlan">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order_plan
+        where id = #{id,jdbcType=INTEGER}
+    </select>
+
+    <select id="selectAll" resultType="com.ho.flow.entity.WorkOrderPlan">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order_plan
+        order by effect_date desc
+    </select>
+    <select id="selectByGroupId" resultType="com.ho.flow.entity.WorkOrderPlan">
+        select
+        <include refid="Base_Column_List"/>
+        from work_order_plan
+        <where>
+            <if test="groupId != null">
+                group_id = #{groupId}
+            </if>
+        </where>
+    </select>
+
+
+    <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
+        delete
+        from work_order_plan
+        where id = #{id,jdbcType=INTEGER}
+    </delete>
+    <insert id="insert" keyColumn="id" keyProperty="id" parameterType="com.ho.flow.entity.WorkOrderPlan"
+            useGeneratedKeys="true">
+        insert into work_order_plan
+        ( user_id, group_id
+        , date_type, `day`, exec_day, effect_date
+        , expire_date, order_type, plan_title
+        , `desc`)
+        values ( #{jdbcType=INTEGER}, #{userId,jdbcType=VARCHAR}, #{groupId,jdbcType=INTEGER}
+               , #{dateType,jdbcType=VARCHAR}, #{day,jdbcType=INTEGER}, #{execDay,jdbcType=INTEGER}
+               , #{effectDate,jdbcType=TIMESTAMP}
+               , #{expireDate,jdbcType=TIMESTAMP}, #{orderType,jdbcType=INTEGER}, #{planTitle,jdbcType=VARCHAR}
+               , #{desc,jdbcType=VARCHAR})
+    </insert>
+    <insert id="insertSelective" keyColumn="id" keyProperty="id" parameterType="com.ho.flow.entity.WorkOrderPlan"
+            useGeneratedKeys="true">
+        insert into work_order_plan
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+            <if test="userId != null">user_id,</if>
+            <if test="groupId != null">group_id,</if>
+            <if test="dateType != null">date_type,</if>
+            <if test="day != null">`day`,</if>
+            <if test="execDay != null">exec_day,</if>
+            <if test="effectDate != null">effect_date,</if>
+            <if test="expireDate != null">expire_date,</if>
+            <if test="orderType != null">order_type,</if>
+            <if test="planTitle != null">plan_title,</if>
+            <if test="desc != null">`desc`,</if>
+        </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+            <if test="userId != null">#{userId,jdbcType=VARCHAR},</if>
+            <if test="groupId != null">#{groupId,jdbcType=INTEGER},</if>
+            <if test="dateType != null">#{dateType,jdbcType=VARCHAR},</if>
+            <if test="day != null">#{day,jdbcType=INTEGER},</if>
+            <if test="execDay != null">#{execDay,jdbcType=INTEGER},</if>
+            <if test="effectDate != null">#{effectDate,jdbcType=TIMESTAMP},</if>
+            <if test="expireDate != null">#{expireDate,jdbcType=TIMESTAMP},</if>
+            <if test="orderType != null">#{orderType,jdbcType=INTEGER},</if>
+            <if test="planTitle != null">#{planTitle,jdbcType=VARCHAR},</if>
+            <if test="desc != null">#{desc,jdbcType=VARCHAR},</if>
+        </trim>
+    </insert>
+    <update id="updateByPrimaryKeySelective" parameterType="com.ho.flow.entity.WorkOrderPlan">
+        update work_order_plan
+        <set>
+            <if test="userId != null">
+                user_id = #{userId,jdbcType=VARCHAR},
+            </if>
+            <if test="groupId != null">
+                group_id = #{groupId,jdbcType=INTEGER},
+            </if>
+            <if test="dateType != null">
+                date_type = #{dateType,jdbcType=VARCHAR},
+            </if>
+            <if test="day != null">
+                `day` = #{day,jdbcType=INTEGER},
+            </if>
+            <if test="execDay != null">
+                exec_day = #{execDay,jdbcType=INTEGER},
+            </if>
+            <if test="effectDate != null">
+                effect_date = #{effectDate,jdbcType=TIMESTAMP},
+            </if>
+            <if test="expireDate != null">
+                expire_date = #{expireDate,jdbcType=TIMESTAMP},
+            </if>
+            <if test="orderType != null">
+                order_type = #{orderType,jdbcType=INTEGER},
+            </if>
+            <if test="planTitle != null">
+                plan_title = #{planTitle,jdbcType=VARCHAR},
+            </if>
+            <if test="desc != null">
+                `desc` = #{desc,jdbcType=VARCHAR},
+            </if>
+        </set>
+        where id = #{id,jdbcType=INTEGER}
+    </update>
+    <update id="updateByPrimaryKey" parameterType="com.ho.flow.entity.WorkOrderPlan">
+        update work_order_plan
+        set user_id     = #{userId,jdbcType=VARCHAR},
+            group_id    = #{groupId,jdbcType=INTEGER},
+            date_type   = #{dateType,jdbcType=VARCHAR},
+            `day`       = #{day,jdbcType=INTEGER},
+            exec_day    = #{execDay,jdbcType=INTEGER},
+            effect_date = #{effectDate,jdbcType=TIMESTAMP},
+            expire_date = #{expireDate,jdbcType=TIMESTAMP},
+            order_type  = #{orderType,jdbcType=INTEGER},
+            plan_title  = #{planTitle,jdbcType=VARCHAR},
+            `desc`      = #{desc,jdbcType=VARCHAR}
+        where id = #{id,jdbcType=INTEGER}
+    </update>
+</mapper>

flowable-center-dao/src/main/resources/mapper/WorkOrderPlanSubMapper.xml

@@ -0,0 +1,106 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.ho.flow.mapper.WorkOrderPlanSubMapper">
+
+    <resultMap id="BaseResultMap" type="com.ho.flow.entity.WorkOrderPlanSub">
+            <id property="id" column="id" jdbcType="INTEGER"/>
+            <result property="pid" column="pid" jdbcType="INTEGER"/>
+            <result property="type" column="type" jdbcType="VARCHAR"/>
+            <result property="srcId" column="src_id" jdbcType="INTEGER"/>
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        id,pid,type,
+        src_id,user_id
+    </sql>
+
+    <select id="selectByPrimaryKey" parameterType="java.lang.Long" resultMap="BaseResultMap">
+        select
+        <include refid="Base_Column_List" />
+        from work_order_plan_sub
+        where  id = #{id,jdbcType=INTEGER} 
+    </select>
+
+    <select id="selectByPid" resultType="com.ho.flow.entity.WorkOrderPlanSub">
+        select
+        <include refid="Base_Column_List" />
+        from work_order_plan_sub
+        where  pid = #{pid}
+    </select>
+
+    <delete id="deleteByPrimaryKey" parameterType="java.lang.Long">
+        delete from work_order_plan_sub
+        where  id = #{id,jdbcType=INTEGER} 
+    </delete>
+    <delete id="deleteByPid">
+        delete from work_order_plan_sub
+        where pid = #{pid}
+    </delete>
+    <insert id="insert" keyColumn="id" keyProperty="id" parameterType="com.ho.flow.entity.WorkOrderPlanSub" useGeneratedKeys="true">
+        insert into work_order_plan_sub
+        ( id,pid,type
+        ,src_id)
+        values (#{id,jdbcType=INTEGER},#{pid,jdbcType=INTEGER},#{type,jdbcType=VARCHAR}
+        ,#{srcId,jdbcType=INTEGER})
+    </insert>
+    <insert id="insertSelective" keyColumn="id" keyProperty="id" parameterType="com.ho.flow.entity.WorkOrderPlanSub" useGeneratedKeys="true">
+        insert into work_order_plan_sub
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+                <if test="id != null">id,</if>
+                <if test="pid != null">pid,</if>
+                <if test="type != null">type,</if>
+                <if test="srcId != null">src_id,</if>
+                <if test="userId != null">user_id,</if>
+        </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+                <if test="id != null">#{id,jdbcType=INTEGER},</if>
+                <if test="pid != null">#{pid,jdbcType=INTEGER},</if>
+                <if test="type != null">#{type,jdbcType=VARCHAR},</if>
+                <if test="srcId != null">#{srcId,jdbcType=INTEGER},</if>
+                <if test="userId != null">#{userId,jdbcType=VARCHAR},</if>
+        </trim>
+    </insert>
+    <insert id="insertBatch">
+        insert into work_order_plan_sub
+        ( pid,type
+        ,src_id)
+        values
+        <foreach item="item" collection="list" index="index" separator=",">
+         (#{item.pid},#{item.type},#{item.srcId})
+        </foreach>
+    </insert>
+    <insert id="insertUserBatch">
+        insert into work_order_plan_sub
+        ( pid,type
+        ,user_id)
+        values
+        <foreach item="item" collection="list" index="index" separator=",">
+            (#{item.pid},#{item.type},#{item.userId})
+        </foreach>
+    </insert>
+    <update id="updateByPrimaryKeySelective" parameterType="com.ho.flow.entity.WorkOrderPlanSub">
+        update work_order_plan_sub
+        <set>
+                <if test="pid != null">
+                    pid = #{pid,jdbcType=INTEGER},
+                </if>
+                <if test="type != null">
+                    type = #{type,jdbcType=VARCHAR},
+                </if>
+                <if test="srcId != null">
+                    src_id = #{srcId,jdbcType=INTEGER},
+                </if>
+        </set>
+        where   id = #{id,jdbcType=INTEGER} 
+    </update>
+    <update id="updateByPrimaryKey" parameterType="com.ho.flow.entity.WorkOrderPlanSub">
+        update work_order_plan_sub
+        set 
+            pid =  #{pid,jdbcType=INTEGER},
+            type =  #{type,jdbcType=VARCHAR},
+            src_id =  #{srcId,jdbcType=INTEGER}
+        where   id = #{id,jdbcType=INTEGER} 
+    </update>
+</mapper>

flowable-center-dao/src/main/resources/mapper/WorkOrderSubMapper.xml

@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.ho.flow.mapper.WorkOrderSubMapper">
+
+
+
+    <sql id="Base_Column_List">
+        id,pid,type,
+        src_id
+    </sql>
+
+    <select id="selectByPrimaryKey" resultType="com.ho.flow.entity.WorkOrderSub">
+        select
+        <include refid="Base_Column_List" />
+        from work_order_sub
+        where  id = #{id,jdbcType=INTEGER}
+    </select>
+    <select id="selectByPid" resultType="com.ho.flow.entity.WorkOrderSub">
+        select
+        <include refid="Base_Column_List" />
+        from work_order_sub
+        where  pid = #{pId,jdbcType=INTEGER}
+    </select>
+
+    <delete id="deleteByPrimaryKey">
+        delete from work_order_sub
+        where  id = #{id,jdbcType=INTEGER}
+    </delete>
+
+    <delete id="deleteByPid">
+        delete from work_order_sub
+        where pid = #{pid}
+    </delete>
+
+    <insert id="insert" keyColumn="id" keyProperty="id" parameterType="com.ho.flow.entity.WorkOrderSub" useGeneratedKeys="true">
+        insert into work_order_sub
+        ( id,pid,type
+        ,src_id)
+        values (#{id,jdbcType=INTEGER},#{pid,jdbcType=BIGINT},#{type,jdbcType=INTEGER}
+               ,#{srcId,jdbcType=INTEGER})
+    </insert>
+    <insert id="insertSelective" keyColumn="id" keyProperty="id" parameterType="com.ho.flow.entity.WorkOrderSub" useGeneratedKeys="true">
+        insert into work_order_sub
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+            <if test="id != null">id,</if>
+            <if test="pid != null">pid,</if>
+            <if test="type != null">type,</if>
+            <if test="srcId != null">src_id,</if>
+        </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+            <if test="id != null">#{id,jdbcType=INTEGER},</if>
+            <if test="pid != null">#{pid,jdbcType=BIGINT},</if>
+            <if test="type != null">#{type,jdbcType=INTEGER},</if>
+            <if test="srcId != null">#{srcId,jdbcType=INTEGER},</if>
+        </trim>
+    </insert>
+
+    <insert id="insertBatch">
+        insert into work_order_sub
+        ( pid,`type`
+        ,src_id)
+        values
+        <foreach item="item" collection="list" index="index" separator=",">
+            (#{item.pid},#{item.type},#{item.srcId})
+        </foreach>
+    </insert>
+
+    <update id="updateByPrimaryKeySelective" parameterType="com.ho.flow.entity.WorkOrderSub">
+        update work_order_sub
+        <set>
+            <if test="pid != null">
+                pid = #{pid,jdbcType=BIGINT},
+            </if>
+            <if test="type != null">
+                type = #{type,jdbcType=INTEGER},
+            </if>
+            <if test="srcId != null">
+                src_id = #{srcId,jdbcType=INTEGER},
+            </if>
+        </set>
+        where   id = #{id,jdbcType=INTEGER}
+    </update>
+    <update id="updateByPrimaryKey" parameterType="com.ho.flow.entity.WorkOrderSub">
+        update work_order_sub
+        set
+            pid =  #{pid,jdbcType=BIGINT},
+            type =  #{type,jdbcType=INTEGER},
+            src_id =  #{srcId,jdbcType=INTEGER}
+        where   id = #{id,jdbcType=INTEGER}
+    </update>
+</mapper>

flowable-center-dao/src/main/resources/processes/order1.bpmn20.xml

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:activiti="http://activiti.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI" typeLanguage="http://www.w3.org/2001/XMLSchema" expressionLanguage="http://www.w3.org/1999/XPath" targetNamespace="http://www.activiti.org/processdef">
+  <process id="order1" name="order1" isExecutable="true">
+    <startEvent id="sid-c414ef16-09ea-4e16-b6f0-214b8a1976d6"/>
+    <sequenceFlow id="sid-6067ee69-a01c-41cf-bc9b-c7a0312c92ce" sourceRef="sid-c414ef16-09ea-4e16-b6f0-214b8a1976d6" targetRef="d1"/>
+    <endEvent id="sid-ce510ee0-17a5-458a-9eb7-08709a95871a"/>
+    <userTask id="d1" name="d1">
+      <extensionElements>
+        <activiti:taskListener class="com.ho.flow.listener.Node1Listener" event="create"/>
+      </extensionElements>
+    </userTask>
+    <userTask id="d2" name="d2">
+      <extensionElements>
+        <activiti:taskListener class="com.ho.flow.listener.Node2Listener" event="create"/>
+      </extensionElements>
+    </userTask>
+
+    <sequenceFlow id="sid-24b86efe-c13b-4245-ae83-6149d3707fba" sourceRef="d1" targetRef="d2"/>
+    <sequenceFlow id="sid-7ade5d3c-a914-42ad-9535-c84ceba37aed" sourceRef="d2" targetRef="sid-ce510ee0-17a5-458a-9eb7-08709a95871a"/>
+  </process>
+  <bpmndi:BPMNDiagram id="BPMNDiagram_order1">
+    <bpmndi:BPMNPlane bpmnElement="order1" id="BPMNPlane_order1">
+      <bpmndi:BPMNShape id="shape-a0f2f19d-38c1-42b9-a1ca-fdf8036b7a21" bpmnElement="sid-c414ef16-09ea-4e16-b6f0-214b8a1976d6">
+        <omgdc:Bounds x="-280.0" y="-60.0" width="30.0" height="30.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNEdge id="edge-839c460e-520f-495a-9294-e1b5511c81a6" bpmnElement="sid-6067ee69-a01c-41cf-bc9b-c7a0312c92ce">
+        <omgdi:waypoint x="-250.0" y="-45.0"/>
+        <omgdi:waypoint x="-170.0" y="-50.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNShape id="shape-a02b9317-d62d-4153-ac7f-8d877373d069" bpmnElement="sid-ce510ee0-17a5-458a-9eb7-08709a95871a">
+        <omgdc:Bounds x="100.0" y="-65.0" width="30.0" height="30.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="shape-84979c24-dde1-4543-ac84-fb5c1691f971" bpmnElement="d1">
+        <omgdc:Bounds x="-170.0" y="-85.0" width="70.0" height="60.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="shape-f0f6aabb-0212-47ab-a370-5faf0fc6b218" bpmnElement="d2">
+        <omgdc:Bounds x="-60.0" y="-90.0" width="100.0" height="80.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNEdge id="edge-ee47f5c3-cc86-44b9-af2b-5ddc3ffd68c2" bpmnElement="sid-24b86efe-c13b-4245-ae83-6149d3707fba">
+        <omgdi:waypoint x="-100.0" y="-70.0"/>
+        <omgdi:waypoint x="-60.0" y="-70.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="edge-72130a01-54cd-4313-b794-17dd309ff8fa" bpmnElement="sid-7ade5d3c-a914-42ad-9535-c84ceba37aed">
+        <omgdi:waypoint x="40.0" y="-50.0"/>
+        <omgdi:waypoint x="100.0" y="-50.0"/>
+      </bpmndi:BPMNEdge>
+    </bpmndi:BPMNPlane>
+  </bpmndi:BPMNDiagram>
+</definitions>

flowable-center-dao/src/main/resources/processes/order2.bpmn20.xml

@@ -0,0 +1,100 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:activiti="http://activiti.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI" typeLanguage="http://www.w3.org/2001/XMLSchema" expressionLanguage="http://www.w3.org/1999/XPath" targetNamespace="http://www.activiti.org/processdef">
+  <process id="order2" name="order2" isExecutable="true">
+    <startEvent id="d-start"/>
+    <userTask id="d1" name="分配工单的节点" activiti:candidateGroups="${stationId}">
+      <extensionElements>
+        <activiti:formProperty id="Property 1"/>
+      </extensionElements>
+    </userTask>
+    <userTask id="d2" name="接收或驳回的节点" activiti:assignee="${orderReq.workerId}"/>
+    <exclusiveGateway id="x1" name="接收或驳回的网关"/>
+    <sequenceFlow id="sid-ce0abf7c-67ce-482d-9c07-e8aeacb78030" sourceRef="d2" targetRef="x1"/>
+    <sequenceFlow id="sid-0ff6fea8-b044-4737-9c44-25b067c54205" sourceRef="d1" targetRef="d2"/>
+    <sequenceFlow id="sid-a0440356-7166-4c7e-893f-ebf04175b0ed" sourceRef="d-start" targetRef="d1"/>
+    <userTask id="d3" activiti:assignee="${orderReq.workerId}" name="处理工单的节点"/>
+    <sequenceFlow id="x1-agree" sourceRef="x1" targetRef="d3" name="接收工单">
+      <conditionExpression xsi:type="tFormalExpression">${orderReq.reject==0}</conditionExpression>
+    </sequenceFlow>
+    <sequenceFlow id="x1-reject" sourceRef="x1" targetRef="d1" name="驳回工单">
+      <conditionExpression xsi:type="tFormalExpression">${orderReq.reject==1}</conditionExpression>
+    </sequenceFlow>
+    <endEvent id="d-end"/>
+    <userTask id="d4" name="验收通过或没通过" activiti:candidateGroups="${stationId}"/>
+    <sequenceFlow id="sid-66006a35-37a5-4d09-9396-5515ec83be06" sourceRef="d3" targetRef="d4"/>
+    <exclusiveGateway id="x2" name="验收通过或没通过的网关"/>
+    <sequenceFlow id="sid-d34a0a46-905a-4b99-b696-0bda31dd795c" sourceRef="d4" targetRef="x2"/>
+    <sequenceFlow id="sid-087f20af-9034-445c-b16e-79921a28b938" sourceRef="x2" targetRef="d3" name="工单验收不通过">
+      <conditionExpression xsi:type="tFormalExpression">${orderReq.complete==0}</conditionExpression>
+    </sequenceFlow>
+    <sequenceFlow id="sid-84b81ee3-39d1-45ea-98cb-cc41f7c3454e" sourceRef="x2" targetRef="d-end" name="工单验收通过">
+      <conditionExpression xsi:type="tFormalExpression">${orderReq.complete==1}</conditionExpression>
+    </sequenceFlow>
+  </process>
+  <bpmndi:BPMNDiagram id="BPMNDiagram_order2">
+    <bpmndi:BPMNPlane bpmnElement="order2" id="BPMNPlane_order2">
+      <bpmndi:BPMNShape id="shape-9d49be98-cc1a-4232-b40d-e822f3e5b183" bpmnElement="d-start">
+        <omgdc:Bounds x="-490.0" y="0.0" width="30.0" height="30.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="shape-13475417-9e0a-4059-92f5-7753ae17748d" bpmnElement="d1">
+        <omgdc:Bounds x="-400.0" y="-12.5" width="60.0" height="55.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="shape-5b7a834a-6ff8-4917-a61e-295feaaa37d5" bpmnElement="d2">
+        <omgdc:Bounds x="-250.0" y="-14.999998" width="70.0" height="60.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="shape-84a86e19-b70f-48a9-9801-3d7e0f6d5908" bpmnElement="x1">
+        <omgdc:Bounds x="-235.0" y="-110.0" width="40.0" height="40.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNEdge id="edge-5a2a83ec-bd4e-48d6-90da-505942369c79" bpmnElement="sid-ce0abf7c-67ce-482d-9c07-e8aeacb78030">
+        <omgdi:waypoint x="-215.0" y="-14.999998"/>
+        <omgdi:waypoint x="-215.0" y="-70.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="edge-6c797a63-9d64-4fb9-bb1d-0129311bed27" bpmnElement="sid-0ff6fea8-b044-4737-9c44-25b067c54205">
+        <omgdi:waypoint x="-340.0" y="15.0"/>
+        <omgdi:waypoint x="-250.0" y="15.000002"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="edge-3a37999e-813d-44dd-8e63-1f28d9e5f86e" bpmnElement="sid-a0440356-7166-4c7e-893f-ebf04175b0ed">
+        <omgdi:waypoint x="-460.0" y="15.0"/>
+        <omgdi:waypoint x="-400.0" y="15.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNShape id="shape-935e9064-2671-4ef9-97c7-e24d347cdc8d" bpmnElement="d3">
+        <omgdc:Bounds x="-120.0" y="-120.0" width="65.0" height="60.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNEdge id="edge-b4a11447-d068-4f93-a358-c3dc5c1bac7c" bpmnElement="x1-agree">
+        <omgdi:waypoint x="-194.99998" y="-89.99999"/>
+        <omgdi:waypoint x="-180.0" y="-90.0"/>
+        <omgdi:waypoint x="-162.5" y="-90.0"/>
+        <omgdi:waypoint x="-120.0" y="-90.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="edge-b43952f3-f450-4eb7-8fc0-1958ebc22b2e" bpmnElement="x1-reject">
+        <omgdi:waypoint x="-235.0" y="-90.0"/>
+        <omgdi:waypoint x="-340.0" y="1.25"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNShape id="shape-96f035a9-d956-4558-b675-0ac4fd796f2e" bpmnElement="d-end">
+        <omgdc:Bounds x="-92.5" y="-20.0" width="30.0" height="30.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="sid-95f15de4-2997-4128-bf53-9c50d65f4321" bpmnElement="d4">
+        <omgdc:Bounds x="10.0" y="-120.0" width="65.0" height="60.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNEdge id="edge-d72b1e68-3861-4d90-8f69-a58410ba7507" bpmnElement="sid-66006a35-37a5-4d09-9396-5515ec83be06">
+        <omgdi:waypoint x="-55.0" y="-90.0"/>
+        <omgdi:waypoint x="10.0" y="-90.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNShape id="shape-1d99afd1-0d26-473f-88ab-20544ca2a8e9" bpmnElement="x2">
+        <omgdc:Bounds x="22.5" y="-25.0" width="40.0" height="40.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNEdge id="edge-dbfe3748-10b8-483f-9774-a66997524812" bpmnElement="sid-d34a0a46-905a-4b99-b696-0bda31dd795c">
+        <omgdi:waypoint x="42.5" y="-60.0"/>
+        <omgdi:waypoint x="42.5" y="-25.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="edge-9955319f-3484-4ecb-8a04-72ed5109bd63" bpmnElement="sid-087f20af-9034-445c-b16e-79921a28b938">
+        <omgdi:waypoint x="32.5" y="-15.0"/>
+        <omgdi:waypoint x="-55.0" y="-75.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="edge-04bd5652-7fe4-493f-9d0a-9372fb0cdf92" bpmnElement="sid-84b81ee3-39d1-45ea-98cb-cc41f7c3454e">
+        <omgdi:waypoint x="22.5" y="-5.0"/>
+        <omgdi:waypoint x="-62.5" y="-5.0"/>
+      </bpmndi:BPMNEdge>
+    </bpmndi:BPMNPlane>
+  </bpmndi:BPMNDiagram>
+</definitions>

flowable-center-dao/src/main/resources/processes/workOrder.bpmn20.xml

@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:activiti="http://activiti.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI" typeLanguage="http://www.w3.org/2001/XMLSchema" expressionLanguage="http://www.w3.org/1999/XPath" targetNamespace="http://www.activiti.org/processdef">
+  <process id="workOrder" name="workOrder" isExecutable="true">
+    <startEvent id="start-workorder"/>
+    <userTask id="d1" name="创建工单" activiti:assignee="${startUser}">
+      <extensionElements>
+        <activiti:taskListener class="com.ho.flow.listener.Node1Listener" event="create"/>
+      </extensionElements>
+    </userTask>
+    <userTask id="d2" name="处理工单">
+      <extensionElements>
+        <activiti:taskListener class="com.ho.flow.listener.Node1Listener" event="create"/>
+      </extensionElements>
+    </userTask>
+    <userTask id="d3" name="验收工单">
+      <extensionElements>
+        <activiti:taskListener class="com.ho.flow.listener.Node1Listener" event="create"/>
+      </extensionElements>
+    </userTask>
+    <userTask id="d4" name="评价工单">
+      <extensionElements>
+        <activiti:taskListener class="com.ho.flow.listener.Node1Listener" event="create"/>
+      </extensionElements>
+    </userTask>
+    <endEvent id="end-workorder"/>
+    <endEvent id="cancel-workorder"/>
+    <sequenceFlow id="sid-4ac0805f-3d90-4a46-a592-7de4ece7b511" sourceRef="start-workorder" targetRef="d1"/>
+    <sequenceFlow id="sid-f872c33d-1b0a-4c48-85bf-8d9c1e685c48" sourceRef="d1" targetRef="d2">
+      <conditionExpression>${complete==0}</conditionExpression>
+    </sequenceFlow>
+    <sequenceFlow id="sid-563b14ed-13a1-4e1b-95a0-15a0b15fb640" sourceRef="d2" targetRef="d1">
+      <conditionExpression>${complete==1}</conditionExpression>
+    </sequenceFlow>
+    <sequenceFlow id="sid-e0e874a3-d5bd-4c78-8867-00b9c06d9cd0" sourceRef="d2" targetRef="d3">
+      <conditionExpression>${complete==0}</conditionExpression>
+    </sequenceFlow>
+    <sequenceFlow id="sid-f018f67f-56ab-4bb1-9351-e2a2d7a41448" sourceRef="d3" targetRef="d4">
+      <conditionExpression>${complete==0}</conditionExpression>
+    </sequenceFlow>
+    <sequenceFlow id="sid-e9371c33-3692-4e1e-9873-b1a0cbd0c667" sourceRef="d3" targetRef="d2">
+      <conditionExpression>${complete==2}</conditionExpression>
+    </sequenceFlow>
+    <sequenceFlow id="sid-48ec5ec3-e4d7-4a2a-8525-350a39bc8cda" sourceRef="d3" targetRef="d1">
+      <conditionExpression>${complete==1}</conditionExpression>
+    </sequenceFlow>
+    <sequenceFlow id="sid-eb2b92f2-acf4-477a-a8b4-eb0e3e4f9e17" sourceRef="d4" targetRef="d3">
+      <conditionExpression>${complete==3}</conditionExpression>
+    </sequenceFlow>
+    <sequenceFlow id="sid-b38c6c3a-2946-40a2-a193-721004a9817e" sourceRef="d4" targetRef="d2">
+      <conditionExpression>${complete==2}</conditionExpression>
+    </sequenceFlow>
+    <sequenceFlow id="sid-582462db-74d0-4921-b402-6505e6d283f9" sourceRef="d4" targetRef="d1">
+      <conditionExpression>${complete==1}</conditionExpression>
+    </sequenceFlow>
+    <sequenceFlow id="sid-026ed14c-8337-4f60-b3e5-551431e68b42" sourceRef="d1" targetRef="cancel-workorder">
+      <conditionExpression>${complete==1}</conditionExpression>
+    </sequenceFlow>
+    <sequenceFlow id="sid-38cc02a8-1be7-4b8c-ae0b-5983beaf4c57" sourceRef="d4" targetRef="end-workorder">
+      <conditionExpression>${complete==0}</conditionExpression>
+    </sequenceFlow>
+  </process>
+  <bpmndi:BPMNDiagram id="BPMNDiagram_workOrder">
+    <bpmndi:BPMNPlane bpmnElement="workOrder" id="BPMNPlane_workOrder">
+      <bpmndi:BPMNShape id="shape-b4955b78-cfe4-458c-b9df-94c51c85aa44" bpmnElement="start-workorder">
+        <omgdc:Bounds x="-320.0" y="-35.0" width="30.0" height="30.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="shape-bc8ee721-fcbc-4a95-9ccc-814cbe9fd54b" bpmnElement="d1">
+        <omgdc:Bounds x="-245.0" y="-40.0" width="45.0" height="40.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="sid-9381f63a-4494-4fb0-aaa7-45e951302edd" bpmnElement="d2">
+        <omgdc:Bounds x="-161.5" y="-40.0" width="45.0" height="40.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="sid-e3da6fc3-5e97-4c25-a449-ea78193b9010" bpmnElement="d3">
+        <omgdc:Bounds x="-66.5" y="-40.0" width="45.0" height="40.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="sid-d7653211-42a4-43dc-b62a-9915c2afbe49" bpmnElement="d4">
+        <omgdc:Bounds x="30.0" y="-40.0" width="45.0" height="40.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="shape-31c1e224-2cde-406b-8e1c-4fff04edac65" bpmnElement="end-workorder">
+        <omgdc:Bounds x="120.0" y="-35.0" width="30.0" height="30.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="shape-2f26b9b5-72e6-4d42-9c2b-3911a52a3f91" bpmnElement="cancel-workorder">
+        <omgdc:Bounds x="-237.5" y="-135.0" width="30.0" height="30.0"/>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNEdge id="edge-f92c494f-4201-4ede-8665-0d69d5c025ce" bpmnElement="sid-4ac0805f-3d90-4a46-a592-7de4ece7b511">
+        <omgdi:waypoint x="-290.0" y="-20.0"/>
+        <omgdi:waypoint x="-245.0" y="-20.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="edge-0a3098ad-5fe1-403b-86da-f1a8bc61faec" bpmnElement="sid-f872c33d-1b0a-4c48-85bf-8d9c1e685c48">
+        <omgdi:waypoint x="-200.0" y="-20.0"/>
+        <omgdi:waypoint x="-161.5" y="-20.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="edge-27e356c2-4f66-4d8f-b295-1196f7195f00" bpmnElement="sid-563b14ed-13a1-4e1b-95a0-15a0b15fb640">
+        <omgdi:waypoint x="-161.5" y="-30.0"/>
+        <omgdi:waypoint x="-200.0" y="-30.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="edge-f28ed170-361d-4011-aa81-6acefc623953" bpmnElement="sid-e0e874a3-d5bd-4c78-8867-00b9c06d9cd0">
+        <omgdi:waypoint x="-116.5" y="-20.0"/>
+        <omgdi:waypoint x="-66.5" y="-20.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="edge-215421d9-530c-4480-be86-161227ec5d41" bpmnElement="sid-f018f67f-56ab-4bb1-9351-e2a2d7a41448">
+        <omgdi:waypoint x="-21.5" y="-20.0"/>
+        <omgdi:waypoint x="30.0" y="-20.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="edge-ca594598-b24b-4541-98a3-bf9cad24d202" bpmnElement="sid-e9371c33-3692-4e1e-9873-b1a0cbd0c667">
+        <omgdi:waypoint x="-66.5" y="-30.0"/>
+        <omgdi:waypoint x="-116.5" y="-30.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="edge-c8e8287f-0e6c-4777-8ed4-000560bb562c" bpmnElement="sid-48ec5ec3-e4d7-4a2a-8525-350a39bc8cda">
+        <omgdi:waypoint x="-66.5" y="-10.0"/>
+        <omgdi:waypoint x="-139.0" y="45.0"/>
+        <omgdi:waypoint x="-200.0" y="-10.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="edge-efa88a48-83fb-47e6-b5d9-c041a03b4dfb" bpmnElement="sid-eb2b92f2-acf4-477a-a8b4-eb0e3e4f9e17">
+        <omgdi:waypoint x="30.0" y="-30.0"/>
+        <omgdi:waypoint x="-21.5" y="-30.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="edge-daa2d750-c2ba-4595-9618-695e552d5368" bpmnElement="sid-b38c6c3a-2946-40a2-a193-721004a9817e">
+        <omgdi:waypoint x="30.0" y="-10.0"/>
+        <omgdi:waypoint x="-44.0" y="45.0"/>
+        <omgdi:waypoint x="-116.5" y="-10.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="edge-41421199-87c7-4cfe-9a99-36fb79a21e26" bpmnElement="sid-582462db-74d0-4921-b402-6505e6d283f9">
+        <omgdi:waypoint x="41.25" y="-40.0"/>
+        <omgdi:waypoint x="-100.0" y="-120.0"/>
+        <omgdi:waypoint x="-211.25" y="-40.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="edge-ae6d5ae6-af51-45ab-bdbf-d6703fe23bb8" bpmnElement="sid-026ed14c-8337-4f60-b3e5-551431e68b42">
+        <omgdi:waypoint x="-222.5" y="-40.0"/>
+        <omgdi:waypoint x="-222.5" y="-105.0"/>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="edge-915bf0b5-e5de-42ee-aec8-2740111658f6" bpmnElement="sid-38cc02a8-1be7-4b8c-ae0b-5983beaf4c57">
+        <omgdi:waypoint x="75.0" y="-20.0"/>
+        <omgdi:waypoint x="120.0" y="-20.0"/>
+      </bpmndi:BPMNEdge>
+    </bpmndi:BPMNPlane>
+  </bpmndi:BPMNDiagram>
+</definitions>