jiangyq
/
YanZhu_GZ_AI
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

提交代码

main
姜玉琦 2024-06-27 01:13:11 +08:00
parent d2af042960
commit 3d016b1db7
66 changed files with 231 additions and 7186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
pom.xml
View File

@ -8,8 +8,8 @@
<artifactId>yanzhu</artifactId>
<version>3.8.7</version>
<name>yzProjectManage</name>
<description>临时项目管理系统</description>
<name>YanZhuGZAI</name>
<description>研筑广州AI项目</description>
<properties>
<yanzhu.version>3.8.7</yanzhu.version>
@ -29,7 +29,6 @@
<poi.version>4.1.2</poi.version>
<velocity.version>2.3</velocity.version>
<jwt.version>0.9.1</jwt.version>
<flowable.version>6.8.0</flowable.version>
</properties>
<!-- 依赖声明 -->
@ -170,16 +169,6 @@
<version>${yanzhu.version}</version>
</dependency>
<dependency>
<groupId>com.yanzhu</groupId>
<artifactId>yanzhu-flowable</artifactId>
<version>${yanzhu.version}</version>
</dependency>
<dependency>
<groupId>org.flowable</groupId>
<artifactId>flowable-spring-boot-starter</artifactId>
<version>${flowable.version}</version>
</dependency>
<dependency>
<groupId>io.swagger</groupId>
<artifactId>swagger-annotations</artifactId>
@ -202,7 +191,6 @@
<module>yanzhu-quartz</module>
<module>yanzhu-generator</module>
<module>yanzhu-common</module>
<module>yanzhu-flowable</module>
</modules>
<packaging>pom</packaging>

6
yanzhu-admin/pom.xml
View File

@ -61,12 +61,6 @@
<artifactId>yanzhu-generator</artifactId>
</dependency>
<!-- 系统核心-->
<dependency>
<groupId>com.yanzhu</groupId>
<artifactId>yanzhu-flowable</artifactId>
</dependency>
</dependencies>
<build>

3
yanzhu-admin/src/main/java/com/yanzhu/YanZhuApplication.java
View File

@ -14,9 +14,8 @@ public class YanZhuApplication
{
public static void main(String[] args)
{
// System.setProperty("spring.devtools.restart.enabled", "false");
SpringApplication.run(YanZhuApplication.class, args);
System.out.println("(♥◠‿◠)ﾉﾞ 研筑临时项目管理启动成功 ლ(´ڡ`ლ)ﾞ \n" +
System.out.println("(♥◠‿◠)ﾉﾞ 研筑广州AI项目启动成功 ლ(´ڡ`ლ)ﾞ \n" +
" .-------. ____ __ \n" +
" | _ _ \\ \\ \\ / / \n" +
" | ( ' ) | \\ _. / ' \n" +

55
yanzhu-admin/src/main/java/com/yanzhu/web/controller/ai/AIBoxController.java
View File

@ -1,55 +0,0 @@
package com.yanzhu.web.controller.ai;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.yanzhu.common.annotation.RateLimiter;
import com.yanzhu.common.core.controller.BaseController;
import com.yanzhu.common.enums.LimitType;
import com.yanzhu.system.domain.ai.DevAiProjectDataVO;
import com.yanzhu.system.service.IDevAiProjectDataService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.Map;
/**
* AIBoxController
* 智能盒子
* @author JiangYuQi
* @date 2023-07-29
*/
@RestController
@RequestMapping("/publics/aiBox")
public class AIBoxController extends BaseController {
@Autowired
private IDevAiProjectDataService devAiProjectDataService;
private static final Logger logger = LoggerFactory.getLogger("AIBoxController");
/**
* aibox推送预警数据
*/
@PostMapping("/v1/push")
@RateLimiter(count = 10, limitType = LimitType.IP)
public void push(@RequestBody Map<String,Object> dataMap)
{
try{
List<Map<String,Object>> list = (List<Map<String,Object>>)dataMap.get("BehaviorResults");
DevAiProjectDataVO devAiProjectDataVO = JSON.parseObject(JSONObject.toJSONString(list.get(0)), DevAiProjectDataVO.class);
devAiProjectDataService.insertHttpDevAiProjectData(devAiProjectDataVO);
}catch (Exception e){
logger.info("AiBox解析参数失败！！！");
logger.info(dataMap.toString());
e.printStackTrace();
}
}
}

163
yanzhu-admin/src/main/java/com/yanzhu/web/controller/aibox/AIBoxController.java 100644
View File

@ -0,0 +1,163 @@
package com.yanzhu.web.controller.aibox;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.yanzhu.common.annotation.Anonymous;
import com.yanzhu.common.annotation.RateLimiter;
import com.yanzhu.common.core.controller.BaseController;
import com.yanzhu.common.core.domain.AjaxResult;
import com.yanzhu.common.core.domain.entity.SysDictData;
import com.yanzhu.common.core.page.TableDataInfo;
import com.yanzhu.common.core.redis.RedisCache;
import com.yanzhu.common.core.text.Convert;
import com.yanzhu.common.enums.LimitType;
import com.yanzhu.common.utils.DictUtils;
import com.yanzhu.common.utils.StringUtils;
import com.yanzhu.system.domain.ai.DevAiProjectData;
import com.yanzhu.system.domain.ai.DevAiProjectDataVO;
import com.yanzhu.system.service.IDevAiProjectDataService;
import com.yanzhu.system.service.ISysDictTypeService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
/**
* AIBoxController
* 智能盒子
* @author JiangYuQi
* @date 2023-07-29
*/
@RestController
@RequestMapping("/publics/aiBox")
public class AIBoxController extends BaseController {
@Autowired
private IDevAiProjectDataService devAiProjectDataService;
private static final Logger logger = LoggerFactory.getLogger("AIBoxController");
/**
* aibox推送预警数据
*/
@Anonymous
@PostMapping("/v1/push")
@RateLimiter(count = 10, limitType = LimitType.IP)
public void push(@RequestBody Map<String,Object> dataMap)
{
try{
List<Map<String,Object>> list = (List<Map<String,Object>>)dataMap.get("BehaviorResults");
DevAiProjectDataVO devAiProjectDataVO = JSON.parseObject(JSONObject.toJSONString(list.get(0)), DevAiProjectDataVO.class);
devAiProjectDataService.insertHttpDevAiProjectData(devAiProjectDataVO);
}catch (Exception e){
logger.info("AiBox解析参数失败！！！");
logger.info(dataMap.toString());
e.printStackTrace();
}
}
private final static Integer CACHE_TIME = 1;
@Autowired
private RedisCache redisCache;
@Autowired
private ISysDictTypeService dictTypeService;
/**
* 查询字典类型详细
*/
@Anonymous
@GetMapping(value = "/dicts")
public AjaxResult getDictType()
{
String key="PUBLIC_AIBOX_dicts";
Object obj=redisCache.getCacheObject(key);
if(obj!=null){
return success(obj);
}
List<SysDictData> list = dictTypeService.selectDictDataByType("aibox_alarm_type");
redisCache.setCacheObject(key, list, CACHE_TIME*5, TimeUnit.MINUTES);
return success(list);
}
/**
* 查询AI预警列表
*/
@Anonymous
@GetMapping("/v1/listView")
public AjaxResult listView(String deptId, String projectId)
{
String key="PUBLIC_AIBOX_listView_"+deptId+"_"+projectId;
Object obj=redisCache.getCacheObject(key);
if(obj!=null){
return success(obj);
}
DevAiProjectData devAiProjectData = new DevAiProjectData();
if(StringUtils.isNotEmpty(deptId)){
devAiProjectData.setDeptId(Convert.toLong(deptId));
}
if(StringUtils.isNotEmpty(projectId)){
devAiProjectData.setProjectId(Convert.toLong(projectId));
}
//默认查询当天数据
/*Map<String, Object> params = new HashMap<>();
params.put("date",new Date());
devAiProjectData.setParams(params);*/
startPage();
List<DevAiProjectData> list = devAiProjectDataService.selectDevAiProjectDataList(devAiProjectData);
redisCache.setCacheObject(key, list, CACHE_TIME, TimeUnit.MINUTES);
return success(list);
}
/**
* 查询AI预警列表
*/
@Anonymous
@PostMapping("/list")
public TableDataInfo list(@RequestBody DevAiProjectData devAiProjectData)
{
startPage();
List<DevAiProjectData> list = devAiProjectDataService.selectDevAiProjectDataList(devAiProjectData);
return getDataTable(list);
}
/**
* 查询视频配置列表
*/
@Anonymous
@GetMapping("/groupCountByAlarmType")
public AjaxResult groupCountByAlarmType(String deptId,String projectId,String now)
{
String key="PUBLIC_AIBOX_groupCountByAlarmType_"+deptId+"_"+projectId+"_"+now;
Object obj=redisCache.getCacheObject(key);
if(obj!=null){
return success(obj);
}
DevAiProjectData devAiProjectData = new DevAiProjectData();
if(StringUtils.isNotEmpty(deptId)){
devAiProjectData.setDeptId(Convert.toLong(deptId));
}
if(StringUtils.isNotEmpty(projectId)){
devAiProjectData.setProjectId(Convert.toLong(projectId));
}
//查询当天数据
if(now!=null && "Y".equals(now)){
Map<String, Object> params = new HashMap<>();
params.put("date",new Date());
devAiProjectData.setParams(params);
}
List<Map<String, Object>> list = devAiProjectDataService.groupCountByAlarmType(devAiProjectData);
redisCache.setCacheObject(key, list, CACHE_TIME, TimeUnit.MINUTES);
return success(list);
}
}

20
yanzhu-admin/src/main/java/com/yanzhu/web/controller/system/SysDictTypeController.java
View File

@ -1,18 +1,5 @@
package com.yanzhu.web.controller.system;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.yanzhu.common.annotation.Log;
import com.yanzhu.common.core.controller.BaseController;
import com.yanzhu.common.core.domain.AjaxResult;
@ -21,6 +8,13 @@ import com.yanzhu.common.core.page.TableDataInfo;
import com.yanzhu.common.enums.BusinessType;
import com.yanzhu.common.utils.poi.ExcelUtil;
import com.yanzhu.system.service.ISysDictTypeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 数据字典信息

6
yanzhu-admin/src/main/resources/application-druid.yml
View File

@ -7,7 +7,7 @@ yanzhu:
# 版权年份
copyrightYear: 2023
# 文件路径 示例（ Windows配置D:/yanZhu/uploadPath，Linux配置 /home/yanZhu/uploadPath）
profile: D:/data/yanzhu
profile: D:/data/yanzhu_GZAI
# 获取ip地址开关
addressEnabled: false
# 验证码类型 math 数字计算 char 字符验证
@ -16,10 +16,10 @@ yanzhu:
# 开发环境配置
server:
# 服务器的HTTP端口，默认为8080
port: 8080
port: 8097
servlet:
# 应用的访问路径
context-path: /prjapi
context-path: /yanzhu-GZAI
tomcat:
# tomcat的URI编码
uri-encoding: UTF-8

6
yanzhu-admin/src/main/resources/application-prod.yml
View File

@ -7,7 +7,7 @@ yanZhu:
# 版权年份
copyrightYear: 2023
# 文件路径 示例（ Windows配置D:/yanZhu/uploadPath，Linux配置 /home/yanZhu/uploadPath）
profile: /data/yanzhu
profile: /data/yanzhu_GZAI
# 获取ip地址开关
addressEnabled: false
# 验证码类型 math 数字计算 char 字符验证
@ -16,10 +16,10 @@ yanZhu:
# 开发环境配置
server:
# 服务器的HTTP端口，默认为8080
port: 8080
port: 8097
servlet:
# 应用的访问路径
context-path: /
context-path: /yanzhu-GZAI
tomcat:
# tomcat的URI编码
uri-encoding: UTF-8

17
yanzhu-admin/src/main/resources/application.yml
View File

@ -1,8 +1,8 @@
# 日志配置
logging:
level:
com.yanzhu: debug
org.springframework: warn
com.yanzhu: error
org.springframework: error
# 用户配置
user:
@ -19,7 +19,7 @@ spring:
# 国际化资源文件路径
basename: i18n/messages
profiles:
active: druid
active: prod
# 文件上传
servlet:
multipart:
@ -69,13 +69,6 @@ xss:
# 过滤开关
enabled: true
# 排除链接（多个用逗号分隔）
excludes: /system/notice,/flowable/definition/save
excludes: /system/notice
# 匹配链接
urlPatterns: /*
# flowable相关表
flowable:
# true 会对数据库中所有表进行更新操作。如果表不存在，则自动创建(建议开发时使用)
database-schema-update: false
# 关闭定时任务JOB
async-executor-activate: false
urlPatterns: /*

2
yanzhu-admin/src/main/resources/logback.xml
View File

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<!-- 日志存放路径 -->
<property name="log.path" value="/Users/2y/zhj/logs" />
<property name="log.path" value="/usr/local/project/gzai/logs" />
<!-- 彩色日志 -->
<conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter"/>

6
yanzhu-common/pom.xml
View File

@ -131,6 +131,12 @@
<artifactId>javax.servlet-api</artifactId>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-core</artifactId>
<version>5.8.20</version>
</dependency>
</dependencies>
</project>

29
yanzhu-common/src/main/java/com/yanzhu/common/utils/file/FileUploadUtils.java
View File

@ -3,7 +3,11 @@ package com.yanzhu.common.utils.file;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Objects;
import cn.hutool.core.img.ImgUtil;
import cn.hutool.core.io.FileUtil;
import org.apache.commons.io.FilenameUtils;
import org.springframework.web.multipart.MultipartFile;
import com.yanzhu.common.config.YanZhuConfig;
@ -114,9 +118,34 @@ public class FileUploadUtils
String absPath = getAbsoluteFile(baseDir, fileName).getAbsolutePath();
file.transferTo(Paths.get(absPath));
makeMiniImage(absPath);
return getPathFileName(baseDir, fileName);
}
/**
* 图片压缩
* @param absPath
*/
private static void makeMiniImage(String absPath) {
try {
String ext = FileUtils.getFileExt(absPath).toLowerCase();
String exts = Arrays.toString(new String[]{"jpg", "jpeg", "png", "bmp"});
if (exts.contains(ext)) {
if (new File(absPath).exists()) {
int w = ImgUtil.read(FileUtil.file(absPath)).getWidth();
if(w>2000) {
ImgUtil.scale(FileUtil.file(absPath),
FileUtil.file(absPath), (float) (2000.0 / w));
}
ImgUtil.scale(FileUtil.file(absPath),
FileUtil.file(absPath + ".min.jpg"), (float) (300.0 / w));
}
}
}catch (Exception ex){
ex.printStackTrace();
}
}
/**
* 编码文件名
*/

9
yanzhu-common/src/main/java/com/yanzhu/common/utils/file/FileUtils.java
View File

@ -288,4 +288,13 @@ public class FileUtils
String baseName = FilenameUtils.getBaseName(fileName);
return baseName;
}
/**
* 文件类型判断
* @param fileName
* @return
*/
public static String getFileExt(String fileName){
return FilenameUtils.getExtension(fileName).toString();
}
}

96
yanzhu-flowable/pom.xml
View File

@ -1,96 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>yanzhu</artifactId>
<groupId>com.yanzhu</groupId>
<version>3.8.7</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>yanzhu-flowable</artifactId>
<dependencies>
<dependency>
<groupId>com.yanzhu</groupId>
<artifactId>yanzhu-framework</artifactId>
</dependency>
<dependency>
<groupId>com.yanzhu</groupId>
<artifactId>yanzhu-system</artifactId>
</dependency>
<dependency>
<groupId>com.yanzhu</groupId>
<artifactId>yanzhu-common</artifactId>
</dependency>
<!--常用工具类 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
<!-- JSON工具类 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
<!-- 阿里JSON解析器 -->
<dependency>
<groupId>com.alibaba.fastjson2</groupId>
<artifactId>fastjson2</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>io.swagger</groupId>
<artifactId>swagger-annotations</artifactId>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.flowable</groupId>
<artifactId>flowable-spring-boot-starter</artifactId>
<!-- 排除flowable自带的权限认证 -->
<exclusions>
<exclusion>
<groupId>org.flowable</groupId>
<artifactId>flowable-spring-security</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
</dependency>
<dependency>
<!-- websocket -->
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
<!--el表达式计算-->
<dependency>
<groupId>com.googlecode.aviator</groupId>
<artifactId>aviator</artifactId>
<version>5.3.3</version>
</dependency>
</dependencies>
<!-- <build>-->
<!-- <plugins>-->
<!-- <plugin>-->
<!-- <groupId>org.springframework.boot</groupId>-->
<!-- <artifactId>spring-boot-maven-plugin</artifactId>-->
<!-- </plugin>-->
<!-- </plugins>-->
<!-- </build>-->
</project>

80
yanzhu-flowable/src/main/java/com/yanzhu/flowable/common/constant/ProcessConstants.java
View File

@ -1,80 +0,0 @@
package com.yanzhu.flowable.common.constant;
/**
* 流程常量信息
*
* @author Tony
* @date 2021/4/17 22:46
*/
public class ProcessConstants {
/**
* 动态数据
*/
public static final String DYNAMIC = "dynamic";
/**
* 固定任务接收
*/
public static final String FIXED = "fixed";
/**
* 单个审批人
*/
public static final String ASSIGNEE = "assignee";
/**
* 候选人
*/
public static final String CANDIDATE_USERS = "candidateUsers";
/**
* 审批组
*/
public static final String CANDIDATE_GROUPS = "candidateGroups";
/**
* 单个审批人
*/
public static final String PROCESS_APPROVAL = "approval";
/**
* 会签人员
*/
public static final String PROCESS_MULTI_INSTANCE_USER = "userList";
/**
* nameapace
*/
public static final String NAMASPASE = "http://flowable.org/bpmn";
/**
* 会签节点
*/
public static final String PROCESS_MULTI_INSTANCE = "multiInstance";
/**
* 自定义属性 dataType
*/
public static final String PROCESS_CUSTOM_DATA_TYPE = "dataType";
/**
* 自定义属性 userType
*/
public static final String PROCESS_CUSTOM_USER_TYPE = "userType";
/**
* 初始化人员
*/
public static final String PROCESS_INITIATOR = "INITIATOR";
/**
* 流程跳过
*/
public static final String FLOWABLE_SKIP_EXPRESSION_ENABLED = "_FLOWABLE_SKIP_EXPRESSION_ENABLED";
}

43
yanzhu-flowable/src/main/java/com/yanzhu/flowable/common/enums/FlowComment.java
View File

@ -1,43 +0,0 @@
package com.yanzhu.flowable.common.enums;
/**
* 流程意见类型
*
* @author Tony
* @date 2021/4/19
*/
public enum FlowComment {
/**
* 说明
*/
NORMAL("1", "正常意见"),
REBACK("2", "退回意见"),
REJECT("3", "驳回意见"),
DELEGATE("4", "委派意见"),
ASSIGN("5", "转办意见"),
STOP("6", "终止流程"),
REVOKE("7", "撤回流程");
/**
* 类型
*/
private final String type;
/**
* 说明
*/
private final String remark;
FlowComment(String type, String remark) {
this.type = type;
this.remark = remark;
}
public String getType() {
return type;
}
public String getRemark() {
return remark;
}
}

32
yanzhu-flowable/src/main/java/com/yanzhu/flowable/config/FlowableConfig.java
View File

@ -1,32 +0,0 @@
package com.yanzhu.flowable.config;
import org.flowable.engine.impl.db.DbIdGenerator;
import org.flowable.spring.SpringProcessEngineConfiguration;
import org.flowable.spring.boot.EngineConfigurationConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.AsyncListenableTaskExecutor;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
/**
* 流程id生成处理
* @author Tony
* @date 2022-12-26 10:24
*/
@Configuration
public class FlowableConfig implements EngineConfigurationConfigurer<SpringProcessEngineConfiguration> {
@Bean
public AsyncListenableTaskExecutor applicationTaskExecutor() {
return new SimpleAsyncTaskExecutor();
}
@Override
public void configure(SpringProcessEngineConfiguration engineConfiguration) {
engineConfiguration.setActivityFontName("宋体");
engineConfiguration.setLabelFontName("宋体");
engineConfiguration.setAnnotationFontName("宋体");
engineConfiguration.setIdGenerator(new DbIdGenerator());
}
}

95
yanzhu-flowable/src/main/java/com/yanzhu/flowable/config/MyDefaultProcessDiagramCanvas.java
View File

@ -1,95 +0,0 @@
//package com.yanzhu.flowable.config;
//
//import com.sun.prism.paint.Color;
//import org.flowable.bpmn.model.AssociationDirection;
//import org.flowable.image.impl.DefaultProcessDiagramCanvas;
//
//import java.awt.*;
//import java.awt.geom.Line2D;
//import java.awt.geom.RoundRectangle2D;
//
///**
// * @author Tony
// * @date 2021-04-03
// */
//public class MyDefaultProcessDiagramCanvas extends DefaultProcessDiagramCanvas {
// //设置高亮线的颜色 这里我设置成绿色
// protected static Color HIGHLIGHT_SEQUENCEFLOW_COLOR = Color.GREEN;
//
// public MyDefaultProcessDiagramCanvas(int width, int height, int minX, int minY, String imageType, String activityFontName, String labelFontName, String annotationFontName, ClassLoader customClassLoader) {
// super(width, height, minX, minY, imageType, activityFontName, labelFontName, annotationFontName, customClassLoader);
// }
//
// public MyDefaultProcessDiagramCanvas(int width, int height, int minX, int minY, String imageType) {
// super(width, height, minX, minY, imageType);
// }
//
//
// /**
// * 画线颜色设置
// */
// @Override
// public void drawConnection(int[] xPoints, int[] yPoints, boolean conditional, boolean isDefault, String connectionType,
// AssociationDirection associationDirection, boolean highLighted, double scaleFactor) {
//
// Paint originalPaint = g.getPaint();
// Stroke originalStroke = g.getStroke();
//
// g.setPaint(CONNECTION_COLOR);
// if (connectionType.equals("association")) {
// g.setStroke(ASSOCIATION_STROKE);
// } else if (highLighted) {
// //设置线的颜色
// g.setPaint(originalPaint);
// g.setStroke(HIGHLIGHT_FLOW_STROKE);
// }
//
// for (int i = 1; i < xPoints.length; i++) {
// Integer sourceX = xPoints[i - 1];
// Integer sourceY = yPoints[i - 1];
// Integer targetX = xPoints[i];
// Integer targetY = yPoints[i];
// Line2D.Double line = new Line2D.Double(sourceX, sourceY, targetX, targetY);
// g.draw(line);
// }
//
// if (isDefault) {
// Line2D.Double line = new Line2D.Double(xPoints[0], yPoints[0], xPoints[1], yPoints[1]);
// drawDefaultSequenceFlowIndicator(line, scaleFactor);
// }
//
// if (conditional) {
// Line2D.Double line = new Line2D.Double(xPoints[0], yPoints[0], xPoints[1], yPoints[1]);
// drawConditionalSequenceFlowIndicator(line, scaleFactor);
// }
//
// if (associationDirection == AssociationDirection.ONE || associationDirection == AssociationDirection.BOTH) {
// Line2D.Double line = new Line2D.Double(xPoints[xPoints.length - 2], yPoints[xPoints.length - 2], xPoints[xPoints.length - 1], yPoints[xPoints.length - 1]);
// drawArrowHead(line, scaleFactor);
// }
// if (associationDirection == AssociationDirection.BOTH) {
// Line2D.Double line = new Line2D.Double(xPoints[1], yPoints[1], xPoints[0], yPoints[0]);
// drawArrowHead(line, scaleFactor);
// }
// g.setPaint(originalPaint);
// g.setStroke(originalStroke);
// }
//
// /**
// * 高亮节点设置
// */
// @Override
// public void drawHighLight(int x, int y, int width, int height) {
// Paint originalPaint = g.getPaint();
// Stroke originalStroke = g.getStroke();
// //设置高亮节点的颜色
// g.setPaint(HIGHLIGHT_COLOR);
// g.setStroke(THICK_TASK_BORDER_STROKE);
//
// RoundRectangle2D rect = new RoundRectangle2D.Double(x, y, width, height, 20, 20);
// g.draw(rect);
//
// g.setPaint(originalPaint);
// g.setStroke(originalStroke);
// }
//}

147
yanzhu-flowable/src/main/java/com/yanzhu/flowable/controller/FlowBusinessKeyController.java
View File

@ -1,147 +0,0 @@
package com.yanzhu.flowable.controller;
import com.yanzhu.common.core.controller.BaseController;
import com.yanzhu.common.core.domain.AjaxResult;
import com.yanzhu.common.core.domain.entity.SysUser;
import com.yanzhu.common.core.page.TableDataInfo;
import com.yanzhu.flowable.service.IFlowBusinessKeyService;
import com.yanzhu.system.domain.flowable.FlowTaskEntity;
import com.yanzhu.system.service.ISysDeptService;
import io.swagger.annotations.Api;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* <p>
* 业务工作流程
* </p>
*
* @author JiangYuQi
* @date 2024-04-03
*/
@Slf4j
@Api(tags = "业务工作流程")
@RestController
@RequestMapping("/flowable/businessKey")
public class FlowBusinessKeyController extends BaseController {
@Autowired
private ISysDeptService sysDeptService;
@Autowired
private IFlowBusinessKeyService flowBusinessKeyService;
/**
* 根据条件查询所有流任务
* @param flowTaskEntity
* @return
*/
@GetMapping(value = "/allList")
public TableDataInfo allList(FlowTaskEntity flowTaskEntity) {
startPage();
//超管查询所有数据
if(!SysUser.isAdmin(super.getUserId())){
flowTaskEntity.setDeptAncestors(super.getLoginUser().getUser().getDept().getAncestors());
}
return getDataTable(flowBusinessKeyService.selectAllFlowTaskByParams(flowTaskEntity));
}
/**
* 根据条件统计所有流任务
* @param flowTaskEntity
* @return
*/
@GetMapping(value = "/queryCount")
public AjaxResult queryCount(FlowTaskEntity flowTaskEntity) {
//超管查询所有数据
if(!SysUser.isAdmin(super.getUserId())){
flowTaskEntity.setDeptAncestors(super.getLoginUser().getUser().getDept().getAncestors());
}
return success(flowBusinessKeyService.quueryCount(flowTaskEntity));
}
/**
* 根据流程Id查询操作日志
* @param procInsId
* @return
*/
@GetMapping(value = "/findCommentByProcInsId")
public AjaxResult findCommentByProcInsId(String procInsId) {
return success(flowBusinessKeyService.selectCommentByProcInsId(procInsId));
}
/**
* 根据流程Id查询表单数据
* @param procInsId
* @return
*/
@GetMapping(value = "/findFormDatasByProcInsId")
public AjaxResult findFormDatasByProcInsId(String procInsId) {
return success(flowBusinessKeyService.selectFormDatasByProcInsId(procInsId));
}
/**
* 根据条件查询我的代办任务
* @param flowTaskEntity
* @return
*/
@GetMapping(value = "/myAwaitFlowTaskList")
public TableDataInfo myAwaitFlowTaskList(FlowTaskEntity flowTaskEntity) {
startPage();
//超管查询所有数据
if(!SysUser.isAdmin(super.getUserId())){
SysUser sysUser = super.getLoginUser().getUser();
flowTaskEntity.setAssigneeId(sysUser.getUserId());
flowTaskEntity.setDeptAncestors(sysUser.getDept().getAncestors()+","+sysUser.getDeptId());
flowTaskEntity.setRoleIds(sysUser.getRoles().stream().map(role -> role.getRoleId()).collect(Collectors.toList()));
}
return getDataTable(flowBusinessKeyService.selectMyAwaitFlowTask(flowTaskEntity));
}
/**
* 根据条件查询我的已办任务
* @param flowTaskEntity
* @return
*/
@GetMapping(value = "/myFinishedFlowTaskList")
public TableDataInfo myFinishedFlowTaskList(FlowTaskEntity flowTaskEntity) {
startPage();
flowTaskEntity.setAssigneeId(super.getUserId());
return getDataTable(flowBusinessKeyService.selectMyFinishedFlowTask(flowTaskEntity));
}
/**
* 查询我的代办任务数量
* @return AjaxResult 统计结果
*/
@GetMapping(value = "/findMyTask")
public AjaxResult findMyTask() {
FlowTaskEntity flowTaskEntity = new FlowTaskEntity();
//超管查询所有数据
if(!SysUser.isAdmin(super.getUserId())){
SysUser sysUser = super.getLoginUser().getUser();
flowTaskEntity.setAssigneeId(sysUser.getUserId());
flowTaskEntity.setDeptAncestors(sysUser.getDept().getAncestors()+","+sysUser.getDeptId());
flowTaskEntity.setRoleIds(sysUser.getRoles().stream().map(role -> role.getRoleId()).collect(Collectors.toList()));
}
List<Map<String, Object>> list = flowBusinessKeyService.selectMyAwaitFlowTask(flowTaskEntity);
Map<String,Object> data = new HashMap<>();
if(CollectionUtils.isNotEmpty(list)){
data.put("todo",list.size());
}else{
data.put("todo",0);
}
return success(data);
}
}

211
yanzhu-flowable/src/main/java/com/yanzhu/flowable/controller/FlowDefinitionController.java
View File

@ -1,211 +0,0 @@
package com.yanzhu.flowable.controller;
import com.yanzhu.common.annotation.Log;
import com.yanzhu.common.core.controller.BaseController;
import com.yanzhu.common.core.domain.AjaxResult;
import com.yanzhu.common.core.domain.entity.SysRole;
import com.yanzhu.common.core.domain.entity.SysUser;
import com.yanzhu.common.core.text.Convert;
import com.yanzhu.common.enums.BusinessType;
import com.yanzhu.flowable.domain.FlowSaveXmlVo;
import com.yanzhu.system.domain.flowable.FlowQueryVo;
import com.yanzhu.flowable.service.IFlowDefinitionService;
import com.yanzhu.system.domain.FlowProcDefDto;
import com.yanzhu.system.domain.SysExpression;
import com.yanzhu.system.service.ISysExpressionService;
import com.yanzhu.system.service.ISysRoleService;
import com.yanzhu.system.service.ISysUserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletResponse;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
/**
* <p>
* 工作流程定义
* </p>
*
* @author Tony
* @date 2021-04-03
*/
@Slf4j
@Api(tags = "流程定义")
@RestController
@RequestMapping("/flowable/definition")
public class FlowDefinitionController extends BaseController {
@Autowired
private IFlowDefinitionService flowDefinitionService;
@Autowired
private ISysUserService userService;
@Resource
private ISysRoleService sysRoleService;
@Resource
private ISysExpressionService sysExpressionService;
/**
* 流程定义列表
*
* @param flowQueryVo 流程查询
* @return 流程定义分页列表数据
*/
@GetMapping(value = "/list")
@ApiOperation(value = "流程定义列表", response = FlowProcDefDto.class)
public AjaxResult list(FlowQueryVo flowQueryVo) {
if(!SysUser.isAdmin(super.getUserId())){
flowQueryVo.setDeptId(Convert.toLong(super.getLoginUser().getUser().getDept().getAncestors().split(",")[2]));
}
return AjaxResult.success(flowDefinitionService.list(flowQueryVo));
}
@ApiOperation(value = "导入流程文件", notes = "上传bpmn20的xml文件")
@Log(title = "导入流程文件", businessType = BusinessType.INSERT)
@PostMapping("/import")
public AjaxResult importFile(@RequestParam(required = false) String name,
@RequestParam(required = false) String category,
MultipartFile file) {
InputStream in = null;
try {
in = file.getInputStream();
flowDefinitionService.importFile(name, category, null , in);
} catch (Exception e) {
log.error("导入失败:", e);
return AjaxResult.success(e.getMessage());
} finally {
try {
if (in != null) {
in.close();
}
} catch (IOException e) {
log.error("关闭输入流出错", e);
}
}
return AjaxResult.success("导入成功");
}
@ApiOperation(value = "读取xml文件")
@GetMapping("/readXml/{deployId}")
public AjaxResult readXml(@ApiParam(value = "流程定义id") @PathVariable(value = "deployId") String deployId) {
try {
return flowDefinitionService.readXml(deployId);
} catch (Exception e) {
return AjaxResult.error("加载xml文件异常");
}
}
@ApiOperation(value = "读取图片文件")
@GetMapping("/readImage/{deployId}")
public void readImage(@ApiParam(value = "流程定义id") @PathVariable(value = "deployId") String deployId, HttpServletResponse response) {
OutputStream os = null;
BufferedImage image = null;
try {
image = ImageIO.read(flowDefinitionService.readImage(deployId));
response.setContentType("image/png");
os = response.getOutputStream();
if (image != null) {
ImageIO.write(image, "png", os);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (os != null) {
os.flush();
os.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
@ApiOperation(value = "保存流程设计器内的xml文件")
@Log(title = "保存流程设计", businessType = BusinessType.INSERT)
@PostMapping("/save")
public AjaxResult save(@RequestBody FlowSaveXmlVo vo) {
InputStream in = null;
try {
in = new ByteArrayInputStream(vo.getXml().getBytes(StandardCharsets.UTF_8));
flowDefinitionService.importFile(vo.getName(), vo.getCategory(), vo.getOwnerDeptId(), in);
} catch (Exception e) {
log.error("导入失败:", e);
return AjaxResult.error(e.getMessage());
} finally {
try {
if (in != null) {
in.close();
}
} catch (IOException e) {
log.error("关闭输入流出错", e);
}
}
return AjaxResult.success("导入成功");
}
@ApiOperation(value = "发起流程")
@Log(title = "发起流程申请", businessType = BusinessType.INSERT)
@PostMapping("/start/{procDefId}")
public AjaxResult start(@ApiParam(value = "流程定义id") @PathVariable(value = "procDefId") String procDefId) {
return flowDefinitionService.startProcessInstanceById(procDefId);
}
@ApiOperation(value = "激活或挂起流程定义")
@Log(title = "激活/挂起流程", businessType = BusinessType.UPDATE)
@PutMapping(value = "/updateState")
public AjaxResult updateState(@ApiParam(value = "1:激活,2:挂起", required = true) @RequestParam Integer state,
@ApiParam(value = "流程部署ID", required = true) @RequestParam String deployId) {
flowDefinitionService.updateState(state, deployId);
return AjaxResult.success();
}
@ApiOperation(value = "删除流程")
@Log(title = "删除流程定义", businessType = BusinessType.UPDATE)
@DeleteMapping(value = "/{deployIds}")
public AjaxResult delete(@PathVariable String[] deployIds) {
for (String deployId : deployIds) {
flowDefinitionService.delete(deployId);
}
return AjaxResult.success();
}
@ApiOperation(value = "指定流程办理人员列表")
@GetMapping("/userList")
public AjaxResult userList(SysUser user) {
List<SysUser> list = userService.selectUserList(user);
return AjaxResult.success(list);
}
@ApiOperation(value = "指定流程办理组列表")
@GetMapping("/roleList")
public AjaxResult roleList(SysRole role) {
List<SysRole> list = sysRoleService.selectRoleList(role);
return AjaxResult.success(list);
}
@ApiOperation(value = "指定流程达式列表")
@GetMapping("/expList")
public AjaxResult expList(SysExpression sysExpression) {
List<SysExpression> list = sysExpressionService.selectSysExpressionList(sysExpression);
return AjaxResult.success(list);
}
}

64
yanzhu-flowable/src/main/java/com/yanzhu/flowable/controller/FlowInstanceController.java
View File

@ -1,64 +0,0 @@
package com.yanzhu.flowable.controller;
import com.yanzhu.common.core.domain.AjaxResult;
import com.yanzhu.flowable.domain.FlowTaskVo;
import com.yanzhu.flowable.service.IFlowInstanceService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
/**
* <p>工作流流程实例管理<p>
*
* @author Tony
* @date 2021-04-03
*/
@Slf4j
@Api(tags = "工作流流程实例管理")
@RestController
@RequestMapping("/flowable/instance")
public class FlowInstanceController {
@Autowired
private IFlowInstanceService flowInstanceService;
@ApiOperation(value = "根据流程定义id启动流程实例")
@PostMapping("/startBy/{procDefId}")
public AjaxResult startById(@ApiParam(value = "流程定义id") @PathVariable(value = "procDefId") String procDefId,
@ApiParam(value = "变量集合,json对象") @RequestBody Map<String, Object> variables) {
return flowInstanceService.startProcessInstanceById(procDefId, variables);
}
@ApiOperation(value = "激活或挂起流程实例")
@PostMapping(value = "/updateState")
public AjaxResult updateState(@ApiParam(value = "1:激活,2:挂起", required = true) @RequestParam Integer state,
@ApiParam(value = "流程实例ID", required = true) @RequestParam String instanceId) {
flowInstanceService.updateState(state,instanceId);
return AjaxResult.success();
}
@ApiOperation("结束流程实例")
@PostMapping(value = "/stopProcessInstance")
public AjaxResult stopProcessInstance(@RequestBody FlowTaskVo flowTaskVo) {
flowInstanceService.stopProcessInstance(flowTaskVo);
return AjaxResult.success();
}
@ApiOperation(value = "删除流程实例")
@DeleteMapping(value = "/delete/{instanceIds}")
public AjaxResult delete(@ApiParam(value = "流程实例ID", required = true) @PathVariable String[] instanceIds,
@ApiParam(value = "删除原因") @RequestParam(required = false) String deleteReason) {
for (String instanceId : instanceIds) {
flowInstanceService.delete(instanceId,deleteReason);
}
return AjaxResult.success();
}
}

268
yanzhu-flowable/src/main/java/com/yanzhu/flowable/controller/FlowTaskController.java
View File

@ -1,268 +0,0 @@
package com.yanzhu.flowable.controller;
import com.yanzhu.common.annotation.Log;
import com.yanzhu.common.core.domain.AjaxResult;
import com.yanzhu.common.enums.BusinessType;
import com.yanzhu.flowable.domain.FlowTaskDto;
import com.yanzhu.system.domain.flowable.FlowQueryVo;
import com.yanzhu.flowable.domain.FlowTaskVo;
import com.yanzhu.flowable.service.IFlowTaskService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletResponse;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* <p>工作流任务管理<p>
*
* @author Tony
* @date 2021-04-03
*/
@Slf4j
@Api(tags = "工作流流程任务管理")
@RestController
@RequestMapping("/flowable/task")
public class FlowTaskController {
@Autowired
private IFlowTaskService flowTaskService;
@ApiOperation(value = "我发起的流程", response = FlowTaskDto.class)
@GetMapping(value = "/myProcess")
public AjaxResult myProcess(FlowQueryVo queryVo) {
return flowTaskService.myProcess(queryVo);
}
@ApiOperation(value = "取消申请", response = FlowTaskDto.class)
@Log(title = "终止申请", businessType = BusinessType.UPDATE)
@PostMapping(value = "/stopProcess")
public AjaxResult stopProcess(@RequestBody FlowTaskVo flowTaskVo) {
return flowTaskService.stopProcess(flowTaskVo);
}
@ApiOperation(value = "撤回流程", response = FlowTaskDto.class)
@Log(title = "撤回流程", businessType = BusinessType.UPDATE)
@PostMapping(value = "/revokeProcess")
public AjaxResult revokeProcess(@RequestBody FlowTaskVo flowTaskVo) {
return flowTaskService.revokeProcess(flowTaskVo);
}
@ApiOperation(value = "获取待办列表", response = FlowTaskDto.class)
@GetMapping(value = "/todoList")
public AjaxResult todoList(FlowQueryVo queryVo) {
return flowTaskService.todoList(queryVo);
}
@ApiOperation(value = "获取已办任务", response = FlowTaskDto.class)
@GetMapping(value = "/finishedList")
public AjaxResult finishedList(FlowQueryVo queryVo) {
return flowTaskService.finishedList(queryVo);
}
@ApiOperation(value = "流程历史流转记录", response = FlowTaskDto.class)
@GetMapping(value = "/flowRecord")
public AjaxResult flowRecord(String procInsId, String deployId) {
return flowTaskService.flowRecord(procInsId, deployId);
}
@ApiOperation(value = "流程初始化表单", response = FlowTaskDto.class)
@GetMapping(value = "/flowFormData")
public AjaxResult flowFormData(String deployId) {
return flowTaskService.flowFormData(deployId);
}
@ApiOperation(value = "获取流程变量", response = FlowTaskDto.class)
@GetMapping(value = "/processVariables/{taskId}")
public AjaxResult processVariables(@ApiParam(value = "流程任务Id") @PathVariable(value = "taskId") String taskId) {
return flowTaskService.processVariables(taskId);
}
@ApiOperation(value = "审批任务")
@Log(title = "审批流程", businessType = BusinessType.UPDATE)
@PostMapping(value = "/complete")
public AjaxResult complete(@RequestBody FlowTaskVo flowTaskVo) {
return flowTaskService.complete(flowTaskVo);
}
@ApiOperation(value = "重新提交流程")
@Log(title = "重新提交流程", businessType = BusinessType.UPDATE)
@PostMapping(value = "/completeAndModify")
public AjaxResult completeAndModify(@RequestBody FlowTaskVo flowTaskVo) {
return flowTaskService.complete(flowTaskVo);
}
@ApiOperation(value = "驳回任务")
@Log(title = "驳回流程", businessType = BusinessType.UPDATE)
@PostMapping(value = "/reject")
public AjaxResult taskReject(@RequestBody FlowTaskVo flowTaskVo) {
flowTaskService.taskReject(flowTaskVo);
return AjaxResult.success();
}
@ApiOperation(value = "退回任务")
@Log(title = "退回流程", businessType = BusinessType.UPDATE)
@PostMapping(value = "/return")
public AjaxResult taskReturn(@RequestBody FlowTaskVo flowTaskVo) {
flowTaskService.taskReturn(flowTaskVo);
return AjaxResult.success();
}
@ApiOperation(value = "获取所有可回退的节点")
@PostMapping(value = "/returnList")
public AjaxResult findReturnTaskList(@RequestBody FlowTaskVo flowTaskVo) {
return flowTaskService.findReturnTaskList(flowTaskVo);
}
@ApiOperation(value = "删除任务")
@Log(title = "删除流程", businessType = BusinessType.DELETE)
@DeleteMapping(value = "/delete")
public AjaxResult delete(@RequestBody FlowTaskVo flowTaskVo) {
flowTaskService.deleteTask(flowTaskVo);
return AjaxResult.success();
}
@ApiOperation(value = "认领/签收任务")
@Log(title = "认领/签收流程", businessType = BusinessType.INSERT)
@PostMapping(value = "/claim")
public AjaxResult claim(@RequestBody FlowTaskVo flowTaskVo) {
flowTaskService.claim(flowTaskVo);
return AjaxResult.success();
}
@ApiOperation(value = "取消认领/签收任务")
@Log(title = "取消认领/签收流程", businessType = BusinessType.UPDATE)
@PostMapping(value = "/unClaim")
public AjaxResult unClaim(@RequestBody FlowTaskVo flowTaskVo) {
flowTaskService.unClaim(flowTaskVo);
return AjaxResult.success();
}
@ApiOperation(value = "委派任务")
@Log(title = "委派流程", businessType = BusinessType.UPDATE)
@PostMapping(value = "/delegateTask")
public AjaxResult delegate(@RequestBody FlowTaskVo flowTaskVo) {
flowTaskService.delegateTask(flowTaskVo);
return AjaxResult.success();
}
@ApiOperation(value = "任务归还")
@Log(title = "归还流程", businessType = BusinessType.UPDATE)
@PostMapping(value = "/resolveTask")
public AjaxResult resolveTask(@RequestBody FlowTaskVo flowTaskVo) {
flowTaskService.resolveTask(flowTaskVo);
return AjaxResult.success();
}
@ApiOperation(value = "转办任务")
@Log(title = "转办流程", businessType = BusinessType.UPDATE)
@PostMapping(value = "/assignTask")
public AjaxResult assign(@RequestBody FlowTaskVo flowTaskVo) {
flowTaskService.assignTask(flowTaskVo);
return AjaxResult.success();
}
@PostMapping(value = "/addMultiInstanceExecution")
@ApiOperation(value = "多实例加签")
public AjaxResult addMultiInstanceExecution(@RequestBody FlowTaskVo flowTaskVo) {
flowTaskService.addMultiInstanceExecution(flowTaskVo);
return AjaxResult.success("加签成功");
}
@PostMapping(value = "/deleteMultiInstanceExecution")
@ApiOperation(value = "多实例减签")
public AjaxResult deleteMultiInstanceExecution(@RequestBody FlowTaskVo flowTaskVo) {
flowTaskService.deleteMultiInstanceExecution(flowTaskVo);
return AjaxResult.success("减签成功");
}
@ApiOperation(value = "获取下一节点")
@PostMapping(value = "/nextFlowNode")
public AjaxResult getNextFlowNode(@RequestBody FlowTaskVo flowTaskVo) {
return flowTaskService.getNextFlowNode(flowTaskVo);
}
@ApiOperation(value = "流程发起时获取下一节点")
@PostMapping(value = "/nextFlowNodeByStart")
public AjaxResult getNextFlowNodeByStart(@RequestBody FlowTaskVo flowTaskVo) {
return flowTaskService.getNextFlowNodeByStart(flowTaskVo);
}
/**
* 生成流程图
*
* @param processId 任务ID
*/
@GetMapping("/diagram/{processId}")
public void genProcessDiagram(HttpServletResponse response,
@PathVariable("processId") String processId) {
InputStream inputStream = flowTaskService.diagram(processId);
OutputStream os = null;
BufferedImage image = null;
try {
image = ImageIO.read(inputStream);
response.setContentType("image/png");
os = response.getOutputStream();
if (image != null) {
ImageIO.write(image, "png", os);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (os != null) {
os.flush();
os.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 获取流程执行节点
*
* @param procInsId 流程实例编号
* @param procInsId 任务执行编号
*/
@GetMapping("/flowViewer/{procInsId}/{executionId}")
public AjaxResult getFlowViewer(@PathVariable("procInsId") String procInsId,
@PathVariable("executionId") String executionId) {
return flowTaskService.getFlowViewer(procInsId, executionId);
}
/**
* 流程节点信息
*
* @param procInsId 流程实例id
* @return
*/
@GetMapping("/flowXmlAndNode")
public AjaxResult flowXmlAndNode(@RequestParam(value = "procInsId", required = false) String procInsId,
@RequestParam(value = "deployId", required = false) String deployId) {
return flowTaskService.flowXmlAndNode(procInsId, deployId);
}
/**
* 流程节点表单
*
* @param taskId 流程任务编号
* @return
*/
@GetMapping("/flowTaskForm")
public AjaxResult flowTaskForm(@RequestParam(value = "taskId", required = false) String taskId) throws Exception {
return flowTaskService.flowTaskForm(taskId);
}
}

117
yanzhu-flowable/src/main/java/com/yanzhu/flowable/controller/SysFormController.java
View File

@ -1,117 +0,0 @@
package com.yanzhu.flowable.controller;
import java.util.List;
import com.yanzhu.flowable.service.ISysDeployFormService;
import com.yanzhu.system.domain.SysDeployForm;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.yanzhu.common.annotation.Log;
import com.yanzhu.common.core.controller.BaseController;
import com.yanzhu.common.core.domain.AjaxResult;
import com.yanzhu.common.enums.BusinessType;
import com.yanzhu.system.domain.SysForm;
import com.yanzhu.flowable.service.ISysFormService;
import com.yanzhu.common.utils.poi.ExcelUtil;
import com.yanzhu.common.core.page.TableDataInfo;
/**
* 流程表单Controller
*
* @author Tony
* @date 2021-04-03
*/
@RestController
@RequestMapping("/flowable/form")
public class SysFormController extends BaseController {
@Autowired
private ISysFormService SysFormService;
@Autowired
private ISysDeployFormService sysDeployFormService;
/**
* 查询流程表单列表
*/
@PreAuthorize("@ss.hasPermi('flowable:form:list')")
@GetMapping("/list")
public TableDataInfo list(SysForm sysForm) {
startPage();
List<SysForm> list = SysFormService.selectSysFormList(sysForm);
return getDataTable(list);
}
@GetMapping("/formList")
public AjaxResult formList(SysForm sysForm) {
List<SysForm> list = SysFormService.selectSysFormList(sysForm);
return AjaxResult.success(list);
}
/**
* 导出流程表单列表
*/
@PreAuthorize("@ss.hasPermi('flowable:form:export')")
@Log(title = "流程表单", businessType = BusinessType.EXPORT)
@GetMapping("/export")
public AjaxResult export(SysForm sysForm) {
List<SysForm> list = SysFormService.selectSysFormList(sysForm);
ExcelUtil<SysForm> util = new ExcelUtil<SysForm>(SysForm.class);
return util.exportExcel(list, "form");
}
/**
* 获取流程表单详细信息
*/
@PreAuthorize("@ss.hasPermi('flowable:form:query')")
@GetMapping(value = "/{formId}")
public AjaxResult getInfo(@PathVariable("formId") Long formId) {
return AjaxResult.success(SysFormService.selectSysFormById(formId));
}
/**
* 新增流程表单
*/
@PreAuthorize("@ss.hasPermi('flowable:form:add')")
@Log(title = "流程表单", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody SysForm sysForm) {
return toAjax(SysFormService.insertSysForm(sysForm));
}
/**
* 修改流程表单
*/
@PreAuthorize("@ss.hasPermi('flowable:form:edit')")
@Log(title = "流程表单", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody SysForm sysForm) {
return toAjax(SysFormService.updateSysForm(sysForm));
}
/**
* 删除流程表单
*/
@PreAuthorize("@ss.hasPermi('flowable:form:remove')")
@Log(title = "流程表单", businessType = BusinessType.DELETE)
@DeleteMapping("/{formIds}")
public AjaxResult remove(@PathVariable Long[] formIds) {
return toAjax(SysFormService.deleteSysFormByIds(formIds));
}
/**
* 挂载流程表单
*/
@Log(title = "流程表单", businessType = BusinessType.INSERT)
@PostMapping("/addDeployForm")
public AjaxResult addDeployForm(@RequestBody SysDeployForm sysDeployForm) {
return toAjax(sysDeployFormService.insertSysDeployForm(sysDeployForm));
}
}

25
yanzhu-flowable/src/main/java/com/yanzhu/flowable/domain/FlowCommentDto.java
View File

@ -1,25 +0,0 @@
package com.yanzhu.flowable.domain;
import lombok.Builder;
import lombok.Data;
import java.io.Serializable;
/**
* @author Tony
* @date 2021/3/28 15:50
*/
@Data
@Builder
public class FlowCommentDto implements Serializable {
/**
* 意见类别 0 正常意见 1 退回意见 2 驳回意见
*/
private String type;
/**
* 意见内容
*/
private String comment;
}

15
yanzhu-flowable/src/main/java/com/yanzhu/flowable/domain/FlowFromFieldDTO.java
View File

@ -1,15 +0,0 @@
package com.yanzhu.flowable.domain;
import lombok.Data;
import java.io.Serializable;
/**
* @author Tony
* @date 2021/3/31 23:20
*/
@Data
public class FlowFromFieldDTO implements Serializable {
private Object fields;
}

19
yanzhu-flowable/src/main/java/com/yanzhu/flowable/domain/FlowNextDto.java
View File

@ -1,19 +0,0 @@
package com.yanzhu.flowable.domain;
import lombok.Data;
import java.io.Serializable;
/**
* 动态人员、组
* @author Tony
* @date 2021/4/17 22:59
*/
@Data
public class FlowNextDto implements Serializable {
private String type;
private String dataType;
private String vars;
}

33
yanzhu-flowable/src/main/java/com/yanzhu/flowable/domain/FlowSaveXmlVo.java
View File

@ -1,33 +0,0 @@
package com.yanzhu.flowable.domain;
import lombok.Data;
import java.io.Serializable;
/**
* @author Tony
* @date 2021/3/28 19:48
*/
@Data
public class FlowSaveXmlVo implements Serializable {
/**
* 流程名称
*/
private String name;
/**
* 流程分类
*/
private String category;
/**
* 流程单位
*/
private String ownerDeptId;
/**
* xml 文件
*/
private String xml;
}

103
yanzhu-flowable/src/main/java/com/yanzhu/flowable/domain/FlowTaskDto.java
View File

@ -1,103 +0,0 @@
package com.yanzhu.flowable.domain;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;
import java.io.Serializable;
import java.util.Date;
/**
* <p>工作流任务<p>
*
* @author Tony
* @date 2021-04-03
*/
@Getter
@Setter
@ApiModel("工作流任务相关-返回参数")
public class FlowTaskDto implements Serializable {
@ApiModelProperty("任务编号")
private String taskId;
@ApiModelProperty("任务执行编号")
private String executionId;
@ApiModelProperty("任务名称")
private String taskName;
@ApiModelProperty("任务Key")
private String taskDefKey;
@ApiModelProperty("任务执行人Id")
private Long assigneeId;
@ApiModelProperty("部门名称")
private String deptName;
@ApiModelProperty("流程发起人部门名称")
private String startDeptName;
@ApiModelProperty("任务执行人名称")
private String assigneeName;
@ApiModelProperty("任务执行人部门")
private String assigneeDeptName;;
@ApiModelProperty("流程发起人Id")
private String startUserId;
@ApiModelProperty("流程发起人名称")
private String startUserName;
@ApiModelProperty("流程类型")
private String category;
@ApiModelProperty("流程变量信息")
private Object procVars;
@ApiModelProperty("局部变量信息")
private Object taskLocalVars;
@ApiModelProperty("流程部署编号")
private String deployId;
@ApiModelProperty("流程ID")
private String procDefId;
@ApiModelProperty("流程key")
private String procDefKey;
@ApiModelProperty("流程定义名称")
private String procDefName;
@ApiModelProperty("流程定义内置使用版本")
private int procDefVersion;
@ApiModelProperty("流程实例ID")
private String procInsId;
@ApiModelProperty("历史流程实例ID")
private String hisProcInsId;
@ApiModelProperty("任务耗时")
private String duration;
@ApiModelProperty("任务意见")
private FlowCommentDto comment;
@ApiModelProperty("候选执行人")
private String candidate;
@ApiModelProperty("任务创建时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
@ApiModelProperty("任务完成时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date finishTime;
}

56
yanzhu-flowable/src/main/java/com/yanzhu/flowable/domain/FlowTaskVo.java
View File

@ -1,56 +0,0 @@
package com.yanzhu.flowable.domain;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.List;
import java.util.Map;
/**
* <p>流程任务<p>
*
* @author Tony
* @date 2021-04-03
*/
@Data
@ApiModel("工作流任务相关--请求参数")
public class FlowTaskVo {
@ApiModelProperty("任务Id")
private String taskId;
@ApiModelProperty("用户Id")
private String userId;
@ApiModelProperty("任务意见")
private String comment;
@ApiModelProperty("流程实例Id")
private String instanceId;
@ApiModelProperty("节点")
private String targetKey;
private String deploymentId;
@ApiModelProperty("流程环节定义ID")
private String defId;
@ApiModelProperty("子执行流ID")
private String currentChildExecutionId;
@ApiModelProperty("子执行流是否已执行")
private Boolean flag;
@ApiModelProperty("流程变量信息")
private Map<String, Object> variables;
@ApiModelProperty("审批人")
private String assignee;
@ApiModelProperty("候选人")
private List<String> candidateUsers;
@ApiModelProperty("审批组")
private List<String> candidateGroups;
}

23
yanzhu-flowable/src/main/java/com/yanzhu/flowable/domain/FlowViewerDto.java
View File

@ -1,23 +0,0 @@
package com.yanzhu.flowable.domain;
import lombok.Data;
import java.io.Serializable;
/**
* @author Tony
* @date 2021/4/21 20:55
*/
@Data
public class FlowViewerDto implements Serializable {
/**
* 流程key
*/
private String key;
/**
* 是否完成(已经审批)
*/
private boolean completed;
}

41
yanzhu-flowable/src/main/java/com/yanzhu/flowable/factory/FlowServiceFactory.java
View File

@ -1,41 +0,0 @@
package com.yanzhu.flowable.factory;
import lombok.Getter;
import org.flowable.engine.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
/**
* flowable 引擎注入封装
* @author Tony
* @date 2021-04-03
*/
@Component
@Getter
public class FlowServiceFactory {
@Resource
protected RepositoryService repositoryService;
@Resource
protected RuntimeService runtimeService;
@Resource
protected IdentityService identityService;
@Resource
protected TaskService taskService;
@Resource
protected HistoryService historyService;
@Resource
protected ManagementService managementService;
@Qualifier("processEngine")
@Resource
protected ProcessEngine processEngine;
}

370
yanzhu-flowable/src/main/java/com/yanzhu/flowable/flow/CustomProcessDiagramCanvas.java
View File

@ -1,370 +0,0 @@
package com.yanzhu.flowable.flow;
import org.flowable.bpmn.model.AssociationDirection;
import org.flowable.bpmn.model.GraphicInfo;
import org.flowable.image.impl.DefaultProcessDiagramCanvas;
import org.flowable.image.util.ReflectUtil;
import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.font.FontRenderContext;
import java.awt.font.LineBreakMeasurer;
import java.awt.font.TextAttribute;
import java.awt.font.TextLayout;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Rectangle2D;
import java.awt.geom.RoundRectangle2D;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.text.AttributedCharacterIterator;
import java.text.AttributedString;
/**
* @author Tony
* @date 2021/4/4 23:58
*/
public class CustomProcessDiagramCanvas extends DefaultProcessDiagramCanvas {
//定义走过流程连线颜色为绿色
protected static Color HIGHLIGHT_SequenceFlow_COLOR = Color.GREEN;
//设置未走过流程的连接线颜色
protected static Color CONNECTION_COLOR = Color.BLACK;
//设置flows连接线字体颜色red
protected static Color LABEL_COLOR = new Color(0, 0, 0);
//高亮显示task框颜色
protected static Color HIGHLIGHT_COLOR = Color.GREEN;
protected static Color HIGHLIGHT_COLOR1 = Color.RED;
public CustomProcessDiagramCanvas(int width, int height, int minX, int minY, String imageType, String activityFontName, String labelFontName, String annotationFontName, ClassLoader customClassLoader) {
super(width, height, minX, minY, imageType, activityFontName, labelFontName, annotationFontName, customClassLoader);
this.initialize(imageType);
}
/**
* 重写绘制连线的方式,设置绘制颜色
* @param xPoints
* @param yPoints
* @param conditional
* @param isDefault
* @param connectionType
* @param associationDirection
* @param highLighted
* @param scaleFactor
*/
@Override
public void drawConnection(int[] xPoints, int[] yPoints, boolean conditional, boolean isDefault, String connectionType, AssociationDirection associationDirection, boolean highLighted, double scaleFactor) {
Paint originalPaint = this.g.getPaint();
Stroke originalStroke = this.g.getStroke();
this.g.setPaint(CONNECTION_COLOR);
if (connectionType.equals("association")) {
this.g.setStroke(ASSOCIATION_STROKE);
} else if (highLighted) {
this.g.setPaint(HIGHLIGHT_SequenceFlow_COLOR);
this.g.setStroke(HIGHLIGHT_FLOW_STROKE);
}
for (int i = 1; i < xPoints.length; ++i) {
Integer sourceX = xPoints[i - 1];
Integer sourceY = yPoints[i - 1];
Integer targetX = xPoints[i];
Integer targetY = yPoints[i];
java.awt.geom.Line2D.Double line = new java.awt.geom.Line2D.Double((double) sourceX, (double) sourceY, (double) targetX, (double) targetY);
this.g.draw(line);
}
java.awt.geom.Line2D.Double line;
if (isDefault) {
line = new java.awt.geom.Line2D.Double((double) xPoints[0], (double) yPoints[0], (double) xPoints[1], (double) yPoints[1]);
this.drawDefaultSequenceFlowIndicator(line, scaleFactor);
}
if (conditional) {
line = new java.awt.geom.Line2D.Double((double) xPoints[0], (double) yPoints[0], (double) xPoints[1], (double) yPoints[1]);
this.drawConditionalSequenceFlowIndicator(line, scaleFactor);
}
if (associationDirection.equals(AssociationDirection.ONE) || associationDirection.equals(AssociationDirection.BOTH)) {
line = new java.awt.geom.Line2D.Double((double) xPoints[xPoints.length - 2], (double) yPoints[xPoints.length - 2], (double) xPoints[xPoints.length - 1], (double) yPoints[xPoints.length - 1]);
this.drawArrowHead(line, scaleFactor);
}
if (associationDirection.equals(AssociationDirection.BOTH)) {
line = new java.awt.geom.Line2D.Double((double) xPoints[1], (double) yPoints[1], (double) xPoints[0], (double) yPoints[0]);
this.drawArrowHead(line, scaleFactor);
}
this.g.setPaint(originalPaint);
this.g.setStroke(originalStroke);
}
/**
* 设置字体大小图标颜色
* @param imageType
*/
@Override
public void initialize(String imageType) {
if ("png".equalsIgnoreCase(imageType)) {
this.processDiagram = new BufferedImage(this.canvasWidth, this.canvasHeight, 2);
} else {
this.processDiagram = new BufferedImage(this.canvasWidth, this.canvasHeight, 1);
}
this.g = this.processDiagram.createGraphics();
if (!"png".equalsIgnoreCase(imageType)) {
this.g.setBackground(new Color(255, 255, 255, 0));
this.g.clearRect(0, 0, this.canvasWidth, this.canvasHeight);
}
this.g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
//修改图标颜色，修改图标字体大小
this.g.setPaint(Color.black);
Font font = new Font(this.activityFontName, 10, 14);
this.g.setFont(font);
this.fontMetrics = this.g.getFontMetrics();
//修改连接线字体大小
LABEL_FONT = new Font(this.labelFontName, 10, 15);
ANNOTATION_FONT = new Font(this.annotationFontName, 0, 11);
try {
USERTASK_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/userTask.png", this.customClassLoader));
SCRIPTTASK_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/scriptTask.png", this.customClassLoader));
SERVICETASK_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/serviceTask.png", this.customClassLoader));
RECEIVETASK_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/receiveTask.png", this.customClassLoader));
SENDTASK_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/sendTask.png", this.customClassLoader));
MANUALTASK_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/manualTask.png", this.customClassLoader));
BUSINESS_RULE_TASK_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/businessRuleTask.png", this.customClassLoader));
SHELL_TASK_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/shellTask.png", this.customClassLoader));
DMN_TASK_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/dmnTask.png", this.customClassLoader));
CAMEL_TASK_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/camelTask.png", this.customClassLoader));
MULE_TASK_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/muleTask.png", this.customClassLoader));
HTTP_TASK_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/httpTask.png", this.customClassLoader));
TIMER_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/timer.png", this.customClassLoader));
COMPENSATE_THROW_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/compensate-throw.png", this.customClassLoader));
COMPENSATE_CATCH_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/compensate.png", this.customClassLoader));
ERROR_THROW_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/error-throw.png", this.customClassLoader));
ERROR_CATCH_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/error.png", this.customClassLoader));
MESSAGE_THROW_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/message-throw.png", this.customClassLoader));
MESSAGE_CATCH_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/message.png", this.customClassLoader));
SIGNAL_THROW_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/signal-throw.png", this.customClassLoader));
SIGNAL_CATCH_IMAGE = ImageIO.read(ReflectUtil.getResource("org/flowable/icons/signal.png", this.customClassLoader));
} catch (IOException var4) {
LOGGER.warn("Could not load image for process diagram creation: {}", var4.getMessage());
}
}
/**
* 设置连接线字体
* @param text
* @param graphicInfo
* @param centered
*/
@Override
public void drawLabel(String text, GraphicInfo graphicInfo, boolean centered) {
float interline = 1.0f;
// text
if (text != null && text.length() > 0) {
Paint originalPaint = g.getPaint();
Font originalFont = g.getFont();
g.setPaint(LABEL_COLOR);
g.setFont(LABEL_FONT);
int wrapWidth = 100;
int textY = (int) graphicInfo.getY();
// TODO: use drawMultilineText()
AttributedString as = new AttributedString(text);
as.addAttribute(TextAttribute.FOREGROUND, g.getPaint());
as.addAttribute(TextAttribute.FONT, g.getFont());
AttributedCharacterIterator aci = as.getIterator();
FontRenderContext frc = new FontRenderContext(null, true, false);
LineBreakMeasurer lbm = new LineBreakMeasurer(aci, frc);
while (lbm.getPosition() < text.length()) {
TextLayout tl = lbm.nextLayout(wrapWidth);
textY += tl.getAscent();
Rectangle2D bb = tl.getBounds();
double tX = graphicInfo.getX();
if (centered) {
tX += (int) (graphicInfo.getWidth() / 2 - bb.getWidth() / 2);
}
tl.draw(g, (float) tX, textY);
textY += tl.getDescent() + tl.getLeading() + (interline - 1.0f) * tl.getAscent();
}
// restore originals
g.setFont(originalFont);
g.setPaint(originalPaint);
}
}
/**
* 高亮显示task框完成的
* @param x
* @param y
* @param width
* @param height
*/
@Override
public void drawHighLight(int x, int y, int width, int height) {
Paint originalPaint = g.getPaint();
Stroke originalStroke = g.getStroke();
g.setPaint(HIGHLIGHT_COLOR);
g.setStroke(THICK_TASK_BORDER_STROKE);
RoundRectangle2D rect = new RoundRectangle2D.Double(x, y, width, height, 20, 20);
g.draw(rect);
g.setPaint(originalPaint);
g.setStroke(originalStroke);
}
/**
* 自定义task框当前的位置
* @param x
* @param y
* @param width
* @param height
*/
public void drawHighLightNow(int x, int y, int width, int height) {
Paint originalPaint = g.getPaint();
Stroke originalStroke = g.getStroke();
g.setPaint(HIGHLIGHT_COLOR1);
g.setStroke(THICK_TASK_BORDER_STROKE);
RoundRectangle2D rect = new RoundRectangle2D.Double(x, y, width, height, 20, 20);
g.draw(rect);
g.setPaint(originalPaint);
g.setStroke(originalStroke);
}
/**
* 自定义结束节点
* @param x
* @param y
* @param width
* @param height
*/
public void drawHighLightEnd(int x, int y, int width, int height) {
Paint originalPaint = g.getPaint();
Stroke originalStroke = g.getStroke();
g.setPaint(HIGHLIGHT_COLOR);
g.setStroke(THICK_TASK_BORDER_STROKE);
RoundRectangle2D rect = new RoundRectangle2D.Double(x, y, width, height, 20, 20);
g.draw(rect);
g.setPaint(originalPaint);
g.setStroke(originalStroke);
}
/**
* task框自定义文字
* @param name
* @param graphicInfo
* @param thickBorder
* @param scaleFactor
*/
@Override
protected void drawTask(String name, GraphicInfo graphicInfo, boolean thickBorder, double scaleFactor) {
Paint originalPaint = g.getPaint();
int x = (int) graphicInfo.getX();
int y = (int) graphicInfo.getY();
int width = (int) graphicInfo.getWidth();
int height = (int) graphicInfo.getHeight();
// Create a new gradient paint for every task box, gradient depends on x and y and is not relative
g.setPaint(TASK_BOX_COLOR);
int arcR = 6;
if (thickBorder) {
arcR = 3;
}
// shape
RoundRectangle2D rect = new RoundRectangle2D.Double(x, y, width, height, arcR, arcR);
g.fill(rect);
g.setPaint(TASK_BORDER_COLOR);
if (thickBorder) {
Stroke originalStroke = g.getStroke();
g.setStroke(THICK_TASK_BORDER_STROKE);
g.draw(rect);
g.setStroke(originalStroke);
} else {
g.draw(rect);
}
g.setPaint(originalPaint);
// text
if (scaleFactor == 1.0 && name != null && name.length() > 0) {
int boxWidth = width - (2 * TEXT_PADDING);
int boxHeight = height - 16 - ICON_PADDING - ICON_PADDING - MARKER_WIDTH - 2 - 2;
int boxX = x + width / 2 - boxWidth / 2;
int boxY = y + height / 2 - boxHeight / 2 + ICON_PADDING + ICON_PADDING - 2 - 2;
drawMultilineCentredText(name, boxX, boxY, boxWidth, boxHeight);
}
}
protected static Color EVENT_COLOR = new Color(255, 255, 255);
/**
* 重写开始事件
* @param graphicInfo
* @param image
* @param scaleFactor
*/
@Override
public void drawStartEvent(GraphicInfo graphicInfo, BufferedImage image, double scaleFactor) {
Paint originalPaint = g.getPaint();
g.setPaint(EVENT_COLOR);
Ellipse2D circle = new Ellipse2D.Double(graphicInfo.getX(), graphicInfo.getY(),
graphicInfo.getWidth(), graphicInfo.getHeight());
g.fill(circle);
g.setPaint(EVENT_BORDER_COLOR);
g.draw(circle);
g.setPaint(originalPaint);
if (image != null) {
// calculate coordinates to center image
int imageX = (int) Math.round(graphicInfo.getX() + (graphicInfo.getWidth() / 2) - (image.getWidth() / (2 * scaleFactor)));
int imageY = (int) Math.round(graphicInfo.getY() + (graphicInfo.getHeight() / 2) - (image.getHeight() / (2 * scaleFactor)));
g.drawImage(image, imageX, imageY,
(int) (image.getWidth() / scaleFactor), (int) (image.getHeight() / scaleFactor), null);
}
}
/**
* 重写结束事件
* @param graphicInfo
* @param scaleFactor
*/
@Override
public void drawNoneEndEvent(GraphicInfo graphicInfo, double scaleFactor) {
Paint originalPaint = g.getPaint();
Stroke originalStroke = g.getStroke();
g.setPaint(EVENT_COLOR);
Ellipse2D circle = new Ellipse2D.Double(graphicInfo.getX(), graphicInfo.getY(),
graphicInfo.getWidth(), graphicInfo.getHeight());
g.fill(circle);
g.setPaint(EVENT_BORDER_COLOR);
// g.setPaint(HIGHLIGHT_COLOR);
if (scaleFactor == 1.0) {
g.setStroke(END_EVENT_STROKE);
} else {
g.setStroke(new BasicStroke(2.0f));
}
g.draw(circle);
g.setStroke(originalStroke);
g.setPaint(originalPaint);
}
}

404
yanzhu-flowable/src/main/java/com/yanzhu/flowable/flow/CustomProcessDiagramGenerator.java
View File

@ -1,404 +0,0 @@
package com.yanzhu.flowable.flow;
import org.flowable.bpmn.model.Process;
import org.flowable.bpmn.model.*;
import org.flowable.image.impl.DefaultProcessDiagramCanvas;
import org.flowable.image.impl.DefaultProcessDiagramGenerator;
import java.util.Iterator;
import java.util.List;
/**
* @author Tony
* @date 2021/4/5 0:31
*/
public class CustomProcessDiagramGenerator extends DefaultProcessDiagramGenerator {
@Override
protected DefaultProcessDiagramCanvas generateProcessDiagram(BpmnModel bpmnModel, String imageType, List<String> highLightedActivities, List<String> highLightedFlows, String activityFontName, String labelFontName, String annotationFontName, ClassLoader customClassLoader, double scaleFactor, boolean drawSequenceFlowNameWithNoLabelDI) {
this.prepareBpmnModel(bpmnModel);
DefaultProcessDiagramCanvas processDiagramCanvas = initProcessDiagramCanvas(bpmnModel, imageType, activityFontName, labelFontName, annotationFontName, customClassLoader);
Iterator var13 = bpmnModel.getPools().iterator();
while (var13.hasNext()) {
Pool process = (Pool) var13.next();
GraphicInfo subProcesses = bpmnModel.getGraphicInfo(process.getId());
processDiagramCanvas.drawPoolOrLane(process.getName(), subProcesses, scaleFactor);
}
var13 = bpmnModel.getProcesses().iterator();
Process process1;
Iterator subProcesses1;
while (var13.hasNext()) {
process1 = (Process) var13.next();
subProcesses1 = process1.getLanes().iterator();
while (subProcesses1.hasNext()) {
Lane artifact = (Lane) subProcesses1.next();
GraphicInfo subProcess = bpmnModel.getGraphicInfo(artifact.getId());
processDiagramCanvas.drawPoolOrLane(artifact.getName(), subProcess, scaleFactor);
}
}
var13 = bpmnModel.getProcesses().iterator();
while (var13.hasNext()) {
process1 = (Process) var13.next();
subProcesses1 = process1.findFlowElementsOfType(FlowNode.class).iterator();
while (subProcesses1.hasNext()) {
FlowNode artifact1 = (FlowNode) subProcesses1.next();
if (!this.isPartOfCollapsedSubProcess(artifact1, bpmnModel)) {
this.drawActivity(processDiagramCanvas, bpmnModel, artifact1, highLightedActivities, highLightedFlows, scaleFactor, Boolean.valueOf(drawSequenceFlowNameWithNoLabelDI));
}
}
}
var13 = bpmnModel.getProcesses().iterator();
label75:
while (true) {
List subProcesses2;
do {
if (!var13.hasNext()) {
return processDiagramCanvas;
}
process1 = (Process) var13.next();
subProcesses1 = process1.getArtifacts().iterator();
while (subProcesses1.hasNext()) {
Artifact artifact2 = (Artifact) subProcesses1.next();
this.drawArtifact(processDiagramCanvas, bpmnModel, artifact2);
}
subProcesses2 = process1.findFlowElementsOfType(SubProcess.class, true);
} while (subProcesses2 == null);
Iterator artifact3 = subProcesses2.iterator();
while (true) {
GraphicInfo graphicInfo;
SubProcess subProcess1;
do {
do {
if (!artifact3.hasNext()) {
continue label75;
}
subProcess1 = (SubProcess) artifact3.next();
graphicInfo = bpmnModel.getGraphicInfo(subProcess1.getId());
} while (graphicInfo != null && graphicInfo.getExpanded() != null && !graphicInfo.getExpanded().booleanValue());
} while (this.isPartOfCollapsedSubProcess(subProcess1, bpmnModel));
Iterator var19 = subProcess1.getArtifacts().iterator();
while (var19.hasNext()) {
Artifact subProcessArtifact = (Artifact) var19.next();
this.drawArtifact(processDiagramCanvas, bpmnModel, subProcessArtifact);
}
}
}
}
protected static DefaultProcessDiagramCanvas initProcessDiagramCanvas(BpmnModel bpmnModel, String imageType, String activityFontName, String labelFontName, String annotationFontName, ClassLoader customClassLoader) {
double minX = 1.7976931348623157E308D;
double maxX = 0.0D;
double minY = 1.7976931348623157E308D;
double maxY = 0.0D;
GraphicInfo nrOfLanes;
for (Iterator flowNodes = bpmnModel.getPools().iterator(); flowNodes.hasNext(); maxY = nrOfLanes.getY() + nrOfLanes.getHeight()) {
Pool artifacts = (Pool) flowNodes.next();
nrOfLanes = bpmnModel.getGraphicInfo(artifacts.getId());
minX = nrOfLanes.getX();
maxX = nrOfLanes.getX() + nrOfLanes.getWidth();
minY = nrOfLanes.getY();
}
List var23 = gatherAllFlowNodes(bpmnModel);
Iterator var24 = var23.iterator();
label155:
while (var24.hasNext()) {
FlowNode var26 = (FlowNode) var24.next();
GraphicInfo artifact = bpmnModel.getGraphicInfo(var26.getId());
if (artifact.getX() + artifact.getWidth() > maxX) {
maxX = artifact.getX() + artifact.getWidth();
}
if (artifact.getX() < minX) {
minX = artifact.getX();
}
if (artifact.getY() + artifact.getHeight() > maxY) {
maxY = artifact.getY() + artifact.getHeight();
}
if (artifact.getY() < minY) {
minY = artifact.getY();
}
Iterator process = var26.getOutgoingFlows().iterator();
while (true) {
List l;
do {
if (!process.hasNext()) {
continue label155;
}
SequenceFlow graphicInfoList = (SequenceFlow) process.next();
l = bpmnModel.getFlowLocationGraphicInfo(graphicInfoList.getId());
} while (l == null);
Iterator graphicInfo = l.iterator();
while (graphicInfo.hasNext()) {
GraphicInfo graphicInfo1 = (GraphicInfo) graphicInfo.next();
if (graphicInfo1.getX() > maxX) {
maxX = graphicInfo1.getX();
}
if (graphicInfo1.getX() < minX) {
minX = graphicInfo1.getX();
}
if (graphicInfo1.getY() > maxY) {
maxY = graphicInfo1.getY();
}
if (graphicInfo1.getY() < minY) {
minY = graphicInfo1.getY();
}
}
}
}
List var25 = gatherAllArtifacts(bpmnModel);
Iterator var27 = var25.iterator();
GraphicInfo var37;
while (var27.hasNext()) {
Artifact var29 = (Artifact) var27.next();
GraphicInfo var31 = bpmnModel.getGraphicInfo(var29.getId());
if (var31 != null) {
if (var31.getX() + var31.getWidth() > maxX) {
maxX = var31.getX() + var31.getWidth();
}
if (var31.getX() < minX) {
minX = var31.getX();
}
if (var31.getY() + var31.getHeight() > maxY) {
maxY = var31.getY() + var31.getHeight();
}
if (var31.getY() < minY) {
minY = var31.getY();
}
}
List var33 = bpmnModel.getFlowLocationGraphicInfo(var29.getId());
if (var33 != null) {
Iterator var35 = var33.iterator();
while (var35.hasNext()) {
var37 = (GraphicInfo) var35.next();
if (var37.getX() > maxX) {
maxX = var37.getX();
}
if (var37.getX() < minX) {
minX = var37.getX();
}
if (var37.getY() > maxY) {
maxY = var37.getY();
}
if (var37.getY() < minY) {
minY = var37.getY();
}
}
}
}
int var28 = 0;
Iterator var30 = bpmnModel.getProcesses().iterator();
while (var30.hasNext()) {
Process var32 = (Process) var30.next();
Iterator var34 = var32.getLanes().iterator();
while (var34.hasNext()) {
Lane var36 = (Lane) var34.next();
++var28;
var37 = bpmnModel.getGraphicInfo(var36.getId());
if (var37.getX() + var37.getWidth() > maxX) {
maxX = var37.getX() + var37.getWidth();
}
if (var37.getX() < minX) {
minX = var37.getX();
}
if (var37.getY() + var37.getHeight() > maxY) {
maxY = var37.getY() + var37.getHeight();
}
if (var37.getY() < minY) {
minY = var37.getY();
}
}
}
if (var23.isEmpty() && bpmnModel.getPools().isEmpty() && var28 == 0) {
minX = 0.0D;
minY = 0.0D;
}
return new CustomProcessDiagramCanvas((int) maxX + 10, (int) maxY + 10, (int) minX, (int) minY, imageType, activityFontName, labelFontName, annotationFontName, customClassLoader);
}
private static void drawHighLight(DefaultProcessDiagramCanvas processDiagramCanvas, GraphicInfo graphicInfo) {
processDiagramCanvas.drawHighLight((int) graphicInfo.getX(), (int) graphicInfo.getY(), (int) graphicInfo.getWidth(), (int) graphicInfo.getHeight());
}
private static void drawHighLightNow(CustomProcessDiagramCanvas processDiagramCanvas, GraphicInfo graphicInfo) {
processDiagramCanvas.drawHighLightNow((int) graphicInfo.getX(), (int) graphicInfo.getY(), (int) graphicInfo.getWidth(), (int) graphicInfo.getHeight());
}
private static void drawHighLightEnd(CustomProcessDiagramCanvas processDiagramCanvas, GraphicInfo graphicInfo) {
processDiagramCanvas.drawHighLightEnd((int) graphicInfo.getX(), (int) graphicInfo.getY(), (int) graphicInfo.getWidth(), (int) graphicInfo.getHeight());
}
@Override
protected void drawActivity(DefaultProcessDiagramCanvas processDiagramCanvas, BpmnModel bpmnModel,
FlowNode flowNode, java.util.List<String> highLightedActivities, java.util.List<String> highLightedFlows, double scaleFactor, Boolean drawSequenceFlowNameWithNoLabelDI) {
DefaultProcessDiagramGenerator.ActivityDrawInstruction drawInstruction = activityDrawInstructions.get(flowNode.getClass());
if (drawInstruction != null) {
drawInstruction.draw(processDiagramCanvas, bpmnModel, flowNode);
// Gather info on the multi instance marker
boolean multiInstanceSequential = false;
boolean multiInstanceParallel = false;
boolean collapsed = false;
if (flowNode instanceof Activity) {
Activity activity = (Activity) flowNode;
MultiInstanceLoopCharacteristics multiInstanceLoopCharacteristics = activity.getLoopCharacteristics();
if (multiInstanceLoopCharacteristics != null) {
multiInstanceSequential = multiInstanceLoopCharacteristics.isSequential();
multiInstanceParallel = !multiInstanceSequential;
}
}
// Gather info on the collapsed marker
GraphicInfo graphicInfo = bpmnModel.getGraphicInfo(flowNode.getId());
if (flowNode instanceof SubProcess) {
collapsed = graphicInfo.getExpanded() != null && !graphicInfo.getExpanded();
} else if (flowNode instanceof CallActivity) {
collapsed = true;
}
if (scaleFactor == 1.0) {
// Actually draw the markers
processDiagramCanvas.drawActivityMarkers((int) graphicInfo.getX(), (int) graphicInfo.getY(), (int) graphicInfo.getWidth(), (int) graphicInfo.getHeight(),
multiInstanceSequential, multiInstanceParallel, collapsed);
}
// Draw highlighted activities
if (highLightedActivities.contains(flowNode.getId())) {
if (highLightedActivities.get(highLightedActivities.size() - 1).equals(flowNode.getId())
&& !"endenv".equals(flowNode.getId())) {
if ((flowNode.getId().contains("Event_"))) {
drawHighLightEnd((CustomProcessDiagramCanvas) processDiagramCanvas, bpmnModel.getGraphicInfo(flowNode.getId()));
} else {
drawHighLightNow((CustomProcessDiagramCanvas) processDiagramCanvas, bpmnModel.getGraphicInfo(flowNode.getId()));
}
} else {
drawHighLight(processDiagramCanvas, bpmnModel.getGraphicInfo(flowNode.getId()));
}
}
}
// Outgoing transitions of activity
for (SequenceFlow sequenceFlow : flowNode.getOutgoingFlows()) {
boolean highLighted = (highLightedFlows.contains(sequenceFlow.getId()));
String defaultFlow = null;
if (flowNode instanceof Activity) {
defaultFlow = ((Activity) flowNode).getDefaultFlow();
} else if (flowNode instanceof Gateway) {
defaultFlow = ((Gateway) flowNode).getDefaultFlow();
}
boolean isDefault = false;
if (defaultFlow != null && defaultFlow.equalsIgnoreCase(sequenceFlow.getId())) {
isDefault = true;
}
boolean drawConditionalIndicator = sequenceFlow.getConditionExpression() != null && !(flowNode instanceof Gateway);
String sourceRef = sequenceFlow.getSourceRef();
String targetRef = sequenceFlow.getTargetRef();
FlowElement sourceElement = bpmnModel.getFlowElement(sourceRef);
FlowElement targetElement = bpmnModel.getFlowElement(targetRef);
java.util.List<GraphicInfo> graphicInfoList = bpmnModel.getFlowLocationGraphicInfo(sequenceFlow.getId());
if (graphicInfoList != null && graphicInfoList.size() > 0) {
graphicInfoList = connectionPerfectionizer(processDiagramCanvas, bpmnModel, sourceElement, targetElement, graphicInfoList);
int xPoints[] = new int[graphicInfoList.size()];
int yPoints[] = new int[graphicInfoList.size()];
for (int i = 1; i < graphicInfoList.size(); i++) {
GraphicInfo graphicInfo = graphicInfoList.get(i);
GraphicInfo previousGraphicInfo = graphicInfoList.get(i - 1);
if (i == 1) {
xPoints[0] = (int) previousGraphicInfo.getX();
yPoints[0] = (int) previousGraphicInfo.getY();
}
xPoints[i] = (int) graphicInfo.getX();
yPoints[i] = (int) graphicInfo.getY();
}
processDiagramCanvas.drawSequenceflow(xPoints, yPoints, drawConditionalIndicator, isDefault, highLighted, scaleFactor);
// Draw sequenceflow label
GraphicInfo labelGraphicInfo = bpmnModel.getLabelGraphicInfo(sequenceFlow.getId());
if (labelGraphicInfo != null) {
processDiagramCanvas.drawLabel(sequenceFlow.getName(), labelGraphicInfo, false);
} else {
if (drawSequenceFlowNameWithNoLabelDI) {
GraphicInfo lineCenter = getLineCenter(graphicInfoList);
processDiagramCanvas.drawLabel(sequenceFlow.getName(), lineCenter, false);
}
}
}
}
// Nested elements
if (flowNode instanceof FlowElementsContainer) {
for (FlowElement nestedFlowElement : ((FlowElementsContainer) flowNode).getFlowElements()) {
if (nestedFlowElement instanceof FlowNode && !isPartOfCollapsedSubProcess(nestedFlowElement, bpmnModel)) {
drawActivity(processDiagramCanvas, bpmnModel, (FlowNode) nestedFlowElement,
highLightedActivities, highLightedFlows, scaleFactor, drawSequenceFlowNameWithNoLabelDI);
}
}
}
}
}

257
yanzhu-flowable/src/main/java/com/yanzhu/flowable/flow/FindNextNodeUtil.java
View File

@ -1,257 +0,0 @@
package com.yanzhu.flowable.flow;
import com.googlecode.aviator.AviatorEvaluator;
import com.googlecode.aviator.Expression;
//import com.greenpineyu.fel.FelEngine;
//import com.greenpineyu.fel.FelEngineImpl;
//import com.greenpineyu.fel.context.FelContext;
import org.flowable.bpmn.model.Process;
import org.flowable.bpmn.model.*;
import org.flowable.engine.RepositoryService;
import org.flowable.engine.repository.ProcessDefinition;
import java.util.*;
/**
* @author Tony
* @date 2021/4/19 20:51
*/
public class FindNextNodeUtil {
/**
* 获取下一步骤的用户任务
*
* @param repositoryService
* @param map
* @return
*/
public static List<UserTask> getNextUserTasks(RepositoryService repositoryService, org.flowable.task.api.Task task, Map<String, Object> map) {
List<UserTask> data = new ArrayList<>();
ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(task.getProcessDefinitionId()).singleResult();
BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinition.getId());
Process mainProcess = bpmnModel.getMainProcess();
Collection<FlowElement> flowElements = mainProcess.getFlowElements();
String key = task.getTaskDefinitionKey();
FlowElement flowElement = bpmnModel.getFlowElement(key);
next(flowElements, flowElement, map, data);
return data;
}
/**
* 启动流程时获取下一步骤的用户任务
*
* @param repositoryService
* @param map
* @return
*/
public static List<UserTask> getNextUserTasksByStart(RepositoryService repositoryService, ProcessDefinition processDefinition, Map<String, Object> map) {
List<UserTask> data = new ArrayList<>();
BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinition.getId());
Process mainProcess = bpmnModel.getMainProcess();
Collection<FlowElement> flowElements = mainProcess.getFlowElements();
String key = null;
// 找到开始节点 并获取唯一key
for (FlowElement flowElement : flowElements) {
if (flowElement instanceof StartEvent) {
key = flowElement.getId();
break;
}
}
FlowElement flowElement = bpmnModel.getFlowElement(key);
next(flowElements, flowElement, map, data);
return data;
}
/**
* 查找下一节点
*
* @param flowElements
* @param flowElement
* @param map
* @param nextUser
*/
public static void next(Collection<FlowElement> flowElements, FlowElement flowElement, Map<String, Object> map, List<UserTask> nextUser) {
//如果是结束节点
if (flowElement instanceof EndEvent) {
//如果是子任务的结束节点
if (getSubProcess(flowElements, flowElement) != null) {
flowElement = getSubProcess(flowElements, flowElement);
}
}
//获取Task的出线信息--可以拥有多个
List<SequenceFlow> outGoingFlows = null;
if (flowElement instanceof Task) {
outGoingFlows = ((Task) flowElement).getOutgoingFlows();
} else if (flowElement instanceof Gateway) {
outGoingFlows = ((Gateway) flowElement).getOutgoingFlows();
} else if (flowElement instanceof StartEvent) {
outGoingFlows = ((StartEvent) flowElement).getOutgoingFlows();
} else if (flowElement instanceof SubProcess) {
outGoingFlows = ((SubProcess) flowElement).getOutgoingFlows();
} else if (flowElement instanceof CallActivity) {
outGoingFlows = ((CallActivity) flowElement).getOutgoingFlows();
}
if (outGoingFlows != null && outGoingFlows.size() > 0) {
//遍历所有的出线--找到可以正确执行的那一条
for (SequenceFlow sequenceFlow : outGoingFlows) {
//1.有表达式，且为true
//2.无表达式
String expression = sequenceFlow.getConditionExpression();
if (expression == null ||
expressionResult(map, expression.substring(expression.lastIndexOf("{") + 1, expression.lastIndexOf("}")))) {
//出线的下一节点
String nextFlowElementID = sequenceFlow.getTargetRef();
if (checkSubProcess(nextFlowElementID, flowElements, nextUser)) {
continue;
}
//查询下一节点的信息
FlowElement nextFlowElement = getFlowElementById(nextFlowElementID, flowElements);
//调用流程
if (nextFlowElement instanceof CallActivity) {
CallActivity ca = (CallActivity) nextFlowElement;
if (ca.getLoopCharacteristics() != null) {
UserTask userTask = new UserTask();
userTask.setId(ca.getId());
userTask.setId(ca.getId());
userTask.setLoopCharacteristics(ca.getLoopCharacteristics());
userTask.setName(ca.getName());
nextUser.add(userTask);
}
next(flowElements, nextFlowElement, map, nextUser);
}
//用户任务
if (nextFlowElement instanceof UserTask) {
nextUser.add((UserTask) nextFlowElement);
}
//排他网关
else if (nextFlowElement instanceof ExclusiveGateway) {
next(flowElements, nextFlowElement, map, nextUser);
}
//并行网关
else if (nextFlowElement instanceof ParallelGateway) {
next(flowElements, nextFlowElement, map, nextUser);
}
//接收任务
else if (nextFlowElement instanceof ReceiveTask) {
next(flowElements, nextFlowElement, map, nextUser);
}
//服务任务
else if (nextFlowElement instanceof ServiceTask) {
next(flowElements, nextFlowElement, map, nextUser);
}
//子任务的起点
else if (nextFlowElement instanceof StartEvent) {
next(flowElements, nextFlowElement, map, nextUser);
}
//结束节点
else if (nextFlowElement instanceof EndEvent) {
next(flowElements, nextFlowElement, map, nextUser);
}
}
}
}
}
/**
* 判断是否是多实例子流程并且需要设置集合类型变量
*/
public static boolean checkSubProcess(String Id, Collection<FlowElement> flowElements, List<UserTask> nextUser) {
for (FlowElement flowElement1 : flowElements) {
if (flowElement1 instanceof SubProcess && flowElement1.getId().equals(Id)) {
SubProcess sp = (SubProcess) flowElement1;
if (sp.getLoopCharacteristics() != null) {
String inputDataItem = sp.getLoopCharacteristics().getInputDataItem();
UserTask userTask = new UserTask();
userTask.setId(sp.getId());
userTask.setLoopCharacteristics(sp.getLoopCharacteristics());
userTask.setName(sp.getName());
nextUser.add(userTask);
return true;
}
}
}
return false;
}
/**
* 查询一个节点的是否子任务中的节点，如果是，返回子任务
*
* @param flowElements 全流程的节点集合
* @param flowElement 当前节点
* @return
*/
public static FlowElement getSubProcess(Collection<FlowElement> flowElements, FlowElement flowElement) {
for (FlowElement flowElement1 : flowElements) {
if (flowElement1 instanceof SubProcess) {
for (FlowElement flowElement2 : ((SubProcess) flowElement1).getFlowElements()) {
if (flowElement.equals(flowElement2)) {
return flowElement1;
}
}
}
}
return null;
}
/**
* 根据ID查询流程节点对象, 如果是子任务，则返回子任务的开始节点
*
* @param Id 节点ID
* @param flowElements 流程节点集合
* @return
*/
public static FlowElement getFlowElementById(String Id, Collection<FlowElement> flowElements) {
for (FlowElement flowElement : flowElements) {
if (flowElement.getId().equals(Id)) {
//如果是子任务，则查询出子任务的开始节点
if (flowElement instanceof SubProcess) {
return getStartFlowElement(((SubProcess) flowElement).getFlowElements());
}
return flowElement;
}
if (flowElement instanceof SubProcess) {
FlowElement flowElement1 = getFlowElementById(Id, ((SubProcess) flowElement).getFlowElements());
if (flowElement1 != null) {
return flowElement1;
}
}
}
return null;
}
/**
* 返回流程的开始节点
*
* @param flowElements 节点集合
* @description:
*/
public static FlowElement getStartFlowElement(Collection<FlowElement> flowElements) {
for (FlowElement flowElement : flowElements) {
if (flowElement instanceof StartEvent) {
return flowElement;
}
}
return null;
}
/**
* 校验el表达式
*
* @param map
* @param expression
* @return
*/
public static boolean expressionResult(Map<String, Object> map, String expression) {
Expression exp = AviatorEvaluator.compile(expression);
final Object execute = exp.execute(map);
return Boolean.parseBoolean(String.valueOf(execute));
}
}

589
yanzhu-flowable/src/main/java/com/yanzhu/flowable/flow/FlowableUtils.java
View File

@ -1,589 +0,0 @@
package com.yanzhu.flowable.flow;
import lombok.extern.slf4j.Slf4j;
import org.flowable.bpmn.model.*;
import org.flowable.engine.impl.bpmn.behavior.ParallelMultiInstanceBehavior;
import org.flowable.engine.impl.bpmn.behavior.SequentialMultiInstanceBehavior;
import org.flowable.task.api.history.HistoricTaskInstance;
import java.util.*;
/**
* @author Tony
* @date 2021-04-03 23:57
*/
@Slf4j
public class FlowableUtils {
/**
* 根据节点，获取入口连线
* @param source
* @return
*/
public static List<SequenceFlow> getElementIncomingFlows(FlowElement source) {
List<SequenceFlow> sequenceFlows = null;
if (source instanceof FlowNode) {
sequenceFlows = ((FlowNode) source).getIncomingFlows();
} else if (source instanceof Gateway) {
sequenceFlows = ((Gateway) source).getIncomingFlows();
} else if (source instanceof SubProcess) {
sequenceFlows = ((SubProcess) source).getIncomingFlows();
} else if (source instanceof StartEvent) {
sequenceFlows = ((StartEvent) source).getIncomingFlows();
} else if (source instanceof EndEvent) {
sequenceFlows = ((EndEvent) source).getIncomingFlows();
}
return sequenceFlows;
}
/**
* 根据节点，获取出口连线
* @param source
* @return
*/
public static List<SequenceFlow> getElementOutgoingFlows(FlowElement source) {
List<SequenceFlow> sequenceFlows = null;
if (source instanceof FlowNode) {
sequenceFlows = ((FlowNode) source).getOutgoingFlows();
} else if (source instanceof Gateway) {
sequenceFlows = ((Gateway) source).getOutgoingFlows();
} else if (source instanceof SubProcess) {
sequenceFlows = ((SubProcess) source).getOutgoingFlows();
} else if (source instanceof StartEvent) {
sequenceFlows = ((StartEvent) source).getOutgoingFlows();
} else if (source instanceof EndEvent) {
sequenceFlows = ((EndEvent) source).getOutgoingFlows();
}
return sequenceFlows;
}
/**
* 获取全部节点列表，包含子流程节点
* @param flowElements
* @param allElements
* @return
*/
public static Collection<FlowElement> getAllElements(Collection<FlowElement> flowElements, Collection<FlowElement> allElements) {
allElements = allElements == null ? new ArrayList<>() : allElements;
for (FlowElement flowElement : flowElements) {
allElements.add(flowElement);
if (flowElement instanceof SubProcess) {
// 继续深入子流程，进一步获取子流程
allElements = FlowableUtils.getAllElements(((SubProcess) flowElement).getFlowElements(), allElements);
}
}
return allElements;
}
/**
* 迭代获取父级任务节点列表，向前找
* @param source 起始节点
* @param hasSequenceFlow 已经经过的连线的 ID，用于判断线路是否重复
* @param userTaskList 已找到的用户任务节点
* @return
*/
public static List<UserTask> iteratorFindParentUserTasks(FlowElement source, Set<String> hasSequenceFlow, List<UserTask> userTaskList) {
userTaskList = userTaskList == null ? new ArrayList<>() : userTaskList;
hasSequenceFlow = hasSequenceFlow == null ? new HashSet<>() : hasSequenceFlow;
// 如果该节点为开始节点，且存在上级子节点，则顺着上级子节点继续迭代
if (source instanceof StartEvent && source.getSubProcess() != null) {
userTaskList = iteratorFindParentUserTasks(source.getSubProcess(), hasSequenceFlow, userTaskList);
}
// 根据类型，获取入口连线
List<SequenceFlow> sequenceFlows = getElementIncomingFlows(source);
if (sequenceFlows != null) {
// 循环找到目标元素
for (SequenceFlow sequenceFlow: sequenceFlows) {
// 如果发现连线重复，说明循环了，跳过这个循环
if (hasSequenceFlow.contains(sequenceFlow.getId())) {
continue;
}
// 添加已经走过的连线
hasSequenceFlow.add(sequenceFlow.getId());
// 类型为用户节点，则新增父级节点
if (sequenceFlow.getSourceFlowElement() instanceof UserTask) {
userTaskList.add((UserTask) sequenceFlow.getSourceFlowElement());
continue;
}
// 类型为子流程，则添加子流程开始节点出口处相连的节点
if (sequenceFlow.getSourceFlowElement() instanceof SubProcess) {
// 获取子流程用户任务节点
List<UserTask> childUserTaskList = findChildProcessUserTasks((StartEvent) ((SubProcess) sequenceFlow.getSourceFlowElement()).getFlowElements().toArray()[0], null, null);
// 如果找到节点，则说明该线路找到节点，不继续向下找，反之继续
if (childUserTaskList != null && childUserTaskList.size() > 0) {
userTaskList.addAll(childUserTaskList);
continue;
}
}
// 继续迭代
userTaskList = iteratorFindParentUserTasks(sequenceFlow.getSourceFlowElement(), hasSequenceFlow, userTaskList);
}
}
return userTaskList;
}
/**
* 根据正在运行的任务节点，迭代获取子级任务节点列表，向后找
* @param source 起始节点(退回节点)
* @param runTaskKeyList 正在运行的任务 Key，用于校验任务节点是否是正在运行的节点
* @param hasSequenceFlow 已经经过的连线的 ID，用于判断线路是否重复
* @param userTaskList 需要撤回的用户任务列表
* @return
*/
public static List<UserTask> iteratorFindChildUserTasks(FlowElement source, List<String> runTaskKeyList, Set<String> hasSequenceFlow, List<UserTask> userTaskList) {
hasSequenceFlow = hasSequenceFlow == null ? new HashSet<>() : hasSequenceFlow;
userTaskList = userTaskList == null ? new ArrayList<>() : userTaskList;
// 如果该节点为开始节点，且存在上级子节点，则顺着上级子节点继续迭代
if (source instanceof EndEvent && source.getSubProcess() != null) {
userTaskList = iteratorFindChildUserTasks(source.getSubProcess(), runTaskKeyList, hasSequenceFlow, userTaskList);
}
// 根据类型，获取出口连线
List<SequenceFlow> sequenceFlows = getElementOutgoingFlows(source);
if (sequenceFlows != null) {
// 循环找到目标元素
for (SequenceFlow sequenceFlow: sequenceFlows) {
// 如果发现连线重复，说明循环了，跳过这个循环
if (hasSequenceFlow.contains(sequenceFlow.getId())) {
continue;
}
// 添加已经走过的连线
hasSequenceFlow.add(sequenceFlow.getId());
// 如果为用户任务类型，且任务节点的 Key 正在运行的任务中存在，添加
if (sequenceFlow.getTargetFlowElement() instanceof UserTask && runTaskKeyList.contains((sequenceFlow.getTargetFlowElement()).getId())) {
userTaskList.add((UserTask) sequenceFlow.getTargetFlowElement());
continue;
}
// 如果节点为子流程节点情况，则从节点中的第一个节点开始获取
if (sequenceFlow.getTargetFlowElement() instanceof SubProcess) {
List<UserTask> childUserTaskList = iteratorFindChildUserTasks((FlowElement) (((SubProcess) sequenceFlow.getTargetFlowElement()).getFlowElements().toArray()[0]), runTaskKeyList, hasSequenceFlow, null);
// 如果找到节点，则说明该线路找到节点，不继续向下找，反之继续
if (childUserTaskList != null && childUserTaskList.size() > 0) {
userTaskList.addAll(childUserTaskList);
continue;
}
}
// 继续迭代
userTaskList = iteratorFindChildUserTasks(sequenceFlow.getTargetFlowElement(), runTaskKeyList, hasSequenceFlow, userTaskList);
}
}
return userTaskList;
}
/**
* 迭代获取子流程用户任务节点
* @param source 起始节点
* @param hasSequenceFlow 已经经过的连线的 ID，用于判断线路是否重复
* @param userTaskList 需要撤回的用户任务列表
* @return
*/
public static List<UserTask> findChildProcessUserTasks(FlowElement source, Set<String> hasSequenceFlow, List<UserTask> userTaskList) {
hasSequenceFlow = hasSequenceFlow == null ? new HashSet<>() : hasSequenceFlow;
userTaskList = userTaskList == null ? new ArrayList<>() : userTaskList;
// 根据类型，获取出口连线
List<SequenceFlow> sequenceFlows = getElementOutgoingFlows(source);
if (sequenceFlows != null) {
// 循环找到目标元素
for (SequenceFlow sequenceFlow: sequenceFlows) {
// 如果发现连线重复，说明循环了，跳过这个循环
if (hasSequenceFlow.contains(sequenceFlow.getId())) {
continue;
}
// 添加已经走过的连线
hasSequenceFlow.add(sequenceFlow.getId());
// 如果为用户任务类型，且任务节点的 Key 正在运行的任务中存在，添加
if (sequenceFlow.getTargetFlowElement() instanceof UserTask) {
userTaskList.add((UserTask) sequenceFlow.getTargetFlowElement());
continue;
}
// 如果节点为子流程节点情况，则从节点中的第一个节点开始获取
if (sequenceFlow.getTargetFlowElement() instanceof SubProcess) {
List<UserTask> childUserTaskList = findChildProcessUserTasks((FlowElement) (((SubProcess) sequenceFlow.getTargetFlowElement()).getFlowElements().toArray()[0]), hasSequenceFlow, null);
// 如果找到节点，则说明该线路找到节点，不继续向下找，反之继续
if (childUserTaskList != null && childUserTaskList.size() > 0) {
userTaskList.addAll(childUserTaskList);
continue;
}
}
// 继续迭代
userTaskList = findChildProcessUserTasks(sequenceFlow.getTargetFlowElement(), hasSequenceFlow, userTaskList);
}
}
return userTaskList;
}
/**
* 从后向前寻路，获取所有脏线路上的点
* @param source 起始节点
* @param passRoads 已经经过的点集合
* @param hasSequenceFlow 已经经过的连线的 ID，用于判断线路是否重复
* @param targets 目标脏线路终点
* @param dirtyRoads 确定为脏数据的点，因为不需要重复，因此使用 set 存储
* @return
*/
public static Set<String> iteratorFindDirtyRoads(FlowElement source, List<String> passRoads, Set<String> hasSequenceFlow, List<String> targets, Set<String> dirtyRoads) {
passRoads = passRoads == null ? new ArrayList<>() : passRoads;
dirtyRoads = dirtyRoads == null ? new HashSet<>() : dirtyRoads;
hasSequenceFlow = hasSequenceFlow == null ? new HashSet<>() : hasSequenceFlow;
// 如果该节点为开始节点，且存在上级子节点，则顺着上级子节点继续迭代
if (source instanceof StartEvent && source.getSubProcess() != null) {
dirtyRoads = iteratorFindDirtyRoads(source.getSubProcess(), passRoads, hasSequenceFlow, targets, dirtyRoads);
}
// 根据类型，获取入口连线
List<SequenceFlow> sequenceFlows = getElementIncomingFlows(source);
if (sequenceFlows != null) {
// 循环找到目标元素
for (SequenceFlow sequenceFlow: sequenceFlows) {
// 如果发现连线重复，说明循环了，跳过这个循环
if (hasSequenceFlow.contains(sequenceFlow.getId())) {
continue;
}
// 添加已经走过的连线
hasSequenceFlow.add(sequenceFlow.getId());
// 新增经过的路线
passRoads.add(sequenceFlow.getSourceFlowElement().getId());
// 如果此点为目标点，确定经过的路线为脏线路，添加点到脏线路中，然后找下个连线
if (targets.contains(sequenceFlow.getSourceFlowElement().getId())) {
dirtyRoads.addAll(passRoads);
continue;
}
// 如果该节点为开始节点，且存在上级子节点，则顺着上级子节点继续迭代
if (sequenceFlow.getSourceFlowElement() instanceof SubProcess) {
dirtyRoads = findChildProcessAllDirtyRoad((StartEvent) ((SubProcess) sequenceFlow.getSourceFlowElement()).getFlowElements().toArray()[0], null, dirtyRoads);
// 是否存在子流程上，true 是，false 否
Boolean isInChildProcess = dirtyTargetInChildProcess((StartEvent) ((SubProcess) sequenceFlow.getSourceFlowElement()).getFlowElements().toArray()[0], null, targets, null);
if (isInChildProcess) {
// 已在子流程上找到，该路线结束
continue;
}
}
// 继续迭代
dirtyRoads = iteratorFindDirtyRoads(sequenceFlow.getSourceFlowElement(), passRoads, hasSequenceFlow, targets, dirtyRoads);
}
}
return dirtyRoads;
}
/**
* 迭代获取子流程脏路线
* 说明，假如回退的点就是子流程，那么也肯定会回退到子流程最初的用户任务节点，因此子流程中的节点全是脏路线
* @param source 起始节点
* @param hasSequenceFlow 已经经过的连线的 ID，用于判断线路是否重复
* @param dirtyRoads 确定为脏数据的点，因为不需要重复，因此使用 set 存储
* @return
*/
public static Set<String> findChildProcessAllDirtyRoad(FlowElement source, Set<String> hasSequenceFlow, Set<String> dirtyRoads) {
hasSequenceFlow = hasSequenceFlow == null ? new HashSet<>() : hasSequenceFlow;
dirtyRoads = dirtyRoads == null ? new HashSet<>() : dirtyRoads;
// 根据类型，获取出口连线
List<SequenceFlow> sequenceFlows = getElementOutgoingFlows(source);
if (sequenceFlows != null) {
// 循环找到目标元素
for (SequenceFlow sequenceFlow: sequenceFlows) {
// 如果发现连线重复，说明循环了，跳过这个循环
if (hasSequenceFlow.contains(sequenceFlow.getId())) {
continue;
}
// 添加已经走过的连线
hasSequenceFlow.add(sequenceFlow.getId());
// 添加脏路线
dirtyRoads.add(sequenceFlow.getTargetFlowElement().getId());
// 如果节点为子流程节点情况，则从节点中的第一个节点开始获取
if (sequenceFlow.getTargetFlowElement() instanceof SubProcess) {
dirtyRoads = findChildProcessAllDirtyRoad((FlowElement) (((SubProcess) sequenceFlow.getTargetFlowElement()).getFlowElements().toArray()[0]), hasSequenceFlow, dirtyRoads);
}
// 继续迭代
dirtyRoads = findChildProcessAllDirtyRoad(sequenceFlow.getTargetFlowElement(), hasSequenceFlow, dirtyRoads);
}
}
return dirtyRoads;
}
/**
* 判断脏路线结束节点是否在子流程上
* @param source 起始节点
* @param hasSequenceFlow 已经经过的连线的 ID，用于判断线路是否重复
* @param targets 判断脏路线节点是否存在子流程上，只要存在一个，说明脏路线只到子流程为止
* @param inChildProcess 是否存在子流程上，true 是，false 否
* @return
*/
public static Boolean dirtyTargetInChildProcess(FlowElement source, Set<String> hasSequenceFlow, List<String> targets, Boolean inChildProcess) {
hasSequenceFlow = hasSequenceFlow == null ? new HashSet<>() : hasSequenceFlow;
inChildProcess = inChildProcess != null && inChildProcess;
// 根据类型，获取出口连线
List<SequenceFlow> sequenceFlows = getElementOutgoingFlows(source);
if (sequenceFlows != null && !inChildProcess) {
// 循环找到目标元素
for (SequenceFlow sequenceFlow: sequenceFlows) {
// 如果发现连线重复，说明循环了，跳过这个循环
if (hasSequenceFlow.contains(sequenceFlow.getId())) {
continue;
}
// 添加已经走过的连线
hasSequenceFlow.add(sequenceFlow.getId());
// 如果发现目标点在子流程上存在，说明只到子流程为止
if (targets.contains(sequenceFlow.getTargetFlowElement().getId())) {
inChildProcess = true;
break;
}
// 如果节点为子流程节点情况，则从节点中的第一个节点开始获取
if (sequenceFlow.getTargetFlowElement() instanceof SubProcess) {
inChildProcess = dirtyTargetInChildProcess((FlowElement) (((SubProcess) sequenceFlow.getTargetFlowElement()).getFlowElements().toArray()[0]), hasSequenceFlow, targets, inChildProcess);
}
// 继续迭代
inChildProcess = dirtyTargetInChildProcess(sequenceFlow.getTargetFlowElement(), hasSequenceFlow, targets, inChildProcess);
}
}
return inChildProcess;
}
/**
* 迭代从后向前扫描，判断目标节点相对于当前节点是否是串行
* 不存在直接回退到子流程中的情况，但存在从子流程出去到父流程情况
* @param source 起始节点
* @param isSequential 是否串行
* @param hasSequenceFlow 已经经过的连线的 ID，用于判断线路是否重复
* @param targetKsy 目标节点
* @return
*/
public static Boolean iteratorCheckSequentialReferTarget(FlowElement source, String targetKsy, Set<String> hasSequenceFlow, Boolean isSequential) {
isSequential = isSequential == null || isSequential;
hasSequenceFlow = hasSequenceFlow == null ? new HashSet<>() : hasSequenceFlow;
// 如果该节点为开始节点，且存在上级子节点，则顺着上级子节点继续迭代
if (source instanceof StartEvent && source.getSubProcess() != null) {
isSequential = iteratorCheckSequentialReferTarget(source.getSubProcess(), targetKsy, hasSequenceFlow, isSequential);
}
// 根据类型，获取入口连线
List<SequenceFlow> sequenceFlows = getElementIncomingFlows(source);
if (sequenceFlows != null) {
// 循环找到目标元素
for (SequenceFlow sequenceFlow: sequenceFlows) {
// 如果发现连线重复，说明循环了，跳过这个循环
if (hasSequenceFlow.contains(sequenceFlow.getId())) {
continue;
}
// 添加已经走过的连线
hasSequenceFlow.add(sequenceFlow.getId());
// 如果目标节点已被判断为并行，后面都不需要执行，直接返回
if (!isSequential) {
break;
}
// 这条线路存在目标节点，这条线路完成，进入下个线路
if (targetKsy.equals(sequenceFlow.getSourceFlowElement().getId())) {
continue;
}
if (sequenceFlow.getSourceFlowElement() instanceof StartEvent) {
isSequential = false;
break;
}
// 否则就继续迭代
isSequential = iteratorCheckSequentialReferTarget(sequenceFlow.getSourceFlowElement(), targetKsy, hasSequenceFlow, isSequential);
}
}
return isSequential;
}
/**
* 从后向前寻路，获取到达节点的所有路线
* 不存在直接回退到子流程，但是存在回退到父级流程的情况
* @param source 起始节点
* @param passRoads 已经经过的点集合
* @param roads 路线
* @return
*/
public static List<List<UserTask>> findRoad(FlowElement source, List<UserTask> passRoads, Set<String> hasSequenceFlow, List<List<UserTask>> roads) {
passRoads = passRoads == null ? new ArrayList<>() : passRoads;
roads = roads == null ? new ArrayList<>() : roads;
hasSequenceFlow = hasSequenceFlow == null ? new HashSet<>() : hasSequenceFlow;
// 如果该节点为开始节点，且存在上级子节点，则顺着上级子节点继续迭代
if (source instanceof StartEvent && source.getSubProcess() != null) {
roads = findRoad(source.getSubProcess(), passRoads, hasSequenceFlow, roads);
}
// 根据类型，获取入口连线
List<SequenceFlow> sequenceFlows = getElementIncomingFlows(source);
if (sequenceFlows != null && sequenceFlows.size() != 0) {
for (SequenceFlow sequenceFlow: sequenceFlows) {
// 如果发现连线重复，说明循环了，跳过这个循环
if (hasSequenceFlow.contains(sequenceFlow.getId())) {
continue;
}
// 添加已经走过的连线
hasSequenceFlow.add(sequenceFlow.getId());
// 添加经过路线
if (sequenceFlow.getSourceFlowElement() instanceof UserTask) {
passRoads.add((UserTask) sequenceFlow.getSourceFlowElement());
}
// 继续迭代
roads = findRoad(sequenceFlow.getSourceFlowElement(), passRoads, hasSequenceFlow, roads);
}
} else {
// 添加路线
roads.add(passRoads);
}
return roads;
}
/**
* 历史节点数据清洗，清洗掉又回滚导致的脏数据
* @param allElements 全部节点信息
* @param historicTaskInstanceList 历史任务实例信息，数据采用开始时间升序
* @return
*/
public static List<String> historicTaskInstanceClean(Collection<FlowElement> allElements, List<HistoricTaskInstance> historicTaskInstanceList) {
// 会签节点收集
List<String> multiTask = new ArrayList<>();
allElements.forEach(flowElement -> {
if (flowElement instanceof UserTask) {
// 如果该节点的行为为会签行为，说明该节点为会签节点
if (((UserTask) flowElement).getBehavior() instanceof ParallelMultiInstanceBehavior || ((UserTask) flowElement).getBehavior() instanceof SequentialMultiInstanceBehavior) {
multiTask.add(flowElement.getId());
}
}
});
// 循环放入栈，栈 LIFO：后进先出
Stack<HistoricTaskInstance> stack = new Stack<>();
historicTaskInstanceList.forEach(stack::push);
// 清洗后的历史任务实例
List<String> lastHistoricTaskInstanceList = new ArrayList<>();
// 网关存在可能只走了部分分支情况，且还存在跳转废弃数据以及其他分支数据的干扰，因此需要对历史节点数据进行清洗
// 临时用户任务 key
StringBuilder userTaskKey = null;
// 临时被删掉的任务 key，存在并行情况
List<String> deleteKeyList = new ArrayList<>();
// 临时脏数据线路
List<Set<String>> dirtyDataLineList = new ArrayList<>();
// 由某个点跳到会签点,此时出现多个会签实例对应 1 个跳转情况，需要把这些连续脏数据都找到
// 会签特殊处理下标
int multiIndex = -1;
// 会签特殊处理 key
StringBuilder multiKey = null;
// 会签特殊处理操作标识
boolean multiOpera = false;
while (!stack.empty()) {
// 从这里开始 userTaskKey 都还是上个栈的 key
// 是否是脏数据线路上的点
final boolean[] isDirtyData = {false};
for (Set<String> oldDirtyDataLine : dirtyDataLineList) {
if (oldDirtyDataLine.contains(stack.peek().getTaskDefinitionKey())) {
isDirtyData[0] = true;
}
}
// 删除原因不为空，说明从这条数据开始回跳或者回退的
// MI_END：会签完成后，其他未签到节点的删除原因，不在处理范围内
if (stack.peek().getDeleteReason() != null && !"MI_END".equals(stack.peek().getDeleteReason())) {
// 可以理解为脏线路起点
String dirtyPoint = "";
if (stack.peek().getDeleteReason().contains("Change activity to ")) {
dirtyPoint = stack.peek().getDeleteReason().replace("Change activity to ", "");
}
// 会签回退删除原因有点不同
if (stack.peek().getDeleteReason().contains("Change parent activity to ")) {
dirtyPoint = stack.peek().getDeleteReason().replace("Change parent activity to ", "");
}
FlowElement dirtyTask = null;
// 获取变更节点的对应的入口处连线
// 如果是网关并行回退情况，会变成两条脏数据路线，效果一样
for (FlowElement flowElement : allElements) {
if (flowElement.getId().equals(stack.peek().getTaskDefinitionKey())) {
dirtyTask = flowElement;
}
}
// 获取脏数据线路
Set<String> dirtyDataLine = FlowableUtils.iteratorFindDirtyRoads(dirtyTask, null, null, Arrays.asList(dirtyPoint.split(",")), null);
// 自己本身也是脏线路上的点，加进去
dirtyDataLine.add(stack.peek().getTaskDefinitionKey());
log.info(stack.peek().getTaskDefinitionKey() + "点脏路线集合：" + dirtyDataLine);
// 是全新的需要添加的脏线路
boolean isNewDirtyData = true;
for (int i = 0; i < dirtyDataLineList.size(); i++) {
// 如果发现他的上个节点在脏线路内，说明这个点可能是并行的节点，或者连续驳回
// 这时，都以之前的脏线路节点为标准，只需合并脏线路即可，也就是路线补全
if (dirtyDataLineList.get(i).contains(userTaskKey.toString())) {
isNewDirtyData = false;
dirtyDataLineList.get(i).addAll(dirtyDataLine);
}
}
// 已确定时全新的脏线路
if (isNewDirtyData) {
// deleteKey 单一路线驳回到并行，这种同时生成多个新实例记录情况，这时 deleteKey 其实是由多个值组成
// 按照逻辑，回退后立刻生成的实例记录就是回退的记录
// 至于驳回所生成的 Key，直接从删除原因中获取，因为存在驳回到并行的情况
deleteKeyList.add(dirtyPoint + ",");
dirtyDataLineList.add(dirtyDataLine);
}
// 添加后，现在这个点变成脏线路上的点了
isDirtyData[0] = true;
}
// 如果不是脏线路上的点，说明是有效数据，添加历史实例 Key
if (!isDirtyData[0]) {
lastHistoricTaskInstanceList.add(stack.peek().getTaskDefinitionKey());
}
// 校验脏线路是否结束
for (int i = 0; i < deleteKeyList.size(); i ++) {
// 如果发现脏数据属于会签，记录下下标与对应 Key，以备后续比对，会签脏数据范畴开始
if (multiKey == null && multiTask.contains(stack.peek().getTaskDefinitionKey())
&& deleteKeyList.get(i).contains(stack.peek().getTaskDefinitionKey())) {
multiIndex = i;
multiKey = new StringBuilder(stack.peek().getTaskDefinitionKey());
}
// 会签脏数据处理，节点退回会签清空
// 如果在会签脏数据范畴中发现 Key改变，说明会签脏数据在上个节点就结束了，可以把会签脏数据删掉
if (multiKey != null && !multiKey.toString().equals(stack.peek().getTaskDefinitionKey())) {
deleteKeyList.set(multiIndex , deleteKeyList.get(multiIndex).replace(stack.peek().getTaskDefinitionKey() + ",", ""));
multiKey = null;
// 结束进行下校验删除
multiOpera = true;
}
// 其他脏数据处理
// 发现该路线最后一条脏数据，说明这条脏数据线路处理完了，删除脏数据信息
// 脏数据产生的新实例中是否包含这条数据
if (multiKey == null && deleteKeyList.get(i).contains(stack.peek().getTaskDefinitionKey())) {
// 删除匹配到的部分
deleteKeyList.set(i , deleteKeyList.get(i).replace(stack.peek().getTaskDefinitionKey() + ",", ""));
}
// 如果每组中的元素都以匹配过，说明脏数据结束
if ("".equals(deleteKeyList.get(i))) {
// 同时删除脏数据
deleteKeyList.remove(i);
dirtyDataLineList.remove(i);
break;
}
}
// 会签数据处理需要在循环外处理，否则可能导致溢出
// 会签的数据肯定是之前放进去的所以理论上不会溢出，但还是校验下
if (multiOpera && deleteKeyList.size() > multiIndex && "".equals(deleteKeyList.get(multiIndex))) {
// 同时删除脏数据
deleteKeyList.remove(multiIndex);
dirtyDataLineList.remove(multiIndex);
multiIndex = -1;
multiOpera = false;
}
// pop() 方法与 peek() 方法不同，在返回值的同时，会把值从栈中移除
// 保存新的 userTaskKey 在下个循环中使用
userTaskKey = new StringBuilder(stack.pop().getTaskDefinitionKey());
}
log.info("清洗后的历史节点数据：" + lastHistoricTaskInstanceList);
return lastHistoricTaskInstanceList;
}
}

372
yanzhu-flowable/src/main/java/com/yanzhu/flowable/flow/ModelUtils.java
View File

@ -1,372 +0,0 @@
package com.yanzhu.flowable.flow;
import com.yanzhu.common.utils.StringUtils;
import org.flowable.bpmn.converter.BpmnXMLConverter;
import org.flowable.bpmn.model.Process;
import org.flowable.bpmn.model.*;
import org.flowable.common.engine.impl.util.io.StringStreamSource;
import java.util.*;
/**
* @author KonBAI
* @createTime 2022/3/26 19:04
*/
public class ModelUtils {
private static final BpmnXMLConverter bpmnXMLConverter = new BpmnXMLConverter();
/**
* xml转bpmnModel对象
*
* @param xml xml
* @return bpmnModel对象
*/
public static BpmnModel getBpmnModel(String xml) {
return bpmnXMLConverter.convertToBpmnModel(new StringStreamSource(xml), false, false);
}
/**
* bpmnModel转xml字符串
*
* @deprecated 存在会丢失 bpmn 连线问题
* @param bpmnModel bpmnModel对象
* @return xml字符串
*/
@Deprecated
public static String getBpmnXmlStr(BpmnModel bpmnModel) {
return StringUtils.utf8Str(getBpmnXml(bpmnModel));
}
/**
* bpmnModel转xml对象
*
* @deprecated 存在丢失 bpmn 连线问题
* @param bpmnModel bpmnModel对象
* @return xml
*/
@Deprecated
public static byte[] getBpmnXml(BpmnModel bpmnModel) {
return bpmnXMLConverter.convertToXML(bpmnModel);
}
/**
* 根据节点，获取入口连线
*
* @param source 起始节点
* @return 入口连线列表
*/
public static List<SequenceFlow> getElementIncomingFlows(FlowElement source) {
List<SequenceFlow> sequenceFlows = new ArrayList<>();
if (source instanceof FlowNode) {
sequenceFlows = ((FlowNode) source).getIncomingFlows();
}
return sequenceFlows;
}
/**
* 根据节点，获取出口连线
*
* @param source 起始节点
* @return 出口连线列表
*/
public static List<SequenceFlow> getElementOutgoingFlows(FlowElement source) {
List<SequenceFlow> sequenceFlows = new ArrayList<>();
if (source instanceof FlowNode) {
sequenceFlows = ((FlowNode) source).getOutgoingFlows();
}
return sequenceFlows;
}
/**
* 获取开始节点
*
* @param model bpmnModel对象
* @return 开始节点（未找到开始节点，返回null）
*/
public static StartEvent getStartEvent(BpmnModel model) {
Process process = model.getMainProcess();
FlowElement startElement = process.getInitialFlowElement();
if (startElement instanceof StartEvent) {
return (StartEvent) startElement;
}
return getStartEvent(process.getFlowElements());
}
/**
* 获取开始节点
*
* @param flowElements 流程元素集合
* @return 开始节点（未找到开始节点，返回null）
*/
public static StartEvent getStartEvent(Collection<FlowElement> flowElements) {
for (FlowElement flowElement : flowElements) {
if (flowElement instanceof StartEvent) {
return (StartEvent) flowElement;
}
}
return null;
}
/**
* 获取结束节点
*
* @param model bpmnModel对象
* @return 结束节点（未找到开始节点，返回null）
*/
public static EndEvent getEndEvent(BpmnModel model) {
Process process = model.getMainProcess();
return getEndEvent(process.getFlowElements());
}
/**
* 获取结束节点
*
* @param flowElements 流程元素集合
* @return 结束节点（未找到开始节点，返回null）
*/
public static EndEvent getEndEvent(Collection<FlowElement> flowElements) {
for (FlowElement flowElement : flowElements) {
if (flowElement instanceof EndEvent) {
return (EndEvent) flowElement;
}
}
return null;
}
public static UserTask getUserTaskByKey(BpmnModel model, String taskKey) {
Process process = model.getMainProcess();
FlowElement flowElement = process.getFlowElement(taskKey);
if (flowElement instanceof UserTask) {
return (UserTask) flowElement;
}
return null;
}
/**
* 获取流程元素信息
*
* @param model bpmnModel对象
* @param flowElementId 元素ID
* @return 元素信息
*/
public static FlowElement getFlowElementById(BpmnModel model, String flowElementId) {
Process process = model.getMainProcess();
return process.getFlowElement(flowElementId);
}
/**
* 获取元素表单Key（限开始节点和用户节点可用）
*
* @param flowElement 元素
* @return 表单Key
*/
public static String getFormKey(FlowElement flowElement) {
if (flowElement != null) {
if (flowElement instanceof StartEvent) {
return ((StartEvent) flowElement).getFormKey();
} else if (flowElement instanceof UserTask) {
return ((UserTask) flowElement).getFormKey();
}
}
return null;
}
/**
* 获取开始节点属性值
* @param model bpmnModel对象
* @param name 属性名
* @return 属性值
*/
public static String getStartEventAttributeValue(BpmnModel model, String name) {
StartEvent startEvent = getStartEvent(model);
return getElementAttributeValue(startEvent, name);
}
/**
* 获取结束节点属性值
* @param model bpmnModel对象
* @param name 属性名
* @return 属性值
*/
public static String getEndEventAttributeValue(BpmnModel model, String name) {
EndEvent endEvent = getEndEvent(model);
return getElementAttributeValue(endEvent, name);
}
/**
* 获取用户任务节点属性值
* @param model bpmnModel对象
* @param taskKey 任务Key
* @param name 属性名
* @return 属性值
*/
public static String getUserTaskAttributeValue(BpmnModel model, String taskKey, String name) {
UserTask userTask = getUserTaskByKey(model, taskKey);
return getElementAttributeValue(userTask, name);
}
/**
* 获取元素属性值
* @param baseElement 流程元素
* @param name 属性名
* @return 属性值
*/
public static String getElementAttributeValue(BaseElement baseElement, String name) {
if (baseElement != null) {
List<ExtensionAttribute> attributes = baseElement.getAttributes().get(name);
if (attributes != null && !attributes.isEmpty()) {
attributes.iterator().next().getValue();
Iterator<ExtensionAttribute> attrIterator = attributes.iterator();
if(attrIterator.hasNext()) {
ExtensionAttribute attribute = attrIterator.next();
return attribute.getValue();
}
}
}
return null;
}
public static boolean isMultiInstance(BpmnModel model, String taskKey) {
UserTask userTask = getUserTaskByKey(model, taskKey);
if (!Objects.isNull(userTask)) {
return userTask.hasMultiInstanceLoopCharacteristics();
}
return false;
}
/**
* 获取所有用户任务节点
*
* @param model bpmnModel对象
* @return 用户任务节点列表
*/
public static Collection<UserTask> getAllUserTaskEvent(BpmnModel model) {
Process process = model.getMainProcess();
Collection<FlowElement> flowElements = process.getFlowElements();
return getAllUserTaskEvent(flowElements, null);
}
/**
* 获取所有用户任务节点
* @param flowElements 流程元素集合
* @param allElements 所有流程元素集合
* @return 用户任务节点列表
*/
public static Collection<UserTask> getAllUserTaskEvent(Collection<FlowElement> flowElements, Collection<UserTask> allElements) {
allElements = allElements == null ? new ArrayList<>() : allElements;
for (FlowElement flowElement : flowElements) {
if (flowElement instanceof UserTask) {
allElements.add((UserTask) flowElement);
}
if (flowElement instanceof SubProcess) {
// 继续深入子流程，进一步获取子流程
allElements = getAllUserTaskEvent(((SubProcess) flowElement).getFlowElements(), allElements);
}
}
return allElements;
}
/**
* 查找起始节点下一个用户任务列表列表
* @param source 起始节点
* @return 结果
*/
public static List<UserTask> findNextUserTasks(FlowElement source) {
return findNextUserTasks(source, null, null);
}
/**
* 查找起始节点下一个用户任务列表列表
* @param source 起始节点
* @param hasSequenceFlow 已经经过的连线的 ID，用于判断线路是否重复
* @param userTaskList 用户任务列表
* @return 结果
*/
public static List<UserTask> findNextUserTasks(FlowElement source, Set<String> hasSequenceFlow, List<UserTask> userTaskList) {
hasSequenceFlow = Optional.ofNullable(hasSequenceFlow).orElse(new HashSet<>());
userTaskList = Optional.ofNullable(userTaskList).orElse(new ArrayList<>());
// 获取出口连线
List<SequenceFlow> sequenceFlows = getElementOutgoingFlows(source);
if (!sequenceFlows.isEmpty()) {
for (SequenceFlow sequenceFlow : sequenceFlows) {
// 如果发现连线重复，说明循环了，跳过这个循环
if (hasSequenceFlow.contains(sequenceFlow.getId())) {
continue;
}
// 添加已经走过的连线
hasSequenceFlow.add(sequenceFlow.getId());
FlowElement targetFlowElement = sequenceFlow.getTargetFlowElement();
if (targetFlowElement instanceof UserTask) {
// 若节点为用户任务，加入到结果列表中
userTaskList.add((UserTask) targetFlowElement);
} else {
// 若节点非用户任务，继续递归查找下一个节点
findNextUserTasks(targetFlowElement, hasSequenceFlow, userTaskList);
}
}
}
return userTaskList;
}
/**
* 迭代从后向前扫描，判断目标节点相对于当前节点是否是串行
* 不存在直接回退到子流程中的情况，但存在从子流程出去到父流程情况
* @param source 起始节点
* @param target 目标节点
* @param visitedElements 已经经过的连线的 ID，用于判断线路是否重复
* @return 结果
*/
public static boolean isSequentialReachable(FlowElement source, FlowElement target, Set<String> visitedElements) {
visitedElements = visitedElements == null ? new HashSet<>() : visitedElements;
if (source instanceof StartEvent && isInEventSubprocess(source)) {
return false;
}
// 根据类型，获取入口连线
List<SequenceFlow> sequenceFlows = getElementIncomingFlows(source);
if (sequenceFlows != null && sequenceFlows.size() > 0) {
// 循环找到目标元素
for (SequenceFlow sequenceFlow: sequenceFlows) {
// 如果发现连线重复，说明循环了，跳过这个循环
if (visitedElements.contains(sequenceFlow.getId())) {
continue;
}
// 添加已经走过的连线
visitedElements.add(sequenceFlow.getId());
FlowElement sourceFlowElement = sequenceFlow.getSourceFlowElement();
// 这条线路存在目标节点，这条线路完成，进入下个线路
if (target.getId().equals(sourceFlowElement.getId())) {
continue;
}
// 如果目标节点为并行网关，则不继续
if (sourceFlowElement instanceof ParallelGateway) {
return false;
}
// 否则就继续迭代
boolean isSequential = isSequentialReachable(sourceFlowElement, target, visitedElements);
if (!isSequential) {
return false;
}
}
}
return true;
}
protected static boolean isInEventSubprocess(FlowElement flowElement) {
FlowElementsContainer flowElementsContainer = flowElement.getParentContainer();
while (flowElementsContainer != null) {
if (flowElementsContainer instanceof EventSubProcess) {
return true;
}
if (flowElementsContainer instanceof FlowElement) {
flowElementsContainer = ((FlowElement) flowElementsContainer).getParentContainer();
} else {
flowElementsContainer = null;
}
}
return false;
}
}

36
yanzhu-flowable/src/main/java/com/yanzhu/flowable/listener/FlowExecutionListener.java
View File

@ -1,36 +0,0 @@
package com.yanzhu.flowable.listener;
import lombok.extern.slf4j.Slf4j;
import org.flowable.common.engine.api.delegate.Expression;
import org.flowable.engine.delegate.DelegateExecution;
import org.flowable.engine.delegate.ExecutionListener;
import org.springframework.stereotype.Component;
/**
* 执行监听器
*
* 执行监听器允许在执行过程中执行Java代码。
* 执行监听器可以捕获事件的类型：
* 流程实例启动，结束
* 输出流捕获
* 获取启动，结束
* 路由开始，结束
* 中间事件开始，结束
* 触发开始事件，触发结束事件
*
* @author Tony
* @date 2022/12/16
*/
@Slf4j
@Component
public class FlowExecutionListener implements ExecutionListener {
/**
* 流程设计器添加的参数
*/
private Expression param;
@Override
public void notify(DelegateExecution execution) {
log.info("执行监听器:{}", execution);
}
}

29
yanzhu-flowable/src/main/java/com/yanzhu/flowable/listener/FlowTaskEndListener.java
View File

@ -1,29 +0,0 @@
package com.yanzhu.flowable.listener;
import lombok.extern.slf4j.Slf4j;
import org.flowable.engine.delegate.DelegateExecution;
import org.flowable.engine.delegate.ExecutionListener;
import org.flowable.engine.delegate.TaskListener;
import org.flowable.task.service.delegate.DelegateTask;
import org.springframework.stereotype.Component;
/**
* 任务监听器
*
* create（创建）:在任务被创建且所有的任务属性设置完成后才触发
* assignment（指派）：在任务被分配给某个办理人之后触发
* complete（完成）：在配置了监听器的上一个任务完成时触发
* delete（删除）：在任务即将被删除前触发。请注意任务由completeTask正常完成时也会触发
*
* @author Tony
* @date 2021/4/20
*/
@Slf4j
@Component
public class FlowTaskEndListener implements ExecutionListener {
@Override
public void notify(DelegateExecution delegateExecution) {
log.info("任务结束监听器:{}", delegateExecution);
}
}

29
yanzhu-flowable/src/main/java/com/yanzhu/flowable/listener/FlowTaskListener.java
View File

@ -1,29 +0,0 @@
package com.yanzhu.flowable.listener;
import lombok.extern.slf4j.Slf4j;
import org.flowable.engine.delegate.TaskListener;
import org.flowable.task.service.delegate.DelegateTask;
import org.springframework.stereotype.Component;
/**
* 任务监听器
*
* create（创建）:在任务被创建且所有的任务属性设置完成后才触发
* assignment（指派）：在任务被分配给某个办理人之后触发
* complete（完成）：在配置了监听器的上一个任务完成时触发
* delete（删除）：在任务即将被删除前触发。请注意任务由completeTask正常完成时也会触发
*
* @author Tony
* @date 2021/4/20
*/
@Slf4j
@Component
public class FlowTaskListener implements TaskListener{
@Override
public void notify(DelegateTask delegateTask) {
log.info("任务监听器:{}", delegateTask);
// TODO 获取事件类型 delegateTask.getEventName(),可以通过监听器给任务执行人发送相应的通知消息
}
}

56
yanzhu-flowable/src/main/java/com/yanzhu/flowable/service/IFlowBusinessKeyService.java
View File

@ -1,56 +0,0 @@
package com.yanzhu.flowable.service;
import com.yanzhu.system.domain.flowable.FlowTaskEntity;
import java.util.List;
import java.util.Map;
/**
* @author JiangYuQi
* @date 2021-04-03 14:41
*/
public interface IFlowBusinessKeyService {
/**
* 根据条件查询所有流任务
* @param flowTaskEntity
* @return
*/
public List<FlowTaskEntity> selectAllFlowTaskByParams(FlowTaskEntity flowTaskEntity);
/**
* 根据条件统计所有流任务
* @param flowTaskEntity
* @return
*/
public Map<String,Object> quueryCount(FlowTaskEntity flowTaskEntity);
/**
* 根据条件流程Id查询操作日志
* @param procInsId
* @return
*/
public List<Map<String, Object>> selectCommentByProcInsId(String procInsId);
/**
* 根据流程Id查询表单数据
* @param procInsId
* @return
*/
public Map<String, Object> selectFormDatasByProcInsId(String procInsId);
/**
* 查询我的代办任务
* @param flowTaskEntity
* @return
*/
public List<Map<String, Object>> selectMyAwaitFlowTask(FlowTaskEntity flowTaskEntity);
/**
* 查询我的已办任务
* @param flowTaskEntity
* @return
*/
public List<Map<String, Object>> selectMyFinishedFlowTask(FlowTaskEntity flowTaskEntity);
}

76
yanzhu-flowable/src/main/java/com/yanzhu/flowable/service/IFlowDefinitionService.java
View File

@ -1,76 +0,0 @@
package com.yanzhu.flowable.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yanzhu.common.core.domain.AjaxResult;
import com.yanzhu.system.domain.FlowProcDefDto;
import com.yanzhu.system.domain.flowable.FlowQueryVo;
import java.io.IOException;
import java.io.InputStream;
/**
* @author Tony
* @date 2021-04-03 14:41
*/
public interface IFlowDefinitionService {
boolean exist(String processDefinitionKey);
/**
* 流程定义列表
*
* @param flowQueryVo 流程查询
* @return 流程定义分页列表数据
*/
Page<FlowProcDefDto> list(FlowQueryVo flowQueryVo);
/**
* 导入流程文件
* 当每个key的流程第一次部署时，指定版本为1。对其后所有使用相同key的流程定义，
* 部署时版本会在该key当前已部署的最高版本号基础上加1。key参数用于区分流程定义
* @param name
* @param category
* @param in
*/
void importFile(String name, String category, String OwnerDeptId, InputStream in);
/**
* 读取xml
* @param deployId
* @return
*/
AjaxResult readXml(String deployId) throws IOException;
/**
* 根据流程定义ID启动流程实例
*
* @param procDefId 流程ID
* @return
*/
AjaxResult startProcessInstanceById(String procDefId);
/**
* 激活或挂起流程定义
*
* @param state 状态
* @param deployId 流程部署ID
*/
void updateState(Integer state, String deployId);
/**
* 删除流程定义
*
* @param deployId 流程部署ID act_ge_bytearray 表中 deployment_id值
*/
void delete(String deployId);
/**
* 读取图片文件
* @param deployId
* @return
*/
InputStream readImage(String deployId);
}

54
yanzhu-flowable/src/main/java/com/yanzhu/flowable/service/IFlowInstanceService.java
View File

@ -1,54 +0,0 @@
package com.yanzhu.flowable.service;
import com.yanzhu.common.core.domain.AjaxResult;
import com.yanzhu.flowable.domain.FlowTaskVo;
import org.flowable.engine.history.HistoricProcessInstance;
import java.util.Map;
/**
* @author Tony
* @date 2021-04-03 14:40
*/
public interface IFlowInstanceService {
/**
* 结束流程实例
*
* @param vo
*/
void stopProcessInstance(FlowTaskVo vo);
/**
* 激活或挂起流程实例
*
* @param state 状态
* @param instanceId 流程实例ID
*/
void updateState(Integer state, String instanceId);
/**
* 删除流程实例ID
*
* @param instanceId 流程实例ID
* @param deleteReason 删除原因
*/
void delete(String instanceId, String deleteReason);
/**
* 根据实例ID查询历史实例数据
*
* @param processInstanceId
* @return
*/
HistoricProcessInstance getHistoricProcessInstanceById(String processInstanceId);
/**
* 根据流程定义ID启动流程实例
*
* @param procDefId 流程定义Id
* @param variables 流程变量
* @return
*/
AjaxResult startProcessInstanceById(String procDefId, Map<String, Object> variables);
}

208
yanzhu-flowable/src/main/java/com/yanzhu/flowable/service/IFlowTaskService.java
View File

@ -1,208 +0,0 @@
package com.yanzhu.flowable.service;
import com.yanzhu.common.core.domain.AjaxResult;
import com.yanzhu.system.domain.flowable.FlowQueryVo;
import com.yanzhu.flowable.domain.FlowTaskVo;
import org.flowable.task.api.Task;
import java.io.InputStream;
/**
* @author Tony
* @date 2021-04-03 14:42
*/
public interface IFlowTaskService {
/**
* 审批任务
*
* @param task 请求实体参数
*/
AjaxResult complete(FlowTaskVo task);
/**
* 驳回任务
*
* @param flowTaskVo
*/
void taskReject(FlowTaskVo flowTaskVo);
/**
* 退回任务
*
* @param flowTaskVo 请求实体参数
*/
void taskReturn(FlowTaskVo flowTaskVo);
/**
* 获取所有可回退的节点
*
* @param flowTaskVo
* @return
*/
AjaxResult findReturnTaskList(FlowTaskVo flowTaskVo);
/**
* 删除任务
*
* @param flowTaskVo 请求实体参数
*/
void deleteTask(FlowTaskVo flowTaskVo);
/**
* 认领/签收任务
*
* @param flowTaskVo 请求实体参数
*/
void claim(FlowTaskVo flowTaskVo);
/**
* 取消认领/签收任务
*
* @param flowTaskVo 请求实体参数
*/
void unClaim(FlowTaskVo flowTaskVo);
/**
* 委派任务
*
* @param flowTaskVo 请求实体参数
*/
void delegateTask(FlowTaskVo flowTaskVo);
/**
* 任务归还
*
* @param flowTaskVo 请求实体参数
*/
void resolveTask(FlowTaskVo flowTaskVo);
/**
* 转办任务
*
* @param flowTaskVo 请求实体参数
*/
void assignTask(FlowTaskVo flowTaskVo);
/**
* 多实例加签
* @param flowTaskVo
*/
void addMultiInstanceExecution(FlowTaskVo flowTaskVo);
/**
* 多实例减签
* @param flowTaskVo
*/
void deleteMultiInstanceExecution(FlowTaskVo flowTaskVo);
/**
* 我发起的流程
* @param queryVo 请求参数
* @return
*/
AjaxResult myProcess(FlowQueryVo queryVo);
/**
* 取消申请
* 目前实现方式: 直接将当前流程变更为已完成
* @param flowTaskVo
* @return
*/
AjaxResult stopProcess(FlowTaskVo flowTaskVo);
/**
* 撤回流程
* @param flowTaskVo
* @return
*/
AjaxResult revokeProcess(FlowTaskVo flowTaskVo);
/**
* 代办任务列表
*
* @param queryVo 请求参数
* @return
*/
AjaxResult todoList(FlowQueryVo queryVo);
/**
* 已办任务列表
*
* @param queryVo 请求参数
* @return
*/
AjaxResult finishedList(FlowQueryVo queryVo);
/**
* 流程历史流转记录
*
* @param procInsId 流程实例Id
* @return
*/
AjaxResult flowRecord(String procInsId,String deployId);
/**
* 根据任务ID查询挂载的表单信息
*
* @param taskId 任务Id
* @return
*/
Task getTaskForm(String taskId);
/**
* 获取流程过程图
* @param processId
* @return
*/
InputStream diagram(String processId);
/**
* 获取流程执行节点
* @param procInsId
* @return
*/
AjaxResult getFlowViewer(String procInsId,String executionId);
/**
* 获取流程变量
* @param taskId
* @return
*/
AjaxResult processVariables(String taskId);
/**
* 获取下一节点
* @param flowTaskVo 任务
* @return
*/
AjaxResult getNextFlowNode(FlowTaskVo flowTaskVo);
AjaxResult getNextFlowNodeByStart(FlowTaskVo flowTaskVo);
/**
* 流程初始化表单
* @param deployId
* @return
*/
AjaxResult flowFormData(String deployId);
/**
* 流程节点信息
* @param procInsId
* @return
*/
AjaxResult flowXmlAndNode(String procInsId,String deployId);
/**
* 流程节点表单
* @param taskId 流程任务编号
* @return
*/
AjaxResult flowTaskForm(String taskId) throws Exception;
}

69
yanzhu-flowable/src/main/java/com/yanzhu/flowable/service/ISysDeployFormService.java
View File

@ -1,69 +0,0 @@
package com.yanzhu.flowable.service;
import java.util.List;
import com.yanzhu.system.domain.SysDeployForm;
import com.yanzhu.system.domain.SysForm;
/**
* 流程实例关联表单Service接口
*
* @author Tony
* @date 2021-04-03
*/
public interface ISysDeployFormService
{
/**
* 查询流程实例关联表单
*
* @param id 流程实例关联表单ID
* @return 流程实例关联表单
*/
public SysDeployForm selectSysDeployFormById(Long id);
/**
* 查询流程实例关联表单列表
*
* @param sysDeployForm 流程实例关联表单
* @return 流程实例关联表单集合
*/
public List<SysDeployForm> selectSysDeployFormList(SysDeployForm sysDeployForm);
/**
* 新增流程实例关联表单
*
* @param sysDeployForm 流程实例关联表单
* @return 结果
*/
public int insertSysDeployForm(SysDeployForm sysDeployForm);
/**
* 修改流程实例关联表单
*
* @param sysDeployForm 流程实例关联表单
* @return 结果
*/
public int updateSysDeployForm(SysDeployForm sysDeployForm);
/**
* 批量删除流程实例关联表单
*
* @param ids 需要删除的流程实例关联表单ID
* @return 结果
*/
public int deleteSysDeployFormByIds(Long[] ids);
/**
* 删除流程实例关联表单信息
*
* @param id 流程实例关联表单ID
* @return 结果
*/
public int deleteSysDeployFormById(Long id);
/**
* 查询流程挂着的表单
* @param deployId
* @return
*/
SysForm selectSysDeployFormByDeployId(String deployId);
}

60
yanzhu-flowable/src/main/java/com/yanzhu/flowable/service/ISysFormService.java
View File

@ -1,60 +0,0 @@
package com.yanzhu.flowable.service;
import java.util.List;
import com.yanzhu.system.domain.SysForm;
/**
* 表单
* @author Tony
* @date 2021-04-03
*/
public interface ISysFormService
{
/**
* 查询流程表单
*
* @param formId 流程表单ID
* @return 流程表单
*/
public SysForm selectSysFormById(Long formId);
/**
* 查询流程表单列表
*
* @param sysForm 流程表单
* @return 流程表单集合
*/
public List<SysForm> selectSysFormList(SysForm sysForm);
/**
* 新增流程表单
*
* @param sysForm 流程表单
* @return 结果
*/
public int insertSysForm(SysForm sysForm);
/**
* 修改流程表单
*
* @param sysForm 流程表单
* @return 结果
*/
public int updateSysForm(SysForm sysForm);
/**
* 批量删除流程表单
*
* @param formIds 需要删除的流程表单ID
* @return 结果
*/
public int deleteSysFormByIds(Long[] formIds);
/**
* 删除流程表单信息
*
* @param formId 流程表单ID
* @return 结果
*/
public int deleteSysFormById(Long formId);
}

62
yanzhu-flowable/src/main/java/com/yanzhu/flowable/service/ISysTaskFormService.java
View File

@ -1,62 +0,0 @@
package com.yanzhu.flowable.service;
import com.yanzhu.system.domain.SysTaskForm;
import java.util.List;
/**
* 流程任务关联单Service接口
*
* @author Tony
* @date 2021-04-03
*/
@Deprecated
public interface ISysTaskFormService {
/**
* 查询流程任务关联单
*
* @param id 流程任务关联单ID
* @return 流程任务关联单
*/
public SysTaskForm selectSysTaskFormById(Long id);
/**
* 查询流程任务关联单列表
*
* @param sysTaskForm 流程任务关联单
* @return 流程任务关联单集合
*/
public List<SysTaskForm> selectSysTaskFormList(SysTaskForm sysTaskForm);
/**
* 新增流程任务关联单
*
* @param sysTaskForm 流程任务关联单
* @return 结果
*/
public int insertSysTaskForm(SysTaskForm sysTaskForm);
/**
* 修改流程任务关联单
*
* @param sysTaskForm 流程任务关联单
* @return 结果
*/
public int updateSysTaskForm(SysTaskForm sysTaskForm);
/**
* 批量删除流程任务关联单
*
* @param ids 需要删除的流程任务关联单ID
* @return 结果
*/
public int deleteSysTaskFormByIds(Long[] ids);
/**
* 删除流程任务关联单信息
*
* @param id 流程任务关联单ID
* @return 结果
*/
public int deleteSysTaskFormById(Long id);
}

102
yanzhu-flowable/src/main/java/com/yanzhu/flowable/service/impl/FlowBusinessKeyServiceImpl.java
View File

@ -1,102 +0,0 @@
package com.yanzhu.flowable.service.impl;
import com.yanzhu.common.core.text.Convert;
import com.yanzhu.flowable.service.IFlowBusinessKeyService;
import com.yanzhu.system.domain.flowable.FlowTaskEntity;
import com.yanzhu.system.mapper.FlowBusinessKeyMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* 业务工作流程自定义
*
* @author Tony
* @date 2021-04-03
*/
@Service
@Slf4j
public class FlowBusinessKeyServiceImpl implements IFlowBusinessKeyService {
@Resource
private FlowBusinessKeyMapper flowBusinessKeyMapper;
/**
* 根据条件查询所有流任务
* @param flowTaskEntity
* @return
*/
@Override
public List<FlowTaskEntity> selectAllFlowTaskByParams(FlowTaskEntity flowTaskEntity) {
return flowBusinessKeyMapper.selectAllFlowTaskByParams(flowTaskEntity);
}
/**
* 根据条件统计所有流任务
* @param flowTaskEntity
* @return
*/
@Override
public Map<String,Object> quueryCount(FlowTaskEntity flowTaskEntity) {
flowTaskEntity.setActiveName("await");
int awaitSize = flowBusinessKeyMapper.selectAllFlowTaskByParams(flowTaskEntity).size();
flowTaskEntity.setActiveName("finished");
int finishedSize = flowBusinessKeyMapper.selectAllFlowTaskByParams(flowTaskEntity).size();
Map<String, Object> dataMap = new HashMap<>();
dataMap.put("await",awaitSize);
dataMap.put("finished",finishedSize);
return dataMap;
}
/**
* 根据条件流程Id查询操作日志
* @param procInsId
* @return
*/
@Override
public List<Map<String, Object>> selectCommentByProcInsId(String procInsId) {
return flowBusinessKeyMapper.selectCommentByProcInsId(procInsId);
}
/**
* 根据流程Id查询表单数据
* @param procInsId
* @return
*/
@Override
public Map<String, Object> selectFormDatasByProcInsId(String procInsId) {
Map<String, Object> dataMap = new HashMap<>();
List<Map<String, Object>> list = flowBusinessKeyMapper.selectFormDatasByProcInsId(procInsId);
Iterator<Map<String, Object>> it = list.iterator();
while (it.hasNext()) {
Map<String, Object> map = it.next();
dataMap.put(Convert.toStr(map.get("name")), map.get("text"));
}
return dataMap;
}
/**
* 查询我的代办任务
* @param flowTaskEntity
* @return
*/
@Override
public List<Map<String, Object>> selectMyAwaitFlowTask(FlowTaskEntity flowTaskEntity){
return flowBusinessKeyMapper.selectMyAwaitFlowTask(flowTaskEntity);
}
/**
* 查询我的已办任务
* @param flowTaskEntity
* @return
*/
@Override
public List<Map<String, Object>> selectMyFinishedFlowTask(FlowTaskEntity flowTaskEntity) {
return flowBusinessKeyMapper.selectMyFinishedFlowTask(flowTaskEntity);
}
}

258
yanzhu-flowable/src/main/java/com/yanzhu/flowable/service/impl/FlowDefinitionServiceImpl.java
View File

@ -1,258 +0,0 @@
package com.yanzhu.flowable.service.impl;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.yanzhu.common.core.domain.AjaxResult;
import com.yanzhu.common.core.domain.entity.SysUser;
import com.yanzhu.common.core.text.Convert;
import com.yanzhu.common.utils.SecurityUtils;
import com.yanzhu.common.utils.StringUtils;
import com.yanzhu.flowable.common.constant.ProcessConstants;
import com.yanzhu.flowable.common.enums.FlowComment;
import com.yanzhu.flowable.factory.FlowServiceFactory;
import com.yanzhu.flowable.service.IFlowDefinitionService;
import com.yanzhu.flowable.service.ISysDeployFormService;
import com.yanzhu.system.domain.FlowProcDefDto;
import com.yanzhu.system.domain.flowable.FlowDeptVo;
import com.yanzhu.system.domain.flowable.FlowQueryVo;
import com.yanzhu.system.mapper.FlowDeployMapper;
import com.yanzhu.system.service.ISysDeptService;
import com.yanzhu.system.service.ISysPostService;
import com.yanzhu.system.service.ISysUserService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.io.IOUtils;
import org.flowable.bpmn.model.BpmnModel;
import org.flowable.engine.repository.Deployment;
import org.flowable.engine.repository.ProcessDefinition;
import org.flowable.engine.repository.ProcessDefinitionQuery;
import org.flowable.engine.runtime.ProcessInstance;
import org.flowable.image.impl.DefaultProcessDiagramGenerator;
import org.flowable.task.api.Task;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.stream.Collectors;
/**
* 流程定义
*
* @author Tony
* @date 2021-04-03
*/
@Service
@Slf4j
public class FlowDefinitionServiceImpl extends FlowServiceFactory implements IFlowDefinitionService {
@Resource
private ISysDeployFormService sysDeployFormService;
@Resource
private ISysUserService sysUserService;
@Resource
private ISysDeptService sysDeptService;
@Resource
private ISysPostService postService;
@Resource
private FlowDeployMapper flowDeployMapper;
private static final String BPMN_FILE_SUFFIX = ".bpmn";
@Override
public boolean exist(String processDefinitionKey) {
ProcessDefinitionQuery processDefinitionQuery
= repositoryService.createProcessDefinitionQuery().processDefinitionKey(processDefinitionKey);
long count = processDefinitionQuery.count();
return count > 0 ? true : false;
}
/**
* 流程定义列表
*
* @param flowQueryVo 流程查询
* @return 流程定义分页列表数据
*/
@Override
public Page<FlowProcDefDto> list(FlowQueryVo flowQueryVo) {
Page<FlowProcDefDto> page = new Page<>();
PageHelper.startPage(flowQueryVo.getPageNum(), flowQueryVo.getPageSize());
List<FlowProcDefDto> dataList = flowDeployMapper.selectDeployList(flowQueryVo);
// 加载挂表单
/**for (FlowProcDefDto procDef : dataList) {
SysForm sysForm = sysDeployFormService.selectSysDeployFormByDeployId(procDef.getDeploymentId());
if (Objects.nonNull(sysForm)) {
procDef.setFormName(sysForm.getFormName());
procDef.setFormId(sysForm.getFormId());
}
}*/
if(flowQueryVo.getDeptId()!=null){
// 单位查询时::查询缺省工作流
List<String> categoryList = dataList.stream().map(FlowProcDefDto::getCategory).collect(Collectors.toList());
List<FlowProcDefDto> defaultList = flowDeployMapper.selectDefaultDeployList(categoryList);
if(CollectionUtils.isNotEmpty(defaultList)){
dataList.addAll(defaultList);
}
}
page.setTotal(new PageInfo(dataList).getTotal());
page.setRecords(dataList);
return page;
}
/**
* 导入流程文件
*
* 当每个key的流程第一次部署时，指定版本为1。对其后所有使用相同key的流程定义，
* 部署时版本会在该key当前已部署的最高版本号基础上加1。key参数用于区分流程定义
* @param name 流程名称
* @param category 流程类型
* @param OwnerDeptId 流程单位
* @param in 流程文件流
*/
@Override
public void importFile(String name, String category, String OwnerDeptId, InputStream in) {
Deployment deploy = repositoryService.createDeployment().addInputStream(name + BPMN_FILE_SUFFIX, in).name(name).category(category).deploy();
ProcessDefinition definition = repositoryService.createProcessDefinitionQuery().deploymentId(deploy.getId()).singleResult();
repositoryService.setProcessDefinitionCategory(definition.getId(), category);
/**新增流程单位关系**/
FlowDeptVo flowDeptVo = new FlowDeptVo();
flowDeptVo.setProcdefId(definition.getId());
//超管能为
if(SecurityUtils.isAdmin(SecurityUtils.getUserId())){
if(StringUtils.isNotEmpty(OwnerDeptId)){
// OwnerDeptId转换Long失败...默认返回null
flowDeptVo.setDeptId(Convert.toLong(OwnerDeptId));
}
}else{
// 从部门祖籍列表中获取项目单位信息...
Long projectDeptId = Convert.toLong(SecurityUtils.getLoginUser().getUser().getDept().getAncestors().split(",")[2]);
flowDeptVo.setDeptId(projectDeptId);
}
if(flowDeptVo.getDeptId()!=null){
flowDeployMapper.insertActReProcdefDept(flowDeptVo);
}
}
/**
* 读取xml
*
* @param deployId
* @return
*/
@Override
public AjaxResult readXml(String deployId) throws IOException {
ProcessDefinition definition = repositoryService.createProcessDefinitionQuery().deploymentId(deployId).singleResult();
InputStream inputStream = repositoryService.getResourceAsStream(definition.getDeploymentId(), definition.getResourceName());
String result = IOUtils.toString(inputStream, StandardCharsets.UTF_8.name());
return AjaxResult.success("", result);
}
/**
* 读取xml
*
* @param deployId
* @return
*/
@Override
public InputStream readImage(String deployId) {
ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().deploymentId(deployId).singleResult();
//获得图片流
DefaultProcessDiagramGenerator diagramGenerator = new DefaultProcessDiagramGenerator();
BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinition.getId());
//输出为图片
return diagramGenerator.generateDiagram(
bpmnModel,
"png",
Collections.emptyList(),
Collections.emptyList(),
"宋体",
"宋体",
"宋体",
null,
1.0,
false);
}
/**
* 根据流程定义ID启动流程实例
*
* @param procDefId 流程模板ID
* @return
*/
@Override
public AjaxResult startProcessInstanceById(String procDefId) {
try {
Map<String, Object> variables = new HashMap<>();
ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(procDefId)
.latestVersion().singleResult();
if (Objects.nonNull(processDefinition) && processDefinition.isSuspended()) {
return AjaxResult.error("流程已被挂起,请联系管理员激活流程");
}
SysUser sysUser = SecurityUtils.getLoginUser().getUser();
String userId = Convert.toStr(sysUser.getUserId());
// 设置流程发起人Id到流程中
identityService.setAuthenticatedUserId(userId);
variables.put(ProcessConstants.PROCESS_INITIATOR, userId);
variables.put("businessKey",null);
ProcessInstance processInstance;
if(variables.get("businessKey")!=null){
processInstance = runtimeService.startProcessInstanceById(procDefId, Convert.toStr(variables.get("businessKey")),variables);
}else{
processInstance = runtimeService.startProcessInstanceById(procDefId, variables);
}
// 给第一步申请人节点设置任务执行人和意见
Task task = taskService.createTaskQuery().processInstanceId(processInstance.getProcessInstanceId()).singleResult();
if (Objects.nonNull(task)) {
taskService.addComment(task.getId(), processInstance.getProcessInstanceId(), FlowComment.NORMAL.getType(), sysUser.getNickName() + "发起流程申请");
taskService.setAssignee(task.getId(), Convert.toStr(userId));
taskService.complete(task.getId(), variables);
}
return AjaxResult.success("流程启动成功");
} catch (Exception e) {
e.printStackTrace();
return AjaxResult.error("流程启动错误");
}
}
/**
* 激活或挂起流程定义
*
* @param state 状态
* @param deployId 流程部署ID
*/
@Override
public void updateState(Integer state, String deployId) {
ProcessDefinition procDef = repositoryService.createProcessDefinitionQuery().deploymentId(deployId).singleResult();
// 激活
if (state == 1) {
repositoryService.activateProcessDefinitionById(procDef.getId(), true, null);
}
// 挂起
if (state == 2) {
repositoryService.suspendProcessDefinitionById(procDef.getId(), true, null);
}
}
/**
* 删除流程定义
*
* @param deployId 流程部署ID act_ge_bytearray 表中 deployment_id值
*/
@Override
public void delete(String deployId) {
// true 允许级联删除 ,不设置会导致数据库外键关联异常
repositoryService.deleteDeployment(deployId, true);
}
}

118
yanzhu-flowable/src/main/java/com/yanzhu/flowable/service/impl/FlowInstanceServiceImpl.java
View File

@ -1,118 +0,0 @@
package com.yanzhu.flowable.service.impl;
import com.yanzhu.common.core.domain.AjaxResult;
import com.yanzhu.common.utils.SecurityUtils;
import com.yanzhu.flowable.domain.FlowTaskVo;
import com.yanzhu.flowable.factory.FlowServiceFactory;
import com.yanzhu.flowable.service.IFlowInstanceService;
import lombok.extern.slf4j.Slf4j;
import org.flowable.common.engine.api.FlowableObjectNotFoundException;
import org.flowable.engine.history.HistoricProcessInstance;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Map;
import java.util.Objects;
/**
* <p>工作流流程实例管理<p>
*
* @author Tony
* @date 2021-04-03
*/
@Service
@Slf4j
public class FlowInstanceServiceImpl extends FlowServiceFactory implements IFlowInstanceService {
/**
* 结束流程实例
*
* @param vo
*/
@Override
public void stopProcessInstance(FlowTaskVo vo) {
String taskId = vo.getTaskId();
}
/**
* 激活或挂起流程实例
*
* @param state 状态
* @param instanceId 流程实例ID
*/
@Override
public void updateState(Integer state, String instanceId) {
// 激活
if (state == 1) {
runtimeService.activateProcessInstanceById(instanceId);
}
// 挂起
if (state == 2) {
runtimeService.suspendProcessInstanceById(instanceId);
}
}
/**
* 删除流程实例ID
*
* @param instanceId 流程实例ID
* @param deleteReason 删除原因
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void delete(String instanceId, String deleteReason) {
// 查询历史数据
HistoricProcessInstance historicProcessInstance = getHistoricProcessInstanceById(instanceId);
if (historicProcessInstance.getEndTime() != null) {
historyService.deleteHistoricProcessInstance(historicProcessInstance.getId());
return;
}
// 删除流程实例
runtimeService.deleteProcessInstance(instanceId, deleteReason);
// 删除历史流程实例
historyService.deleteHistoricProcessInstance(instanceId);
}
/**
* 根据实例ID查询历史实例数据
*
* @param processInstanceId
* @return
*/
@Override
public HistoricProcessInstance getHistoricProcessInstanceById(String processInstanceId) {
HistoricProcessInstance historicProcessInstance =
historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
if (Objects.isNull(historicProcessInstance)) {
throw new FlowableObjectNotFoundException("流程实例不存在: " + processInstanceId);
}
return historicProcessInstance;
}
/**
* 根据流程定义ID启动流程实例
*
* @param procDefId 流程定义Id
* @param variables 流程变量
* @return
*/
@Override
public AjaxResult startProcessInstanceById(String procDefId, Map<String, Object> variables) {
try {
// 设置流程发起人Id到流程中
Long userId = SecurityUtils.getLoginUser().getUser().getUserId();
// identityService.setAuthenticatedUserId(userId.toString());
variables.put("initiator",userId);
variables.put("_FLOWABLE_SKIP_EXPRESSION_ENABLED", true);
runtimeService.startProcessInstanceById(procDefId, variables);
return AjaxResult.success("流程启动成功");
} catch (Exception e) {
e.printStackTrace();
return AjaxResult.error("流程启动错误");
}
}
}

1283
yanzhu-flowable/src/main/java/com/yanzhu/flowable/service/impl/FlowTaskServiceImpl.java
View File

File diff suppressed because it is too large Load Diff

112
yanzhu-flowable/src/main/java/com/yanzhu/flowable/service/impl/SysDeployFormServiceImpl.java
View File

@ -1,112 +0,0 @@
package com.yanzhu.flowable.service.impl;
import java.util.List;
import java.util.Objects;
import com.yanzhu.system.domain.SysForm;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.yanzhu.system.mapper.SysDeployFormMapper;
import com.yanzhu.system.domain.SysDeployForm;
import com.yanzhu.flowable.service.ISysDeployFormService;
/**
* 流程实例关联表单Service业务层处理
*
* @author Tony
* @date 2021-04-03
*/
@Service
public class SysDeployFormServiceImpl implements ISysDeployFormService
{
@Autowired
private SysDeployFormMapper sysDeployFormMapper;
/**
* 查询流程实例关联表单
*
* @param id 流程实例关联表单ID
* @return 流程实例关联表单
*/
@Override
public SysDeployForm selectSysDeployFormById(Long id)
{
return sysDeployFormMapper.selectSysDeployFormById(id);
}
/**
* 查询流程实例关联表单列表
*
* @param sysDeployForm 流程实例关联表单
* @return 流程实例关联表单
*/
@Override
public List<SysDeployForm> selectSysDeployFormList(SysDeployForm sysDeployForm)
{
return sysDeployFormMapper.selectSysDeployFormList(sysDeployForm);
}
/**
* 新增流程实例关联表单
*
* @param sysDeployForm 流程实例关联表单
* @return 结果
*/
@Override
public int insertSysDeployForm(SysDeployForm sysDeployForm)
{
SysForm sysForm = sysDeployFormMapper.selectSysDeployFormByDeployId(sysDeployForm.getDeployId());
if (Objects.isNull(sysForm)) {
return sysDeployFormMapper.insertSysDeployForm(sysDeployForm);
}else {
return 1;
}
}
/**
* 修改流程实例关联表单
*
* @param sysDeployForm 流程实例关联表单
* @return 结果
*/
@Override
public int updateSysDeployForm(SysDeployForm sysDeployForm)
{
return sysDeployFormMapper.updateSysDeployForm(sysDeployForm);
}
/**
* 批量删除流程实例关联表单
*
* @param ids 需要删除的流程实例关联表单ID
* @return 结果
*/
@Override
public int deleteSysDeployFormByIds(Long[] ids)
{
return sysDeployFormMapper.deleteSysDeployFormByIds(ids);
}
/**
* 删除流程实例关联表单信息
*
* @param id 流程实例关联表单ID
* @return 结果
*/
@Override
public int deleteSysDeployFormById(Long id)
{
return sysDeployFormMapper.deleteSysDeployFormById(id);
}
/**
* 查询流程挂着的表单
*
* @param deployId
* @return
*/
@Override
public SysForm selectSysDeployFormByDeployId(String deployId) {
return sysDeployFormMapper.selectSysDeployFormByDeployId(deployId);
}
}

96
yanzhu-flowable/src/main/java/com/yanzhu/flowable/service/impl/SysFormServiceImpl.java
View File

@ -1,96 +0,0 @@
package com.yanzhu.flowable.service.impl;
import java.util.List;
import com.yanzhu.common.utils.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.yanzhu.system.mapper.SysFormMapper;
import com.yanzhu.system.domain.SysForm;
import com.yanzhu.flowable.service.ISysFormService;
/**
* 流程表单Service业务层处理
*
* @author Tony
* @date 2021-04-03
*/
@Service
public class SysFormServiceImpl implements ISysFormService
{
@Autowired
private SysFormMapper sysFormMapper;
/**
* 查询流程表单
*
* @param formId 流程表单ID
* @return 流程表单
*/
@Override
public SysForm selectSysFormById(Long formId)
{
return sysFormMapper.selectSysFormById(formId);
}
/**
* 查询流程表单列表
*
* @param sysForm 流程表单
* @return 流程表单
*/
@Override
public List<SysForm> selectSysFormList(SysForm sysForm)
{
return sysFormMapper.selectSysFormList(sysForm);
}
/**
* 新增流程表单
*
* @param sysForm 流程表单
* @return 结果
*/
@Override
public int insertSysForm(SysForm sysForm)
{
sysForm.setCreateTime(DateUtils.getNowDate());
return sysFormMapper.insertSysForm(sysForm);
}
/**
* 修改流程表单
*
* @param sysForm 流程表单
* @return 结果
*/
@Override
public int updateSysForm(SysForm sysForm)
{
sysForm.setUpdateTime(DateUtils.getNowDate());
return sysFormMapper.updateSysForm(sysForm);
}
/**
* 批量删除流程表单
*
* @param formIds 需要删除的流程表单ID
* @return 结果
*/
@Override
public int deleteSysFormByIds(Long[] formIds)
{
return sysFormMapper.deleteSysFormByIds(formIds);
}
/**
* 删除流程表单信息
*
* @param formId 流程表单ID
* @return 结果
*/
@Override
public int deleteSysFormById(Long formId)
{
return sysFormMapper.deleteSysFormById(formId);
}
}

93
yanzhu-flowable/src/main/java/com/yanzhu/flowable/service/impl/SysTaskFormServiceImpl.java
View File

@ -1,93 +0,0 @@
package com.yanzhu.flowable.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.yanzhu.system.mapper.SysTaskFormMapper;
import com.yanzhu.system.domain.SysTaskForm;
import com.yanzhu.flowable.service.ISysTaskFormService;
/**
* 流程任务关联单Service业务层处理
*
* @author Tony
* @date 2021-04-03
*/
@Service
public class SysTaskFormServiceImpl implements ISysTaskFormService
{
@Autowired
private SysTaskFormMapper sysTaskFormMapper;
/**
* 查询流程任务关联单
*
* @param id 流程任务关联单ID
* @return 流程任务关联单
*/
@Override
public SysTaskForm selectSysTaskFormById(Long id)
{
return sysTaskFormMapper.selectSysTaskFormById(id);
}
/**
* 查询流程任务关联单列表
*
* @param sysTaskForm 流程任务关联单
* @return 流程任务关联单
*/
@Override
public List<SysTaskForm> selectSysTaskFormList(SysTaskForm sysTaskForm)
{
return sysTaskFormMapper.selectSysTaskFormList(sysTaskForm);
}
/**
* 新增流程任务关联单
*
* @param sysTaskForm 流程任务关联单
* @return 结果
*/
@Override
public int insertSysTaskForm(SysTaskForm sysTaskForm)
{
return sysTaskFormMapper.insertSysTaskForm(sysTaskForm);
}
/**
* 修改流程任务关联单
*
* @param sysTaskForm 流程任务关联单
* @return 结果
*/
@Override
public int updateSysTaskForm(SysTaskForm sysTaskForm)
{
return sysTaskFormMapper.updateSysTaskForm(sysTaskForm);
}
/**
* 批量删除流程任务关联单
*
* @param ids 需要删除的流程任务关联单ID
* @return 结果
*/
@Override
public int deleteSysTaskFormByIds(Long[] ids)
{
return sysTaskFormMapper.deleteSysTaskFormByIds(ids);
}
/**
* 删除流程任务关联单信息
*
* @param id 流程任务关联单ID
* @return 结果
*/
@Override
public int deleteSysTaskFormById(Long id)
{
return sysTaskFormMapper.deleteSysTaskFormById(id);
}
}

61
yanzhu-system/src/main/java/com/yanzhu/system/domain/FlowProcDefDto.java
View File

@ -1,61 +0,0 @@
package com.yanzhu.system.domain;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.Date;
/**
* <p>流程定义<p>
*
* @author Tony
* @date 2021-04-03
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel("流程定义")
public class FlowProcDefDto implements Serializable {
@ApiModelProperty("流程id")
private String id;
@ApiModelProperty("流程名称")
private String name;
@ApiModelProperty("流程key")
private String flowKey;
@ApiModelProperty("流程分类")
private String category;
@ApiModelProperty("配置表单名称")
private String formName;
@ApiModelProperty("配置表单id")
private Long formId;
@ApiModelProperty("版本")
private int version;
@ApiModelProperty("部署ID")
private String deploymentId;
@ApiModelProperty("流程定义状态: 1:激活 , 2:中止")
private int suspensionState;
@ApiModelProperty("部署时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date deploymentTime;
@ApiModelProperty("单位主键")
private Long deptId;
@ApiModelProperty("单位名称")
private String deptName;
}

20
yanzhu-system/src/main/java/com/yanzhu/system/domain/ai/DevAiProjectData.java
View File

@ -25,14 +25,10 @@ public class DevAiProjectData extends BaseEntity
@Excel(name = "项目主键")
private Long projectId;
private String projectName;
/** 部门主键 */
@Excel(name = "部门主键")
private Long deptId;
private String deptName;
/** 设备ID */
@Excel(name = "设备ID")
private Long deviceId;
@ -144,22 +140,6 @@ public class DevAiProjectData extends BaseEntity
@Excel(name = "数据状态")
private String isDel;
public String getProjectName() {
return projectName;
}
public void setProjectName(String projectName) {
this.projectName = projectName;
}
public String getDeptName() {
return deptName;
}
public void setDeptName(String deptName) {
this.deptName = deptName;
}
public void setId(Long id)
{
this.id = id;

39
yanzhu-system/src/main/java/com/yanzhu/system/domain/flowable/FlowDeptVo.java
View File

@ -1,39 +0,0 @@
package com.yanzhu.system.domain.flowable;
import com.yanzhu.common.core.domain.BaseEntity;
import io.swagger.annotations.ApiModel;
import lombok.Data;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
/**
* <p>工作流项目单位关系<p>
*
* @author JiangYuQi
* @date 2024-02-23
*/
@Data
@ApiModel("工作流项目单位关系")
public class FlowDeptVo extends BaseEntity {
private static final long serialVersionUID = 1L;
/** 流程定义主键 */
private String procdefId;
/** 流程定义单位 */
private Long deptId;
/** 流程定义排序 */
private String sort;
@Override
public String toString() {
return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
.append("procdefId", getProcdefId())
.append("deptId", getDeptId())
.append("sort", getSort())
.toString();
}
}

41
yanzhu-system/src/main/java/com/yanzhu/system/domain/flowable/FlowQueryVo.java
View File

@ -1,41 +0,0 @@
package com.yanzhu.system.domain.flowable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* <p>流程任务<p>
*
* @author Tony
* @date 2021-04-03
*/
@Data
@ApiModel("工作流任务相关--请求参数")
public class FlowQueryVo {
@ApiModelProperty("流程名称")
private String name;
@ApiModelProperty("开始时间")
private String startTime;
@ApiModelProperty("结束时间")
private String endTime;
@ApiModelProperty("当前页码")
private Integer pageNum;
@ApiModelProperty("每页条数")
private Integer pageSize;
@ApiModelProperty("流程类型")
private String category;
@ApiModelProperty("单位主键")
private Long deptId;
@ApiModelProperty("单位名称")
private String deptName;
}

337
yanzhu-system/src/main/java/com/yanzhu/system/domain/flowable/FlowTaskEntity.java
View File

@ -1,337 +0,0 @@
package com.yanzhu.system.domain.flowable;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.yanzhu.common.core.domain.BaseEntity;
import io.swagger.annotations.ApiModelProperty;
import java.util.Date;
import java.util.List;
/**
* <p>工作流任务<p>
*
* @author JiangYuQi
* @date 2021-04-03
*/
public class FlowTaskEntity extends BaseEntity {
private static final long serialVersionUID = 1L;
private String businessKey;
@ApiModelProperty("业务名称")
private String businessKeyName;
@ApiModelProperty("项目名称")
private String businessKeyParName;
@ApiModelProperty("任务编号")
private String taskId;
@ApiModelProperty("任务执行编号")
private String executionId;
@ApiModelProperty("任务名称")
private String taskName;
@ApiModelProperty("任务Key")
private String taskDefKey;
@ApiModelProperty("部门名称")
private String deptName;
@ApiModelProperty("流程发起人部门名称")
private String startDeptName;
@ApiModelProperty("任务执行人Id")
private Long assigneeId;
@ApiModelProperty("任务执行人名称")
private String assigneeName;
@ApiModelProperty("任务执行人部门")
private String assigneeDeptName;;
@ApiModelProperty("流程发起人Id")
private String startUserId;
@ApiModelProperty("流程发起人名称")
private String startUserName;
@ApiModelProperty("流程类型")
private String category;
@ApiModelProperty("流程变量信息")
private Object procVars;
@ApiModelProperty("局部变量信息")
private Object taskLocalVars;
@ApiModelProperty("流程部署编号")
private String deployId;
@ApiModelProperty("流程ID")
private String procDefId;
@ApiModelProperty("流程key")
private String procDefKey;
@ApiModelProperty("流程定义名称")
private String procDefName;
@ApiModelProperty("流程定义内置使用版本")
private int procDefVersion;
@ApiModelProperty("流程实例ID")
private String procInsId;
@ApiModelProperty("历史流程实例ID")
private String hisProcInsId;
@ApiModelProperty("任务耗时")
private String duration;
@ApiModelProperty("候选执行人")
private String candidate;
@ApiModelProperty("任务完成时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date finishTime;
@ApiModelProperty("单位祖籍列表")
private String deptAncestors;
public String getBusinessKeyName() {
return businessKeyName;
}
public void setBusinessKeyName(String businessKeyName) {
this.businessKeyName = businessKeyName;
}
public String getTaskId() {
return taskId;
}
public void setTaskId(String taskId) {
this.taskId = taskId;
}
public String getExecutionId() {
return executionId;
}
public void setExecutionId(String executionId) {
this.executionId = executionId;
}
public String getTaskName() {
return taskName;
}
public void setTaskName(String taskName) {
this.taskName = taskName;
}
public String getTaskDefKey() {
return taskDefKey;
}
public void setTaskDefKey(String taskDefKey) {
this.taskDefKey = taskDefKey;
}
public Long getAssigneeId() {
return assigneeId;
}
public void setAssigneeId(Long assigneeId) {
this.assigneeId = assigneeId;
}
public String getDeptName() {
return deptName;
}
public void setDeptName(String deptName) {
this.deptName = deptName;
}
public String getStartDeptName() {
return startDeptName;
}
public void setStartDeptName(String startDeptName) {
this.startDeptName = startDeptName;
}
public String getAssigneeName() {
return assigneeName;
}
public void setAssigneeName(String assigneeName) {
this.assigneeName = assigneeName;
}
public String getAssigneeDeptName() {
return assigneeDeptName;
}
public void setAssigneeDeptName(String assigneeDeptName) {
this.assigneeDeptName = assigneeDeptName;
}
public String getStartUserId() {
return startUserId;
}
public void setStartUserId(String startUserId) {
this.startUserId = startUserId;
}
public String getStartUserName() {
return startUserName;
}
public void setStartUserName(String startUserName) {
this.startUserName = startUserName;
}
public String getCategory() {
return category;
}
public void setCategory(String category) {
this.category = category;
}
public Object getProcVars() {
return procVars;
}
public void setProcVars(Object procVars) {
this.procVars = procVars;
}
public Object getTaskLocalVars() {
return taskLocalVars;
}
public void setTaskLocalVars(Object taskLocalVars) {
this.taskLocalVars = taskLocalVars;
}
public String getDeployId() {
return deployId;
}
public void setDeployId(String deployId) {
this.deployId = deployId;
}
public String getProcDefId() {
return procDefId;
}
public void setProcDefId(String procDefId) {
this.procDefId = procDefId;
}
public String getProcDefKey() {
return procDefKey;
}
public void setProcDefKey(String procDefKey) {
this.procDefKey = procDefKey;
}
public String getProcDefName() {
return procDefName;
}
public void setProcDefName(String procDefName) {
this.procDefName = procDefName;
}
public int getProcDefVersion() {
return procDefVersion;
}
public void setProcDefVersion(int procDefVersion) {
this.procDefVersion = procDefVersion;
}
public String getProcInsId() {
return procInsId;
}
public void setProcInsId(String procInsId) {
this.procInsId = procInsId;
}
public String getHisProcInsId() {
return hisProcInsId;
}
public void setHisProcInsId(String hisProcInsId) {
this.hisProcInsId = hisProcInsId;
}
public String getDuration() {
return duration;
}
public void setDuration(String duration) {
this.duration = duration;
}
public String getCandidate() {
return candidate;
}
public void setCandidate(String candidate) {
this.candidate = candidate;
}
public Date getFinishTime() {
return finishTime;
}
public void setFinishTime(Date finishTime) {
this.finishTime = finishTime;
}
public String getBusinessKey() {
return businessKey;
}
public void setBusinessKey(String businessKey) {
this.businessKey = businessKey;
}
public String getDeptAncestors() {
return deptAncestors;
}
public void setDeptAncestors(String deptAncestors) {
this.deptAncestors = deptAncestors;
}
public String getBusinessKeyParName() {
return businessKeyParName;
}
public void setBusinessKeyParName(String businessKeyParName) {
this.businessKeyParName = businessKeyParName;
}
private List<Long> roleIds;
public List<Long> getRoleIds() {
return roleIds;
}
public void setRoleIds(List<Long> roleIds) {
this.roleIds = roleIds;
}
}

23
yanzhu-system/src/main/java/com/yanzhu/system/domain/flowable/ReturnTaskNodeVo.java
View File

@ -1,23 +0,0 @@
package com.yanzhu.system.domain.flowable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* <p>可退回节点<p>
*
* @author tony
* @date 2022-04-23 11:01:52
*/
@Data
@ApiModel("可退回节点")
public class ReturnTaskNodeVo {
@ApiModelProperty("任务Id")
private String id;
@ApiModelProperty("用户Id")
private String name;
}

48
yanzhu-system/src/main/java/com/yanzhu/system/mapper/FlowBusinessKeyMapper.java
View File

@ -1,48 +0,0 @@
package com.yanzhu.system.mapper;
import com.yanzhu.system.domain.flowable.FlowTaskEntity;
import java.util.List;
import java.util.Map;
/***
* 工作流业务相关
*/
public interface FlowBusinessKeyMapper {
/**
* 根据条件查询所有流任务
* @param flowTaskEntity
* @return
*/
public List<FlowTaskEntity> selectAllFlowTaskByParams(FlowTaskEntity flowTaskEntity);
/**
* 根据流程Id查询操作日志
* @param procInsId
* @return
*/
public List<Map<String, Object>> selectCommentByProcInsId(String procInsId);
/**
* 根据流程Id查询表单数据
* @param procInsId
* @return
*/
public List<Map<String, Object>> selectFormDatasByProcInsId(String procInsId);
/**
* 查询我的代办任务
* @param flowTaskEntity
* @return
*/
public List<Map<String, Object>> selectMyAwaitFlowTask(FlowTaskEntity flowTaskEntity);
/**
* 查询我的已办任务
* @param flowTaskEntity
* @return
*/
public List<Map<String, Object>> selectMyFinishedFlowTask(FlowTaskEntity flowTaskEntity);
}

40
yanzhu-system/src/main/java/com/yanzhu/system/mapper/FlowDeployMapper.java
View File

@ -1,40 +0,0 @@
package com.yanzhu.system.mapper;
import com.yanzhu.system.domain.FlowProcDefDto;
import com.yanzhu.system.domain.flowable.FlowDeptVo;
import com.yanzhu.system.domain.flowable.FlowQueryVo;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 流程定义查询
*
* @author Tony
* @email
* @date 2022/1/29 5:44 下午
**/
public interface FlowDeployMapper {
/**
* 流程定义列表
* @param flowQueryVo 流程查询
* @return
*/
List<FlowProcDefDto> selectDeployList(FlowQueryVo flowQueryVo);
/**
* 缺省流程定义列表
* @param list 排除的缺省工作流类型
* @return
*/
List<FlowProcDefDto> selectDefaultDeployList(List<String> list);
/**
* 新增单位流程关系
*
* @param flowDeptVo 流程 单位关系
* @return 结果
*/
public int insertActReProcdefDept(FlowDeptVo flowDeptVo);
}

0
yanzhu-system/src/main/resources/mapper/ai/DevAiProjectConfigMapper.xml → yanzhu-system/src/main/resources/mapper/aibox/DevAiProjectConfigMapper.xml
View File

37
yanzhu-system/src/main/resources/mapper/ai/DevAiProjectDataMapper.xml → yanzhu-system/src/main/resources/mapper/aibox/DevAiProjectDataMapper.xml
View File

@ -7,9 +7,7 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<resultMap type="DevAiProjectData" id="DevAiProjectDataResult">
<result property="id" column="id" />
<result property="projectId" column="project_id" />
<result property="projectName" column="projectName" />
<result property="deptId" column="dept_id" />
<result property="deptName" column="deptName" />
<result property="deviceId" column="device_id" />
<result property="deviceName" column="device_name" />
<result property="deviceAddr0" column="device_addr0" />
@ -42,9 +40,7 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
</resultMap>
<sql id="selectDevAiProjectDataVo">
select dapd.id, dapd.project_id, sp.projectName, dapd.dept_id, sd.dept_name as deptName, dapd.device_id, dapd.device_name, dapd.device_addr0, dapd.device_addr1, dapd.serial_number, dapd.ipc_serial_num, dapd.ipc_addr, dapd.image_url, dapd.channel_id, dapd.channel_name, dapd.alarm_type, sdd.dict_label as alarm_type_name, dapd.alarm_id, dapd.report_rate, dapd.timestamp, dapd.left_top_x, dapd.left_top_y, dapd.right_btm_x, dapd.right_btm_y, dapd.person_num, dapd.in_num, dapd.out_num, dapd.plate_no, dapd.value_type, dapd.alarm_videoURL, dapd.alarm_video_name, dapd.compare_result, dapd.create_time, dapd.is_del from dev_ai_project_data dapd
left join sur_project sp on sp.id=dapd.project_id
left join sys_dept sd on sd.dept_id=dapd.dept_id
select dapd.id, dapd.project_id, dapd.dept_id, dapd.device_id, dapd.device_name, dapd.device_addr0, dapd.device_addr1, dapd.serial_number, dapd.ipc_serial_num, dapd.ipc_addr, dapd.image_url, dapd.channel_id, dapd.channel_name, dapd.alarm_type, sdd.dict_label as alarm_type_name, dapd.alarm_id, dapd.report_rate, dapd.timestamp, dapd.left_top_x, dapd.left_top_y, dapd.right_btm_x, dapd.right_btm_y, dapd.person_num, dapd.in_num, dapd.out_num, dapd.plate_no, dapd.value_type, dapd.alarm_videoURL, dapd.alarm_video_name, dapd.compare_result, dapd.create_time, dapd.is_del from dev_ai_project_data dapd
left join sys_dict_data sdd on sdd.dict_type='aibox_alarm_type' and sdd.dict_value=dapd.alarm_type
</sql>
@ -53,24 +49,10 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<where>
and dapd.is_del='0'
<if test="projectId != null "> and dapd.project_id = #{projectId}</if>
<if test="proType != null and proType != ''"> and sp.projectType = #{proType}</if>
<if test="activeName != null and activeName != ''"> and sp.progressVisible = 0</if>
<if test="projectName != null and projectName != ''"> and sp.projectName like concat('%', #{projectName}, '%')</if>
<if test="deptId != null "> and dapd.dept_id = #{deptId}</if>
<if test="deptName != null and deptName != ''"> and sd.dept_name like concat('%', #{deptName}, '%')</if>
<if test="deviceName != null and deviceName != ''"> and dapd.device_name like concat('%', #{deviceName}, '%')</if>
<if test="alarmType != null "> and dapd.alarm_type = #{alarmType}</if>
<if test="plateNo != null "> and dapd.plate_no = #{plateNo}</if>
<!-- 查询条件-项目部门 -->
<if test="projectDeptId != null "> and sp.deptId = #{projectDeptId}</if>
<!--子部门数据-->
<if test='nowRole == "4"'> and sp.deptId = #{nowDept}</if>
<!--监理单位/总包公司/分包单位查询当前关联数据-->
<if test='nowRole == "5" or nowRole == "6" or nowRole == "7"'> and sp.id in (select spui.projectId from sur_project_unit_info spui where spui.unitId = #{nowDept} and spui.del_flag=0 )</if>
<!--普通用户查询项目人员-->
<if test='nowRole == "15" or nowRole == "16" or nowRole == "17" or nowRole == "99"'>
and sp.id in (select spu.project_id from sur_project_userinfo spu where spu.user_id = #{nowUser} and spu.is_del=0)
</if>
<if test="params.date != null"> and date(dapd.create_time) = date(#{params.date})</if>
<if test="params.beginTime != null and params.beginTime != '' and params.endTime != null and params.endTime != ''"> and date(dapd.create_time) between #{params.beginTime} and #{params.endTime}</if>
</where>
@ -84,29 +66,14 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<select id="groupCountByAlarmType" parameterType="DevAiProjectData" resultType="map">
select dapd.alarm_type as type,sdd.dict_label as name, count(1) as value from dev_ai_project_data dapd
left join sur_project sp on sp.id=dapd.project_id
left join sys_dept sd on sd.dept_id=dapd.dept_id
left join sys_dict_data sdd on sdd.dict_type='aibox_alarm_type' and sdd.dict_value=dapd.alarm_type
<where>
and dapd.is_del='0' and sp.progressVisible = 0
and dapd.is_del='0'
<if test="projectId != null "> and dapd.project_id = #{projectId}</if>
<if test="proType != null and proType != ''"> and sp.projectType = #{proType}</if>
<if test="projectName != null and projectName != ''"> and sp.projectName like concat('%', #{projectName}, '%')</if>
<if test="deptId != null "> and dapd.dept_id = #{deptId}</if>
<if test="deptName != null and deptName != ''"> and sd.dept_name like concat('%', #{deptName}, '%')</if>
<if test="deviceName != null and deviceName != ''"> and dapd.device_name like concat('%', #{deviceName}, '%')</if>
<if test="alarmType != null "> and dapd.alarm_type = #{alarmType}</if>
<if test="plateNo != null "> and dapd.plate_no = #{plateNo}</if>
<!-- 查询条件-项目部门 -->
<if test="projectDeptId != null "> and sp.deptId = #{projectDeptId}</if>
<!--子部门数据-->
<if test='nowRole == "4"'> and sp.deptId = #{nowDept}</if>
<!--监理单位/总包公司/分包单位查询当前关联数据-->
<if test='nowRole == "5" or nowRole == "6" or nowRole == "7"'> and sp.id in (select spui.projectId from sur_project_unit_info spui where spui.unitId = #{nowDept} and spui.del_flag=0 )</if>
<!--普通用户查询项目人员-->
<if test='nowRole == "15" or nowRole == "16" or nowRole == "17" or nowRole == "99"'>
and sp.id in (select spu.project_id from sur_project_userinfo spu where spu.user_id = #{nowUser} and spu.is_del=0)
</if>
<if test="params.date != null"> and date(dapd.create_time) = date(#{params.date})</if>
</where>
GROUP BY dapd.alarm_type

87
yanzhu-system/src/main/resources/mapper/flowable/FlowBusinessKeyMapper.xml
View File

@ -1,87 +0,0 @@
<?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.yanzhu.system.mapper.FlowBusinessKeyMapper">
<select id="selectAllFlowTaskByParams" parameterType="com.yanzhu.system.domain.flowable.FlowTaskEntity" resultType="com.yanzhu.system.domain.flowable.FlowTaskEntity">
SELECT
fa.*
FROM
vw_flow_all fa
<where>
<if test="taskName != null and taskName != ''"> and fa.taskName like concat('%', #{taskName}, '%')</if>
<if test="procDefName != null and procDefName != ''"> and fa.procDefName like concat('%', #{procDefName}, '%')</if>
<if test="businessKey != null and businessKey != ''"> and fa.businessKey = #{businessKey}</if>
<if test="startDeptName != null and startDeptName != ''"> and fa.startDeptName like concat('%', #{startDeptName}, '%')</if>
<if test="startUserName != null and startUserName != ''"> and fa.startUserName like concat('%', #{startUserName}, '%')</if>
<if test="businessKeyName != null and businessKeyName != ''"> and fa.businessKeyName like concat('%', #{businessKeyName}, '%')</if>
<if test="businessKeyParName != null and businessKeyParName != ''"> and fa.businessKeyParName like concat('%', #{businessKeyParName}, '%')</if>
<if test="category != null and category != ''"> and fa.category = #{category}</if>
<if test="params.beginDate != null and params.beginDate != '' and params.endDate != null and params.endDate != ''"> and date(fa.createTime) between #{params.beginDate} and #{params.endDate}</if>
<!-- 查询条件-项目部门 -->
<if test="deptAncestors != null and deptAncestors != ''"> and find_in_set(fa.businessDeptId, #{deptAncestors}) </if>
<if test='activeName == "await"'> and fa.finishTime is null </if>
<if test='activeName == "finished"'> and fa.finishTime is not null </if>
</where>
order by fa.createTime desc
</select>
<!--查询工作流操作日志-->
<select id="selectCommentByProcInsId" parameterType="string" resultType="map">
select * from vw_flow_comment where procInstId = #{procInstId} order by startTime DESC
</select>
<!--查询工作流携带的参数-->
<select id="selectFormDatasByProcInsId" parameterType="string" resultType="map">
select hv.NAME_ as `name`,hv.TEXT_ as text from act_hi_varinst hv where hv.PROC_INST_ID_ = #{procInstId}
</select>
<!--查询我的代办任务-->
<select id="selectMyAwaitFlowTask" parameterType="com.yanzhu.system.domain.flowable.FlowTaskEntity" resultType="map">
select fa.* from vw_flow_await fa
where
1=1
<if test="procDefName != null and procDefName != ''"> and fa.procDefName like concat('%', #{procDefName}, '%')</if>
<if test="businessKey != null and businessKey != ''"> and fa.businessKey = #{businessKey}</if>
<if test="businessKeyName != null and businessKeyName != ''"> and fa.businessKeyName like concat('%', #{businessKeyName}, '%')</if>
<if test="businessKeyParName != null and businessKeyParName != ''"> and fa.businessKeyParName like concat('%', #{businessKeyParName}, '%')</if>
<if test="category != null and category != ''"> and fa.category = #{category}</if>
<if test="params.beginDate != null and params.beginDate != '' and params.endDate != null and params.endDate != ''"> and date(fa.createTime) between #{params.beginDate} and #{params.endDate}</if>
<!-- 查询条件-项目部门 -->
<if test="deptAncestors != null and deptAncestors != ''"> and find_in_set(fa.businessDeptId, #{deptAncestors}) </if>
<if test="roleIds !=null and roleIds.size()>0">
AND (fa.ASSIGNEE_ = #{assigneeId}
OR (
fa.ASSIGNEE_ IS NULL
AND (
fa.USER_ID_ = #{assigneeId}
OR (
fa.GROUP_ID_ IN
<foreach collection="roleIds" item="roleId" open="(" separator="," close=")">
#{roleId}
</foreach>
)
)
)
)
</if>
order by fa.createTime desc
</select>
<!--查询我的已办任务-->
<select id="selectMyFinishedFlowTask" parameterType="com.yanzhu.system.domain.flowable.FlowTaskEntity" resultType="map">
select fa.* from vw_flow_finished fa
where
fa.ASSIGNEE_=#{assigneeId}
<if test="procDefName != null and procDefName != ''"> and fa.procDefName like concat('%', #{procDefName}, '%')</if>
<if test="businessKey != null and businessKey != ''"> and fa.businessKey = #{businessKey}</if>
<if test="businessKeyName != null and businessKeyName != ''"> and fa.businessKeyName like concat('%', #{businessKeyName}, '%')</if>
<if test="businessKeyParName != null and businessKeyParName != ''"> and fa.businessKeyParName like concat('%', #{businessKeyParName}, '%')</if>
<if test="category != null and category != ''"> and fa.category = #{category}</if>
<if test="params.beginDate != null and params.beginDate != '' and params.endDate != null and params.endDate != ''"> and fa.endTime between #{params.beginDate} and #{params.endDate}</if>
order by fa.endTime desc
</select>
</mapper>

84
yanzhu-system/src/main/resources/mapper/flowable/FlowDeployMapper.xml
View File

@ -1,84 +0,0 @@
<?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.yanzhu.system.mapper.FlowDeployMapper">
<!--查询流程定义列表-->
<select id="selectDeployList" parameterType="com.yanzhu.system.domain.flowable.FlowQueryVo" resultType="com.yanzhu.system.domain.FlowProcDefDto">
SELECT
rp.id_ as id,
rp.deployment_id_ as deploymentId,
rd.name_ as name,
rd.category_ as category,
rp.key_ as flowKey,
rp.version_ as version,
rp.suspension_state_ as suspensionState,
rd.deploy_time_ as deploymentTime,
rpd.DEPT_ID_ as deptId,
sd.dept_name as deptName
FROM
act_re_procdef rp
LEFT JOIN act_re_deployment rd ON rp.deployment_id_ = rd.id_
left join act_re_procdef_dept rpd on rp.id_ = rpd.PROCDEF_ID_
left join sys_dept sd on sd.dept_id = rpd.DEPT_ID_
<where>
<if test="deptId != null">
and rpd.DEPT_ID_ = #{deptId}
</if>
<if test="deptName != null and deptName != ''">
and sd.dept_name like concat('%', #{deptName}, '%')
</if>
<if test="name != null and name != ''">
and rd.name_ like concat('%', #{name}, '%')
</if>
<if test="category != null and category != ''">
and rd.category_ = #{category}
</if>
</where>
</select>
<!--查询缺省流程定义列表-->
<select id="selectDefaultDeployList" parameterType="String" resultType="com.yanzhu.system.domain.FlowProcDefDto">
SELECT
rp.id_ as id,
rp.deployment_id_ as deploymentId,
rd.name_ as name,
rd.category_ as category,
rp.key_ as flowKey,
rp.version_ as version,
rp.suspension_state_ as suspensionState,
rd.deploy_time_ as deploymentTime,
null as deptId,
null as deptName
FROM
act_re_procdef rp
LEFT JOIN act_re_deployment rd ON rp.deployment_id_ = rd.id_
left join act_re_procdef_dept rpd on rp.id_ = rpd.PROCDEF_ID_
<where>
and rpd.DEPT_ID_ is null
<if test="list !=null and list.size()>0">
and rd.category_ not in
<foreach collection="list" item="item" index="index" open="(" close=")" separator=",">
#{item}
</foreach>
</if>
</where>
</select>
<!--新增单位流程关系-->
<insert id="insertActReProcdefDept" parameterType="com.yanzhu.system.domain.flowable.FlowDeptVo">
insert into act_re_procdef_dept
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="procdefId != null">PROCDEF_ID_,</if>
<if test="deptId != null">DEPT_ID_,</if>
<if test="sort != null">SORT_,</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="procdefId != null">#{procdefId},</if>
<if test="deptId != null">#{deptId},</if>
<if test="sort != null">#{sort},</if>
</trim>
</insert>
</mapper>

61
yanzhu-system/src/main/resources/mapper/flowable/SysTaskFormMapper.xml
View File

@ -1,61 +0,0 @@
<?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.yanzhu.system.mapper.SysTaskFormMapper">
<resultMap type="SysTaskForm" id="SysTaskFormResult">
<result property="id" column="id" />
<result property="formId" column="form_id" />
<result property="taskId" column="task_id" />
</resultMap>
<sql id="selectSysTaskFormVo">
select id, form_id, task_id from sys_task_form
</sql>
<select id="selectSysTaskFormList" parameterType="SysTaskForm" resultMap="SysTaskFormResult">
<include refid="selectSysTaskFormVo"/>
<where>
<if test="formId != null "> and form_id = #{formId}</if>
<if test="taskId != null and taskId != ''"> and task_id = #{taskId}</if>
</where>
</select>
<select id="selectSysTaskFormById" parameterType="Long" resultMap="SysTaskFormResult">
<include refid="selectSysTaskFormVo"/>
where id = #{id}
</select>
<insert id="insertSysTaskForm" parameterType="SysTaskForm" useGeneratedKeys="true" keyProperty="id">
insert into sys_task_form
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="formId != null">form_id,</if>
<if test="taskId != null">task_id,</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="formId != null">#{formId},</if>
<if test="taskId != null">#{taskId},</if>
</trim>
</insert>
<update id="updateSysTaskForm" parameterType="SysTaskForm">
update sys_task_form
<trim prefix="SET" suffixOverrides=",">
<if test="formId != null">form_id = #{formId},</if>
<if test="taskId != null">task_id = #{taskId},</if>
</trim>
where id = #{id}
</update>
<delete id="deleteSysTaskFormById" parameterType="Long">
delete from sys_task_form where id = #{id}
</delete>
<delete id="deleteSysTaskFormByIds" parameterType="String">
delete from sys_task_form where id in
<foreach item="id" collection="array" open="(" separator="," close=")">
#{id}
</foreach>
</delete>
</mapper>