自定义事件类，实现状态推送

data/workflow/license/license.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<horizon-licenses>
+  <license-group product="workflow" version="8.2" format="1.4" release-time="DE09D72D344C43BB31F6EB5F39574FF093DFA3921B4B4EE5" run-time="DE09D72D344C43BB31F6EB5F39574FF093DFA3921B4B4EE5" timer="DE09D72D344C43BB31F6EB5F39574FF093DFA3921B4B4EE5" summary="RceD8zu+eGwsvz10+yjgYjruIuTBVYLOSCwZSbuFaLO/GOLdK4ALY/D9YdMbSym0G6v7RkvGIXOn8EKtKnhO2F0oiLQCvWyO1klLIsnl3beUEXdP3v85F7uGHGEnuqo+QsmoSuZLvZhYupqzDyqpwUW0vSE2Kr6lqCPTlx25h4s=" install="machine">
+    <license licensee="山信开发" expiration="2025-02-12" cpus="16" users="200" formsums="200" units="1" ip="http://localhost" port="8080" app="/horizon-workflow-boot" flow="20" work="20" tenantspace="1" concurrent="1" multi-server="1" clusters="1" simple="1" form-designer="1">53428102B36553EF2243BF1392B4946238955D312C359A8AB27C74D06CC5DDBC1EDB539407F22DA714B4598337865680006648E21D69088702C390E085C9DB67F44BEA2369CFBA3ABEEDF7D8438472F5D34928437E2E1AC8E67EDD334C00A7BC68C5EA792E08BD4E78A1D85CB931078F6032FF4B5E66E02FCE7D73EC604D979F8E43CC233F93EA90C200B84C76B2268683970B0F23312373CF4157170914DE6AB00D7562BEBC43AC34F320CA143FB54ABB5F57F3247A7D1A898DBDDD84FE6B7B7F0AC765042B9C80A52A10417635BDEDD82F89E1DB89AE5248A78B9A7F04839D36B99A20089CB5331F47CC5D3EF9E4E39E417F5BAB9D2555E0C455A6148610D72BA914C2AE78916A175312FA4FE842B0349B27D4B07C218EBD43E4BD16C0B98F98B4BA9E51248B11B1FCD6B0F8909083C3BB869599F31B8D1E86662AB9E1DF57B867ABB62B3A3CE0DB9D14DA97179E162F93F7581FBD650F9F8D08067DB683067D62016BC35BA3E9570684E0E2AFBCC1BBC6BCE6F801BBFB2C4DF6AB6E1F6364DB571E0CCF3AD8421CA2C5F61126FCE98D17AD9AB1A4E0195B396A860268DEF7FB30784878A2E4D44703AEE8D2AC51B68D07521CB81D4ECDB85C3867A696F7A6602ACB06FDBC34026384F5974B1681FCDEE941668965362C345194D4EFED6E4F8ED318EC7EA809F0DB328B5295C5EDD9B5E9D6657EF10B18C817E8E25BDCE8E4D3089C0CEE39A8340DCDEE7EBF53B72961B8841CE83DAB0DB9E9779207DD41E70E2C11CD1A188FCDAD2C216FD79E6269B1E6031DB15EFBCF078D3EF0423A8B2F8B6430345EF6351091DCDE27044BB05A60ED80CAD255700475AD5946ACA0A11BF7DA00462D89BEE30218F3703BA358FE865EA1DA3BB6FC36606B9EEF91F56D81918189A54FDD7AA72AC757EF297D22523247251DBBA08B2CB293A942892903E24B4C81668AF1CE987888F11120A2BF886C684AAA305837C4982B442A0396934B572E71D5FE470EE41B7895C4A756A4299C4EE5CCC1EB452E06FE77B7D2B383D967DE95905BE2B105288E032D2F257D4FB36EC92BB1D39E2028ED30FEF05662425CAF98622F1D91A6547A7002BBC806E9C37ED5B4343799B243F6635E687F7459B54153F162BEDFD1588E551CD12114E53C37381B4FDCA0C505F9F8E661BF19583FDD4B1B295DF47555AF4973FF542F0970CA53C94EEB04EE3EE892A1B700DC65</license>
+  </license-group>
+</horizon-licenses>

data/workflow/properties/cache.properties

@@ -0,0 +1,95 @@
+#流程缓存模式 redis memcached guava ehcache
+cache.type=guava
+
+#默认的缓存组名称
+default.cache.name=defaultCache
+#默认的缓存过期时间
+default.cache.time=0
+#开启二级缓存,缓存类型为guava时不建议开启
+enableLocalCache=false
+#开启二级缓存后,存储二级缓存的key(模糊包含)（多个用;隔开）
+localCacheKey=HORIZON_DEPTS;HORIZON_USERS;HORIZON_GROUPS;HORIZON_ROLES;HORIZON_POSITIONS
+
+#------------------guava缓存配置---------------
+guava.enable=true
+#瓜娃缓存数接近该值时开始移除不常用的缓存
+guava.maximum.size= 1000
+#当key在被“read/write”操作之后，空闲多久后被删除。（秒）
+guava.expire.after.access= 604800
+#当key被write(put或者reload)操作之后，空闲多久后被删除。（秒）
+expire.after.write=604800
+
+#----------------redis缓存配置----------------------------------------------------
+redis.enable=false
+#redis连接是否是哨兵模式
+redis.sentinel=false
+#redis的服务器地址,多个用分号";"隔开
+#哨兵模式下,第一个redis地址写主节点,哨兵节点写在主节点后面,用分号";"隔开
+redis.host=127.0.0.1
+#redis的服务端口,多个用分号";"隔开
+#哨兵模式下,第一个redis端口写主节点,哨兵节点写在主节点后面,用分号";"隔开
+redis.port=6379
+#名称,多个用分号隔开
+#哨兵模式下,主节点(master)节点的名称必需设置
+redis.name=
+#redis连接密码,多个用分号";"隔开
+#哨兵模式下,密码只需设置一个即可
+redis.passWord=
+#链接数据库
+#redis.default.db=0
+#客户端超时时间单位是毫秒
+redis.timeout=100000
+#最大连接数
+redis.pool.maxActive=300
+#最大空闲数
+redis.pool.maxIdle=100
+#最小空闲数
+redis.pool.minIdle=20
+#最大建立连接等待时间
+redis.pool.maxWait=10000
+#使用连接时，检测连接是否成功
+redis.pool.testOnBorrow=true
+#返回连接时，检测连接是否成功
+redis.pool.testOnReturn=false
+
+#---------------------memcached缓存配置-------------------------
+#启用
+memcache.enable=false
+#服务器地址
+memcached.servers=192.168.3.158:11211
+#当一个服务器请求超时是否去访问另一台
+memcached.failover=true
+#初始链接数
+memcached.initConn=5
+#最小连接数
+memcached.minConn=5
+#最大连接数
+memcached.maxConn=300
+#主线程休眠时间
+memcached.maintSleep=30
+#禁止使用nagle算法
+memcached.nagle=false
+#请求缓存超时时间
+memcached.socketTO=3000
+#检查服务器是否失效
+memcached.aliveCheck=true
+#memcached队列存放缓存时的超时期限
+memcached.timeOut=5
+#memcached内存实例超期期限
+memcached.expiryTime=30
+
+#---------------------ehcache缓存配置-------------------------
+#启用
+ehcache.enable=false
+#内存中最大缓存对象数
+ehcache.maxElementsInMemory=1000
+#是否将会对象写到磁盘中
+ehcache.overflowToDisk=true
+#对象是否永久有效
+ehcache.eternal=false
+#允许对象处于空闲状态的最长时间，以秒为单位。
+ehcache.timeToLiveSeconds=604800
+#对象允许存在于缓存中的最长时间
+ehcache.timeToIdleSeconds=604800
+#磁盘失效线程运行时间间隔
+ehcahce.diskExpiryThreadIntervalSeconds=120

data/workflow/properties/dbconfig.properties

@@ -0,0 +1,27 @@
+#Horizon Workflow DB base info
+horizon.identifier=system
+horizon.databaseType=Oracle
+horizon.isDefault=true
+horizon.lobProcessorClass=com.horizon.db.xlob.XlobProcessorImpl4Oracle
+horizon.lobBufferSize=1048576
+horizon.connectionType=jdbc
+horizon.jndiName=
+#datasource config
+horizon.db.driverClass=oracle.jdbc.driver.OracleDriver
+horizon.db.maxPoolSize=15
+horizon.db.minPoolSize=3
+horizon.db.initialPoolSize=3
+horizon.db.maxIdelTime=0
+horizon.db.jdbcUrl=jdbc:oracle:thin:@172.16.7.51:10002/pdb
+horizon.db.username=zksf
+horizon.db.password=1234
+#数据源类型 默认tomcat-jdbc
+horizon.db.datasourceType=tomcat-jdbc
+# 用于验证数据库连接是否可用的SQL语句,不同数据库sql语句不同
+# mysql,mysql8,dm,tidb;sqlserver,oscar:     SELECT 1
+# oracle:                                   SELECT 1 FROM DUAL
+# postgresql,gbase,highgo,gauss,upbase:     SELECT VERSION()
+# db2:                                      SELECT 1 FROM SYSIBM.SYSDUMMY1
+# gbase8s:                                  SELECT 1 FROM SYSUSERS
+# kingbase,kingbase8:                       SELECT 1 FROM SYS_STAT_ACTIVITY
+horizon.db.validationQuery=SELECT 1 FROM DUAL

data/workflow/properties/horizon.properties

@@ -0,0 +1,167 @@
+
+#文件根目录
+sys.path=/workflow
+
+#模块资源文件目录
+assets.path=/workflow/assets
+
+#第三方插件资源文件目录
+front.path=/workflow/plugins
+
+#公共页面
+common.path=/workflow/common
+
+#初始化安装文件目录
+init.path=/init
+
+#初始化安装模块
+init.module.path=workflow
+
+#管理端请求路径
+url.prefix=/horizon/workflow
+
+#URL请求后缀
+url.suffix=.wf
+
+#视图路径
+view.prefix=/workflow
+view.suffix=.html
+
+#布局 top/top-left/top-left-hoversubmenu/bottom-left/bottom-left-hoversubmenu/left/left-hoversubmenu
+layout.engine=bottom-left
+
+#默认展开框架右侧树
+layout.fixedModal=true
+
+#嵌入 embed
+embed=
+
+#允许上传文件大小
+maxUploadSize=10485760
+
+#允许上传普通附件的类型
+fileFormat=doc;txt;xls;ppt
+
+#允许上传图片的类型
+imgFormat=png;gif;svg;bmp
+
+#保存文件的类型,0为保存到物理机文件系统，1为保存至数据库
+saveType=0
+
+#附件上传路径
+store.path=D:/_tmp
+
+#上传文件是否需要加密
+file.isNeedEncode = false
+
+#产品默认初始化方式  1:租户模式  3:单利模式
+initFlag=3
+
+#实时记录开关，0-不记录，1记录
+realtimeflag=1
+
+#实时数据保留时间，单位“天”，超过三天数据将按天进行归档
+keeptime=1
+
+#WorkflowContextFilter过滤器不需要拦截的地址列表,中间用逗号分隔,
+#注意：不能换行。根据配置，除了jsp,实际请求地址类似：url.prefix+下列地址+url.suffix
+sessionExceptiveURL=/index.html;/index_system.html;/login/tenant;/login/system;/system/tenant/login;/workflow/module/workflow/flow.info.html;/flowchart/chartdata;/workflow/module/designer/index_1.html
+
+#流程框架页面固定右侧信息
+workflow.fixedModal=false
+
+#流程前端设置消息发送类型Mail;Msg;SMS;IM
+workflow.messageType=
+
+#流程启动是否自动到第一个任务节点
+workflow.autoFirstNode=true
+
+#流程无法计算出办理人时,使用默认办理人
+workflow.openDefAuthor=false
+
+#流程在测试是否保存业务数据:默认保存
+workflow.unCommitData=false
+
+#流程[退回]操作时选择办理人
+workflow.reject.selectAuthor=false
+
+#流程[任意退回]操作时选择办理人
+workflow.jumpreject.selectAuthor=false
+
+#如果设置读者，流程提交自动过滤去掉subjection
+workflow.replace.subjection=true
+
+#流程[自由提交]坐标设置
+workflow.freesubmit.axis=true
+
+#流程执行以下操作不执行表单验证֤
+workflow.unValidate=reject;jumpreject;innerreject;getback;save;close;move;goto;pause;stop;subflow;replace
+
+#流程框架导入页面(/module/workflow/page.import.ftl)
+workflow.import=
+ 
+#当前语言
+localeVal=zh_CN
+
+#token 过期时间(分钟)
+token.timeout=7200
+
+#500错误页面
+errorpage500=
+
+#产品分类
+product=workflow
+
+#develop:开发模式
+#product:产品模式
+run.mode=develop
+
+#启动定时任务默认true, 停止启动为false
+task.start=true
+#批量处理个数(用户配置数据库关键字in中的数据个数默认900最大1000.神通数据库请配置200;最大255)
+batch.number=200
+
+#初始化数据时是否忽略连接失败的数据源
+ignore.dataSource.connFail=false
+#是否解析主办组织机构为人员
+workflow.authorParsingToUser=false
+
+# 解析组织机构类型D (部门(不包含子部门)) P(岗位) G(群组) ;分隔
+workflow.authorParsingType=D;
+
+#启动是否加载全部组织机构信息
+orgData.loadAll=true
+
+#组织机构搜索框最大返回数目
+orgData.searchMax=100
+#程序应用名称
+server.name=workflow
+#程序应用监控是否打开
+server.monitor.open=true
+#程序程序运行记录频率5分钟一次
+server.runRecord.step=5
+#jvm内存运行记录频率30分钟一次
+server.jvmRecord.step=30
+#cpu占用率情况记录频率30分钟一次
+server.cpuRecord.step=30
+#磁盘空间记录频率60分钟一次
+server.diskRecord.step=60
+#接口请求响应时间间隔记录
+server.requestRecord.step=10
+#流程域数据刷新时间5分钟一次
+flowArea.refresh.time=5
+#流程实例严重超期天数限制
+monitor.overexceed.day=2
+
+#jar包启动时.properties配置文件和license文件生成的文件夹路径
+#路径为绝对路径，路径之间以 "/" 作为分隔符,例如: C:/test/conf
+#文件夹名不要含有特殊字符,不进行设置时默认为当前用户目录
+horizon.home=data
+
+#首页URl
+home.url=/manager/index
+
+#是否开启租户授权校验
+isValidateOfTenant=false
+
+#initFieldLength.varchar=4

data/workflow/properties/version.properties

@@ -0,0 +1 @@
+version=8.2.2

pom.xml

@@ -23,6 +23,11 @@
     </properties>
 
     <dependencies>
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+            <version>5.8.8</version>
+        </dependency>
         <!--其他需要依赖的jar包-->
         <dependency>
             <groupId>org.springframework.boot</groupId>
@@ -260,28 +265,28 @@
         <dependency>
             <groupId>com.horizon</groupId>
             <artifactId>horizon-framework</artifactId>
-            <version>8.2</version>
+            <version>8.2.2</version>
             <scope>system</scope>
             <systemPath>${basedir}/lib/horizon/horizon-framework-8.2.2.jar</systemPath>
         </dependency>
         <dependency>
             <groupId>com.horizon</groupId>
             <artifactId>horizon-language-zh_CN</artifactId>
-            <version>8.2</version>
+            <version>8.2.2</version>
             <scope>system</scope>
             <systemPath>${basedir}/lib/horizon/horizon-language-zh_CN-8.2.2.jar</systemPath>
         </dependency>
         <dependency>
             <groupId>com.horizon</groupId>
             <artifactId>horizon-language-en</artifactId>
-            <version>8.2</version>
+            <version>8.2.2</version>
             <scope>system</scope>
             <systemPath>${basedir}/lib/horizon/horizon-language-en-8.2.2.jar</systemPath>
         </dependency>
         <dependency>
             <groupId>com.horizon</groupId>
             <artifactId>horizon-language-pub</artifactId>
-            <version>8.2</version>
+            <version>8.2.2</version>
             <scope>system</scope>
             <systemPath>${basedir}/lib/horizon/horizon-language-pub-8.2.2.jar</systemPath>
         </dependency>
@@ -295,21 +300,21 @@
         <dependency>
             <groupId>com.horizon</groupId>
             <artifactId>horizon-tenant-extras</artifactId>
-            <version>8.2</version>
+            <version>8.2.2</version>
             <scope>system</scope>
             <systemPath>${basedir}/lib/horizon/horizon-tenant-extras-8.2.2.jar</systemPath>
         </dependency>
         <dependency>
             <groupId>com.horizon</groupId>
             <artifactId>horizon-workflow-conf</artifactId>
-            <version>8.2</version>
+            <version>8.2.2</version>
             <scope>system</scope>
             <systemPath>${basedir}/lib/horizon/horizon-workflow-conf-8.2.2.jar</systemPath>
         </dependency>
         <dependency>
             <groupId>com.horizon</groupId>
             <artifactId>horizon-workflow-core</artifactId>
-            <version>8.2</version>
+            <version>8.2.2</version>
             <scope>system</scope>
             <systemPath>${basedir}/lib/horizon/horizon-workflow-core-8.2.2.jar</systemPath>
         </dependency>
@@ -323,21 +328,21 @@
         <dependency>
             <groupId>com.horizon</groupId>
             <artifactId>horizon-workflow-extend</artifactId>
-            <version>8.2</version>
+            <version>8.2.2</version>
             <scope>system</scope>
             <systemPath>${basedir}/lib/horizon/horizon-workflow-extend-8.2.2.jar</systemPath>
         </dependency>
         <dependency>
             <groupId>com.horizon</groupId>
             <artifactId>horizon-workflow-pub</artifactId>
-            <version>8.2</version>
+            <version>8.2.2</version>
             <scope>system</scope>
             <systemPath>${basedir}/lib/horizon/horizon-workflow-pub-8.2.2.jar</systemPath>
         </dependency>
         <dependency>
             <groupId>com.horizon</groupId>
             <artifactId>horizon-workflow-xml</artifactId>
-            <version>8.2</version>
+            <version>8.2.2</version>
             <scope>system</scope>
             <systemPath>${basedir}/lib/horizon/horizon-workflow-xml-8.2.2.jar</systemPath>
         </dependency>

src/main/java/com/horizon/common/constant/Constants.java

@@ -0,0 +1,14 @@
+package com.horizon.common.constant;
+
+/**
+ * 流程常量信息
+ */
+public class Constants {
+
+    /**
+     * WF服务器URL，临时写死，后续会写到配置文件中
+     */
+    // public static final String WF_PRE_URL = "http://127.0.0.1:8003";
+    public static final String WF_PRE_URL = "http://172.16.7.51:10034/jlyypt";
+    // http://172.16.7.51:10034/jlyypt/cot/Head/approvalProccess
+}

src/main/java/com/horizon/org/OrgBuilderImpl.java

@@ -17,15 +17,15 @@ public class OrgBuilderImpl extends OrgBuilder {
     @Override
     public List<OrgData> depts() {
         System.out.println("当前租户标识：" + HorizonCore.TENANT_CODE.value());
-        String dbIdentifier = "sgiip";
+        String dbIdentifier = "jl_sgiip";
         Map<String, List<User>> usersDept = getUsersAndDept(dbIdentifier);//获取部门与用户的对应关系
         // id：部门id； dept_code ：部门编号 ； dept_name：部门名称 ；parent_id：部门父节点id，必须存在 ； order_no 排序号，没有可默认
 //        String deptsql = "select id,dept_code,dept_name,parent_id,order_no from to_horizon_dept where  id!='root_node_id' order by order_no";
 
         String deptsql = "";
-        deptsql += " select d.id,d.dept_code,d.dept_name, ( select a.id from sgiip.sys_department a where a.dept_code = d.f_id ) as parent_id  ,";
+        deptsql += " select d.id,d.dept_code,d.dept_name, ( select a.id from JLOPAPUSER.sys_department a where a.dept_code = d.f_id ) as parent_id  ,";
         deptsql += " 'D' as type ,0 as order_no ";
-        deptsql += " from sgiip.sys_department d where d.cancel_flag = '0' and  d.dept_code!='D' ";
+        deptsql += " from JLOPAPUSER.sys_department d where d.cancel_flag = '0' and  d.dept_code!='D' ";
 
 
         List<Map<String, Object>> deptmap = Access.getMultiMap(deptsql, null, dbIdentifier);
@@ -73,9 +73,9 @@ public class OrgBuilderImpl extends OrgBuilder {
      */
     private Map<String, List<User>> getUsersAndDept(String dbIdentifier) {
 //        String usersql = "select u.id,u.login_name,u.name,tor.dept_id from to_horizon_user u,tor_horizon_user_dept tor where u.id = tor.user_id";
-//        String usersql = "select u.id,u.user_name as login_name,u.user_desc,tor.dept_id from sgiip.sys_user u,sgiip.sys_user_department tor where u.id = tor.user_id";
+//        String usersql = "select u.id,u.user_name as login_name,u.user_desc,tor.dept_id from JLOPAPUSER.sys_user u,JLOPAPUSER.sys_user_department tor where u.id = tor.user_id";
         String usersql = "";
-        usersql += "  SELECT u.id,u.user_name as LOGIN_NAME,u.user_desc as NAME,tor.DEPT_ID ,'' as type FROM sgiip.sys_user u,sgiip.sys_user_department tor WHERE u.ID = tor.USER_ID";
+        usersql += "  SELECT u.id,u.user_name as LOGIN_NAME,u.user_desc as NAME,tor.DEPT_ID ,'' as type FROM JLOPAPUSER.sys_user u,JLOPAPUSER.sys_user_department tor WHERE u.ID = tor.USER_ID";
         usersql += "  union all";
         usersql += " select '1' as id ,'admin' as login_name  ,'超级管理员' as NAME ,'0' as DEPT_ID  ,'' as type from dual";
 
@@ -114,7 +114,7 @@ public class OrgBuilderImpl extends OrgBuilder {
 
         return null;
 
-//        String dbIdentifier = "sgiip";
+//        String dbIdentifier = "jl_sgiip";
 //        Map<String,List<User>> usersAndGroup = getUsersAndGroup(dbIdentifier);
 //        // code是编号；  群组跟部门一样，支持树形结构
 //        String usersql = "select id,group_name,group_code,parent_id from to_horizon_group WHERE ID!='root_node_id'";
@@ -156,7 +156,7 @@ public class OrgBuilderImpl extends OrgBuilder {
     @Override
     public List<OrgData> positions() {
         System.out.println("当前租户标识：" + HorizonCore.TENANT_CODE.value());
-        String dbIdentifier = "sgiip";
+        String dbIdentifier = "jl_sgiip";
         Map<String, List<User>> usersDept = getUsersAndPost(dbIdentifier);//获取部门与用户的对应关系
         // id：部门id； dept_code ：部门编号 ； dept_name：部门名称 ；parent_id：部门父节点id，必须存在 ； order_no 排序号，没有可默认
 //        String deptsql = "select id,dept_code,dept_name,parent_id,order_no from to_horizon_dept where  id!='root_node_id' order by order_no";
@@ -164,7 +164,7 @@ public class OrgBuilderImpl extends OrgBuilder {
         String deptsql = "";
         deptsql += " select d.id,d.post_code,d.post_name, 'position_root' as parent_id,";
         deptsql += " 'P' as type ,0 as order_no";
-        deptsql += " from sgiip.sys_post d where d.cancel_flag = '0'";
+        deptsql += " from JLOPAPUSER.sys_post d where d.cancel_flag = '0'";
 
 
         List<Map<String, Object>> deptmap = Access.getMultiMap(deptsql, null, dbIdentifier);
@@ -207,7 +207,7 @@ public class OrgBuilderImpl extends OrgBuilder {
 
 
     private Map<String, List<User>> getUsersAndPost(String dbIdentifier) {
-        String usersql = " SELECT u.id,u.user_name as LOGIN_NAME,u.user_desc as NAME,tor.post_ID ,'' as type FROM sgiip.sys_user u,sgiip.sys_user_post tor WHERE u.ID = tor.USER_ID ";
+        String usersql = " SELECT u.id,u.user_name as LOGIN_NAME,u.user_desc as NAME,tor.post_ID ,'' as type FROM JLOPAPUSER.sys_user u,JLOPAPUSER.sys_user_post tor WHERE u.ID = tor.USER_ID ";
         List<Map<String, Object>> userMap = Access.getMultiMap(usersql, null, dbIdentifier);
         Map<String, List<User>> usersAndDept = new HashMap<String, List<User>>();
         for (Map<String, Object> map : userMap) {
@@ -277,12 +277,12 @@ public class OrgBuilderImpl extends OrgBuilder {
 
     @Override
     public List<User> users() {
-        String dbIdentifier = "sgiip";
+        String dbIdentifier = "jl_sgiip";
         //id，用户唯一id；  login_name,用户登录名；   name，用户姓名；  dept_id，用户所属部门id ；
 //        String sql="SELECT u.id,u.LOGIN_NAME,'F;D' as type,u.NAME,tor.DEPT_ID FROM TO_HORIZON_USER u,TOR_HORIZON_USER_DEPT tor WHERE u.ID = tor.USER_ID";
 
         String sql = "";
-        sql += "  SELECT u.id,u.user_name as LOGIN_NAME,u.user_desc as NAME,tor.DEPT_ID ,'' as type FROM sgiip.sys_user u,sgiip.sys_user_department tor WHERE u.ID = tor.USER_ID";
+        sql += "  SELECT u.id,u.user_name as LOGIN_NAME,u.user_desc as NAME,tor.DEPT_ID ,'' as type FROM JLOPAPUSER.sys_user u,JLOPAPUSER.sys_user_department tor WHERE u.ID = tor.USER_ID";
         sql += "  union all";
         sql += " select '1' as id ,'admin' as login_name  ,'超级管理员' as NAME ,'0' as DEPT_ID  ,'' as type from dual";
 

src/main/java/com/horizon/org/OrgBuilderImplSgiip.java

@@ -0,0 +1,320 @@
+package com.horizon.org;
+
+import com.horizon.common.collect.Lists;
+import com.horizon.core.HorizonCore;
+import com.horizon.db.Access;
+import com.horizon.third.build.OrgBuilder;
+import com.horizon.third.entity.OrgData;
+import com.horizon.third.entity.User;
+
+import java.util.*;
+
+/**
+ * @Author: yangff update  2024-03-21
+ */
+public class OrgBuilderImplSgiip extends OrgBuilder {
+
+    @Override
+    public List<OrgData> depts() {
+        System.out.println("当前租户标识：" + HorizonCore.TENANT_CODE.value());
+        String dbIdentifier = "sgiip";
+        Map<String, List<User>> usersDept = getUsersAndDept(dbIdentifier);//获取部门与用户的对应关系
+        // id：部门id； dept_code ：部门编号 ； dept_name：部门名称 ；parent_id：部门父节点id，必须存在 ； order_no 排序号，没有可默认
+//        String deptsql = "select id,dept_code,dept_name,parent_id,order_no from to_horizon_dept where  id!='root_node_id' order by order_no";
+
+        String deptsql = "";
+        deptsql += " select d.id,d.dept_code,d.dept_name, ( select a.id from sgiip.sys_department a where a.dept_code = d.f_id ) as parent_id  ,";
+        deptsql += " 'D' as type ,0 as order_no ";
+        deptsql += " from sgiip.sys_department d where d.cancel_flag = '0' and  d.dept_code!='D' ";
+
+
+        List<Map<String, Object>> deptmap = Access.getMultiMap(deptsql, null, dbIdentifier);
+        //部门信息封装到datas对象中，作为返回值
+        List<OrgData> datas = Lists.newArrayList();
+        //处理根部门
+        OrgData data_r = new OrgData();
+        data_r.setId("1");
+        data_r.setName("部门导航");
+        data_r.setParentId("0");
+        data_r.setType("D");
+        datas.add(data_r);
+        for (Map<String, Object> map : deptmap) {
+            String id = map.get("id") == null ? "" : map.get("id").toString();
+            String name = map.get("dept_name") == null ? "" : map.get("dept_name").toString();
+            String bmbh = map.get("dept_code") == null ? "" : map.get("dept_code").toString();
+            String parentId = map.get("parent_id") == null ? "" : map.get("parent_id").toString();
+            String sort = map.get("order_no") == null ? "" : map.get("order_no").toString();
+
+            if ("0".equals(parentId)) {
+                parentId = "1"; //部门导航、最顶层
+            }
+            //一个data对象封装一个部门信息
+            OrgData data_d = new OrgData();
+            data_d.setId(id);
+            data_d.setName(name);
+            data_d.setParentId(parentId);
+            data_d.setType("D");
+            data_d.setOrderNo(Integer.parseInt(sort));
+            data_d.setCode(bmbh);
+            //usermap.get(id)根据部门ID获取此部门人员，并保存到data对象中
+            if (usersDept.get(id) != null) {//判断通过id键获取的用户信息不为空，增加对应用户信息
+                data_d.setUsers(usersDept.get(id));
+            }
+            //封装部门信息的实例增加到datas对象中
+            datas.add(data_d);
+        }
+        return datas;
+    }
+
+    /**
+     * 获取部门下人员信息，此方法是获取用户与部门关联的信息，部门ID作为键，User对象为值
+     *
+     * @return
+     */
+    private Map<String, List<User>> getUsersAndDept(String dbIdentifier) {
+//        String usersql = "select u.id,u.login_name,u.name,tor.dept_id from to_horizon_user u,tor_horizon_user_dept tor where u.id = tor.user_id";
+//        String usersql = "select u.id,u.user_name as login_name,u.user_desc,tor.dept_id from sgiip.sys_user u,sgiip.sys_user_department tor where u.id = tor.user_id";
+        String usersql = "";
+        usersql += "  SELECT u.id,u.user_name as LOGIN_NAME,u.user_desc as NAME,tor.DEPT_ID ,'' as type FROM sgiip.sys_user u,sgiip.sys_user_department tor WHERE u.ID = tor.USER_ID";
+        usersql += "  union all";
+        usersql += " select '1' as id ,'admin' as login_name  ,'超级管理员' as NAME ,'0' as DEPT_ID  ,'' as type from dual";
+
+
+        List<Map<String, Object>> userMap = Access.getMultiMap(usersql, null, dbIdentifier);
+        Map<String, List<User>> usersAndDept = new HashMap<String, List<User>>();
+        for (Map<String, Object> map : userMap) {
+            //部门ID
+            String deptId = map.get("dept_id") == null ? "" : map.get("dept_id").toString();
+            //用户名
+            String userName = map.get("name") == null ? "" : map.get("name").toString();
+            //用户ID
+            String id = map.get("id") == null ? null : map.get("id").toString();
+            //若存在ID为null的User对象，那么在获取用户信息时，会出现空指针错误
+            if (id != null) {
+                //用户信息存入user对象中
+                User user = new User();
+                user.setId(id);
+                user.setUserName(userName);
+                List<User> users = new ArrayList<User>();
+                if (usersAndDept.get(deptId) == null) {//第一次存入部门与用户对应信息
+                    users.add(user);
+                    usersAndDept.put(deptId, users);
+                } else {//已存在该部门与用户的对应信息
+                    users = usersAndDept.get(deptId);
+                    users.add(user);
+                    usersAndDept.put(deptId, users);
+                }
+            }
+        }
+        return usersAndDept;
+    }
+
+    @Override
+    public List<OrgData> groups() {
+
+        return null;
+
+//        String dbIdentifier = "sgiip";
+//        Map<String,List<User>> usersAndGroup = getUsersAndGroup(dbIdentifier);
+//        // code是编号；  群组跟部门一样，支持树形结构
+//        String usersql = "select id,group_name,group_code,parent_id from to_horizon_group WHERE ID!='root_node_id'";
+//        List<Map<String,Object>> userMap = Access.getMultiMap(usersql, null, dbIdentifier);
+//        //群组信息封装到datas对象中，作为返回值
+//        List<OrgData> datas = Lists.newArrayList();
+//        OrgData data_r = new OrgData();//群组根数据，根数据的parentid需要为null
+//        data_r.setId("group_root");
+//        data_r.setName("角色导航");
+//        data_r.setParentId(null);
+//        data_r.setType("G");
+//        datas.add(data_r);
+//        for (Map<String, Object> map : userMap) {
+//            String id = map.get("id")==null?"":map.get("id").toString();
+//            String name = map.get("group_name")==null?"":map.get("group_name").toString();
+//            String code = map.get("group_code")==null?"":map.get("group_code").toString();
+//            String parentid = map.get("parent_id")==null?"":map.get("parent_id").toString();
+//
+//            //如果是一级群组，需要转换下根部门，根据实际情况修改名称
+//            if("root_node_id".equals(parentid)){
+//                parentid="group_root";
+//            }
+//            OrgData data_g = new OrgData();
+//            data_g.setId(id);
+//            data_g.setName(name);
+//            data_g.setCode(code);
+//            data_g.setParentId(parentid);
+//            if (usersAndGroup.get(id) != null){//判断通过id键获取的用户信息不为空，增加对应用户信息
+//                data_g.setUsers(usersAndGroup.get(id));
+//            }
+//            //必须固定
+//            data_g.setType("G");
+//            datas.add(data_g);
+//        }
+//         return datas;
+
+    }
+
+    @Override
+    public List<OrgData> positions() {
+        System.out.println("当前租户标识：" + HorizonCore.TENANT_CODE.value());
+        String dbIdentifier = "sgiip";
+        Map<String, List<User>> usersDept = getUsersAndPost(dbIdentifier);//获取部门与用户的对应关系
+        // id：部门id； dept_code ：部门编号 ； dept_name：部门名称 ；parent_id：部门父节点id，必须存在 ； order_no 排序号，没有可默认
+//        String deptsql = "select id,dept_code,dept_name,parent_id,order_no from to_horizon_dept where  id!='root_node_id' order by order_no";
+
+        String deptsql = "";
+        deptsql += " select d.id,d.post_code,d.post_name, 'position_root' as parent_id,";
+        deptsql += " 'P' as type ,0 as order_no";
+        deptsql += " from sgiip.sys_post d where d.cancel_flag = '0'";
+
+
+        List<Map<String, Object>> deptmap = Access.getMultiMap(deptsql, null, dbIdentifier);
+        //部门信息封装到datas对象中，作为返回值
+        List<OrgData> datas = Lists.newArrayList();
+        //处理根部门
+        OrgData data_r = new OrgData();
+        data_r.setId("position_root");
+        data_r.setName("岗位导航");
+        data_r.setParentId("0");
+        data_r.setType("P");
+        datas.add(data_r);
+        for (Map<String, Object> map : deptmap) {
+            String id = map.get("id") == null ? "" : map.get("id").toString();
+            String name = map.get("post_name") == null ? "" : map.get("post_name").toString();
+            String bmbh = map.get("post_code") == null ? "" : map.get("post_code").toString();
+            String parentId = map.get("parent_id") == null ? "" : map.get("parent_id").toString();
+            String sort = map.get("order_no") == null ? "" : map.get("order_no").toString();
+
+            if ("0".equals(parentId)) {
+                parentId = "1"; //部门导航、最顶层
+            }
+            //一个data对象封装一个部门信息
+            OrgData data_d = new OrgData();
+            data_d.setId(id);
+            data_d.setName(name);
+            data_d.setParentId(parentId);
+            data_d.setType("P");
+            data_d.setOrderNo(Integer.parseInt(sort));
+            data_d.setCode(bmbh);
+            //usermap.get(id)根据部门ID获取此部门人员，并保存到data对象中
+            if (usersDept.get(id) != null) {//判断通过id键获取的用户信息不为空，增加对应用户信息
+                data_d.setUsers(usersDept.get(id));
+            }
+            //封装部门信息的实例增加到datas对象中
+            datas.add(data_d);
+        }
+        return datas;
+    }
+
+
+    private Map<String, List<User>> getUsersAndPost(String dbIdentifier) {
+        String usersql = " SELECT u.id,u.user_name as LOGIN_NAME,u.user_desc as NAME,tor.post_ID ,'' as type FROM sgiip.sys_user u,sgiip.sys_user_post tor WHERE u.ID = tor.USER_ID ";
+        List<Map<String, Object>> userMap = Access.getMultiMap(usersql, null, dbIdentifier);
+        Map<String, List<User>> usersAndDept = new HashMap<String, List<User>>();
+        for (Map<String, Object> map : userMap) {
+            //部门ID
+            String deptId = map.get("post_id") == null ? "" : map.get("post_id").toString();
+            //用户名
+            String userName = map.get("name") == null ? "" : map.get("name").toString();
+            //用户ID
+            String id = map.get("id") == null ? null : map.get("id").toString();
+            //若存在ID为null的User对象，那么在获取用户信息时，会出现空指针错误
+            if (id != null) {
+                //用户信息存入user对象中
+                User user = new User();
+                user.setId(id);
+                user.setUserName(userName);
+                List<User> users = new ArrayList<User>();
+                if (usersAndDept.get(deptId) == null) {//第一次存入部门与用户对应信息
+                    users.add(user);
+                    usersAndDept.put(deptId, users);
+                } else {//已存在该部门与用户的对应信息
+                    users = usersAndDept.get(deptId);
+                    users.add(user);
+                    usersAndDept.put(deptId, users);
+                }
+            }
+        }
+        return usersAndDept;
+    }
+
+
+    @Override
+    public List<OrgData> roles() {
+        return null;
+    }
+
+    //获取工作群组人员
+    private Map<String, List<User>> getUsersAndGroup(String dbIdentifier) {
+        // 需要群组id，用户id，用户name
+        String userSql = "select tor.workgroup_id,u.id,u.name from tor_horizon_user_group tor , to_horizon_user u where tor.user_id= u.id";
+        List<Map<String, Object>> userMap = Access.getMultiMap(userSql, null, dbIdentifier);
+        Map<String, List<User>> usersAndGroup = new HashMap<String, List<User>>();
+        for (Map<String, Object> map : userMap) {
+            List<User> users = new ArrayList<User>();
+            String id = map.get("id") == null ? "" : map.get("id").toString();
+            String userName = map.get("name") == null ? "" : map.get("name").toString();
+            String workGroupId = map.get("workgroup_id") == null ? "" : map.get("workgroup_id").toString();
+            if (id != null) {//避免出现空指针错误,如此处ID与users方法中的userid不一致也会出现空指针错误
+                if (usersAndGroup.get(workGroupId) == null) {//第一次操作岗位信息
+                    User user = new User();
+                    user.setId(id);
+                    user.setUserName(userName);
+                    users.add(user);
+                    usersAndGroup.put(workGroupId, users);
+                } else {//已有岗位信息，进行从新编辑
+                    users = usersAndGroup.get(workGroupId);
+                    User user = new User();
+                    user.setId(id);
+                    user.setUserName(userName);
+                    users.add(user);
+                    usersAndGroup.put(workGroupId, users);
+                }
+            }
+        }
+        return usersAndGroup;
+    }
+
+
+    @Override
+    public List<User> users() {
+        String dbIdentifier = "sgiip";
+        //id，用户唯一id；  login_name,用户登录名；   name，用户姓名；  dept_id，用户所属部门id ；
+//        String sql="SELECT u.id,u.LOGIN_NAME,'F;D' as type,u.NAME,tor.DEPT_ID FROM TO_HORIZON_USER u,TOR_HORIZON_USER_DEPT tor WHERE u.ID = tor.USER_ID";
+
+        String sql = "";
+        sql += "  SELECT u.id,u.user_name as LOGIN_NAME,u.user_desc as NAME,tor.DEPT_ID ,'' as type FROM sgiip.sys_user u,sgiip.sys_user_department tor WHERE u.ID = tor.USER_ID";
+        sql += "  union all";
+        sql += " select '1' as id ,'admin' as login_name  ,'超级管理员' as NAME ,'0' as DEPT_ID  ,'' as type from dual";
+
+        //从数据库获取用户信息
+        List<Map<String, Object>> usermap = Access.getMultiMap(sql, null, dbIdentifier);
+        //用户信息保存到datas集合对象中返回
+        List<User> datas = Lists.newArrayList();
+        for (Map<String, Object> map : usermap) {
+            String id = map.get("id") == null ? "" : map.get("id").toString();
+            String name = map.get("name") == null ? "" : map.get("name").toString();
+            String loginName = map.get("login_name") == null ? "" : map.get("login_name").toString();
+            String deptid = map.get("dept_id") == null ? "" : map.get("dept_id").toString();
+
+            //处理用户所属部门，可以所属多个部门
+            List<String> listDept = Lists.newArrayList(deptid);
+//            listDept.add(deptid);
+            //用户信息保存到User类的对象中
+            User u = new User();
+            u.setId(id);
+            u.setUserName(name);
+            u.setLoginName(loginName);
+            u.setPasswd("1234");//密码，一般设置默认统一的密码
+            u.setDepartment(listDept);
+            u.setOrderNo(1);//用户排序，可选
+
+            if(Objects.equals(id, "24F955A08CD8CDECE063040011AC9F7F") && listDept.contains("25855EBF0D906250E063040011ACA98F")){
+                u.setOperType("F");//用户类型（F：直接部门领导，C：上级主管领导，I：部门管理员，空：一般用户，可传多值，多值用;隔开）
+            }else {
+                u.setOperType("");//用户类型（F：直接部门领导，C：上级主管领导，I：部门管理员，空：一般用户，可传多值，多值用;隔开）
+            }
+            datas.add(u);
+        }
+        return datas;
+    }
+}

src/main/java/com/horizon/org/web/OrgSysController.java

@@ -1,17 +1,12 @@
 package com.horizon.org.web;
 
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
 import com.horizon.third.init.WorkflowAdapterInit;
 import org.springframework.stereotype.Controller;
-import org.springframework.web.bind.annotation.ModelAttribute;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody;
 
 import com.alibaba.fastjson.JSON;
-import com.horizon.wf.bean.WorkParaBeanBase;
 import com.horizon.workflow.rest.web.base.RestSuperController;
 
 @Controller

src/main/java/com/horizon/wf/action/ActionGetBack.java

@@ -0,0 +1,305 @@
+package com.horizon.wf.action;
+
+
+import com.horizon.wf.action.base.BaseAction;
+import com.horizon.wf.core.node.INextNode;
+import com.horizon.wf.core.node.ITaskNode;
+import com.horizon.wf.core.runtime.RunningData;
+import com.horizon.wf.core.work.ICustomAction;
+import com.horizon.wf.definition.pub.IFlowNode;
+import com.horizon.wf.definition.pub.node.INodeControl;
+import com.horizon.wf.definition.tools.NodeTypeEnum;
+import com.horizon.wf.entity.db.DBTodo;
+import com.horizon.wf.entity.db.DBTrack;
+import com.horizon.wf.entity.db.DBWorkAuth;
+import com.horizon.wf.global.CollectionUtil;
+import com.horizon.wf.global.StaticVarExtend;
+import com.horizon.wf.global.StringUtilExtend;
+import com.horizon.wf.tools.AccessUtil;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 正常拿回操作实现类
+ * **不支持节点内部拿回
+ * 此类为同一路径下的节点间拿回,从分支和合并节点拿回时,系统在获取操作时,
+ * 自动对操作实现类进行重置为ActionGetBackForBranch和ActionGetBackForMerger
+ * @author liys
+ * @version 1.0
+ * @since v7.2.2
+ */
+public class ActionGetBack extends BaseAction implements ICustomAction {
+    private List<INextNode> nextNodes =null;
+    /**
+     * 操作调用的方法
+     */
+    public boolean execute(ITaskNode curTaskNode) {
+
+        runningdata.setFunname(StaticVarExtend.OPERATOR_FUNNAME_GETBACK);
+        setActionname("GetBack_Msg0001","拿回");
+        if(isGetBack()){
+            msg = pubInfo.getInfo("GetBack_Msg0002", "拿回成功");
+            getCurTrack().setFlowstatus(StaticVarExtend.FlowStatus_GetBack);
+            //将办理人设置的交互对象中,供节点进入事件使用
+            selectedUsers = new LinkedHashMap<String, String>();
+
+            //将当前人员放到人员列表中
+            selectedUsers.put(StaticVarExtend.AUTH_AUTHOR,  getCurUser().getFullName());
+            /**
+             * 20160711 liys
+             * 拿回分为以下几种情况:
+             * 1.同一路径内流转时的拿回,例如:(N1->N2->N3),N2的办理人在流转到N3节点时执行拿回
+             * 2.路径出现分支时,各分支未处理之前,例如:(N1->N2,N1->N3),N1的办理人在N2或者N3上执行拿回,
+             *   每次只能拿回一个分支,拿回后的N1其实是在分支路径上,而不是在分支之前的路径上
+             */
+            //将本来的主办人都设置为读者
+            List<DBWorkAuth> curAuth = runningdata
+                    .getListAuthLikeAuthorByTrackid(getCurTrack().getId());
+//			curAuth.addAll(getXAuthList(StaticVarExtend.AUTH_SECOND_AUTHOR));
+            for(int i=0,n=curAuth.size();i<n;i++){
+                DBWorkAuth a  = curAuth.get(i);
+                //更改其余办理人权限
+                a.setStatus(StaticVarExtend.AUTH_CREADER);
+            }
+
+            //将处理好的人员列表放回底层
+            runningdata.setCurAuthToMap(curAuth);
+            curTaskNode.backToPrevNode(nextNodeList, selectedUsers);
+            INextNode curNode = curTaskNode.getCurNode();
+            result = curNode.getInitResult();
+            msg = curNode.getBackMsg();
+            if(result == StaticVarExtend.F_STATUS_Success){
+                nextNodes = curTaskNode.getGNextNodes();
+                getCurTrack().setEnd(true);//结束当前路径
+                ac.dowithTimer("cancel", getCurNodeType(), runningdata, getIdentifier());//如果当前节点包含定时任务则撤销定时任务
+
+                //2024-2-19 触发进入事件，如果同时想触发进入事件和离开事件，参数传递true
+                doWithNextNodeResult(false);
+
+                //执行操作完成事件
+                if(executeEventSave()){
+//					selectedUsers = ac.makeAgentUser(selectedUsers, runningdata);
+                    runningdata.setUpdateTask(true);
+                    msg = pubInfo.getInfo("GetBack_Msg0002", "拿回成功");
+                    memoBuffer.append(msg);
+                }
+            }
+        }
+        getCurTrack().setFlowstatus(StaticVarExtend.FlowStatus_GetBack);
+        runningdata.setBackMsg(msg);
+        runningdata.setResultCode(result);
+        return true;
+    }
+
+    /**
+     * 判断是否允许拿回
+     * @return
+     */
+    protected boolean isGetBack(){
+        if(!isNodeGetBack()){//节点不在可拿回节点的类型范围之内
+            result = StaticVarExtend.F_STATUS_OtherError;
+            msg = pubInfo.getInfo("GetBack_Msg0003","当前节点不在可拿回的节点类型范围之内");
+            return false;
+        }else if(isDone()){//当前流程已经办理,无法拿回
+            result = StaticVarExtend.F_STATUS_OtherError;
+            msg = pubInfo.getInfo("GetBack_Msg0004","当前流程已经办理,无法拿回");
+            return false;
+        }else if(isSave()){//当前流程主办人已经暂存，无法拿回
+            result = StaticVarExtend.F_STATUS_OtherError;
+            msg = pubInfo.getInfo("GetBack_Msg0005","当前流程主办人已暂存,无法拿回");
+            return false;
+        }else if(getCurTrack().getFlowstatus() != StaticVarExtend.FlowStatus_Normal){
+            result = StaticVarExtend.F_STATUS_OtherError;
+            msg = pubInfo.getInfo("GetBack_Msg0006","当前流程状态不是正常状态,不允许拿回");
+            return false;
+        }
+
+        return true;
+    }
+
+
+    /**
+     * 判断当前节点类型是否允许拿回
+     * @return true:允许拿回
+     */
+    protected boolean isNodeGetBack(){
+        int nodetype = getCurNodeType();
+        if(nodetype == NodeTypeEnum.Node_Single
+                || nodetype == NodeTypeEnum.Node_Multi_Single
+                || nodetype == NodeTypeEnum.Node_Multi
+                || nodetype == NodeTypeEnum.Node_Order
+                || nodetype == NodeTypeEnum.Node_Progressively){
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * 判断当前节点是否已经暂存
+     * @return
+     */
+    protected boolean isSave(){
+
+        String sql="SELECT L.ACTION FROM TW_HZ_LOG L WHERE L.WORKID=? AND L.TRACKID=? ORDER BY L.ACTIONTIME DESC";
+        List<Object> con= new ArrayList<Object>();
+        con.add(getWorkid());
+        con.add(getCurTrackid());
+        List<List<Object>> workLogs= AccessUtil.getInstance().getMultiList(sql,con,getIdentifier());
+        if(null==workLogs || workLogs.isEmpty())return false;
+        if("Save".equals(workLogs.get(0).get(0).toString())){
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * 判断当前节点是否已经办理
+     * @return
+     */
+    protected boolean isDone(){
+        //获取会签人员和已办人员
+        List<DBWorkAuth> curAuth = getXAuthList(StaticVarExtend.AUTH_DONE);
+        curAuth.addAll(getXAuthList(StaticVarExtend.AUTH_HUIQIAN_AUTHOR));
+        curAuth.addAll(getXAuthList(StaticVarExtend.AUTH_START_HUIQIAN_AUTHOR));
+
+        return CollectionUtil.isListNotEmpty(curAuth);
+    }
+
+    /**
+     * 判断当前操作人是否为主办
+     * @return true:当前人是主办
+     */
+    private boolean isCurUserAuthor(){
+        List<DBWorkAuth> authors =  getXAuthList(StaticVarExtend.AUTH_AUTHOR);
+        for(int i=0,n=authors.size();i<n;i++){
+            DBWorkAuth a = authors.get(i);
+            if(a.equalsRunUser(getCurUser())){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * 给task表添加数据
+     */
+    public Map<String,List<Object>>  actionForTask() {
+        Map<String, List<Object>> saveMap = new LinkedHashMap<String, List<Object>>();
+        actionForTask(saveMap);
+        //下一节点任务创建
+        for(int i=0,n=runningdata.getNextTrackList().size();i<n;i++){
+            DBTrack tTrack = runningdata.getNextTrackList().get(i);
+            createTaskObj(null,tTrack,saveMap);
+        }
+        return saveMap;
+    }
+    /**
+     * 取消分支时调用
+     */
+    public void cancelTrackAction(String arg0, List<DBWorkAuth> arg1) {
+
+    }
+
+    /**
+     * 当取消某个路径的激活状态时,对应的权限变化规则设定<br>
+     * (比如把待办的状态改为只读,或者是删除,或者忽略)<br>
+     * 如果不指定,则忽略权限变更(比如Reader不需要处理)<br>
+     * 主要用于合并节点提交时,如果有其他分支未到达时,对未到达的分支的参与者进行处理<br>
+     * @return key=修改前的权限名称(比如:办理人Author),value=修改后的权限名称(比如:只读权限CReader)
+     */
+    public Map<String,String> getCancelTrackAuthRuleMap(){
+        return null;
+    }
+    /**
+     * 保存之后的接口方法.例如:消息数据的更新
+     */
+    public void actionAfterSaveToDB() {
+        if(isNotSaveToDB){
+            return;
+        }
+        actionStartTodoThread();
+    }
+    /**
+     * 保存数据之前的接口方法.例如:消息数据的处理
+     * key=sql,value=parameter
+     */
+    public Map<String,List<Object>> actionBeforeSaveToDB() {
+        Map<String, List<Object>> saveMap = new LinkedHashMap<String, List<Object>>();
+        sendTodo();
+        actionBefore(saveMap);
+        return saveMap ;
+    }
+    /**
+     * 当前节点权限处理(由操作再次干预参与者的接口)<br>
+     * auths列表中为系统节点默认处理完毕后的当前节点的参与者列表
+     * 对应的消息是否需要处理,可以在这个方法中写
+     */
+    public boolean chgCurNodeAuth(List<DBWorkAuth> auths) {
+        if(CollectionUtil.isListNotEmpty(auths)){
+            makeSendInfoByCurAuthList(auths);
+        }
+
+        return true;
+    }
+    /**
+     * 重写父类待办发送方法
+     * 给当前办理人发送待阅
+     */
+    protected void sendTodo(){
+        String getbackNodeId = getGetBackNode(runningdata);
+        if(StringUtilExtend.isNotNull(getbackNodeId)){
+            if(isTrackByNodeId(getbackNodeId, StaticVarExtend.FlowStatus_Reject, getWorkid(), getIdentifier())){
+                runningdata.putMsgToConsole("[msg]this node have track.");
+                return;
+            }
+        }
+
+        String todoUser = selectedUsers.get(StaticVarExtend.AUTH_AUTHOR);
+        DBTodo todo = makeDefaultDBTodo();
+        String nodeid="";
+        if(nextNodes != null){
+            nodeid = nextNodes.get(0).getNodeid();
+        }
+        IFlowNode node = runningdata.getInstanceDefinition().getFlowinfo().getNodeById(nodeid);
+        DBTrack track = getTrackIdByNodeId(nodeid);
+        makeSendInfoForNewAuth(todo,todoUser,StaticVarExtend.AUTH_AUTHOR,StaticVarExtend.Send_Todo,
+                null,track,node);
+    }
+    /**
+     * 在指定节点是否有指定状态的track
+     * @param nodeid
+     * @param status
+     * @param workid
+     * @param identifier
+     */
+    private boolean isTrackByNodeId(String nodeid, int status, String workid, String identifier){
+        String sql = "SELECT id FROM " + StaticVarExtend.Table_Track +" WHERE WORKID=? AND NODEID=? AND FLOWSTATUS=?";
+        List<Object> conditionList = new ArrayList<Object>();
+        conditionList.add(workid);
+        conditionList.add(nodeid);
+        conditionList.add(status);
+        int count = AccessUtil.getInstance().getRsCount(sql, conditionList, identifier);
+        if(count == 0){
+            return false;
+        }
+        return true;
+    }
+    /**
+     * 当前节点是否为上一节点,拿回操作调用
+     * @return
+     */
+    private String getGetBackNode(RunningData rd){
+        IFlowNode node = rd.getCurFlowNode();
+        INodeControl control = node.getParticipantsControl(StaticVarExtend.AUTH_DONE+"_DO");
+        String allNodes = "";
+        if(null != control){
+            allNodes = control.getAllowGetBackNode();
+        }
+        //获取上一节点
+        return allNodes;
+    }
+
+}

src/main/java/com/horizon/wf/action/ActionSubmit.java

@@ -0,0 +1,744 @@
+package com.horizon.wf.action;
+
+import com.horizon.wf.action.base.BaseForTask;
+import com.horizon.wf.action.base.IActionForStartSubFlow;
+import com.horizon.wf.action.base.SubflowEnd;
+import com.horizon.wf.config.HZResourceBundle;
+import com.horizon.wf.core.node.INextNode;
+import com.horizon.wf.core.node.ITaskNode;
+import com.horizon.wf.core.runtime.RunningData;
+import com.horizon.wf.core.track.json.impl.ITrackJson;
+import com.horizon.wf.core.work.ICustomAction;
+import com.horizon.wf.definition.pub.IFlowInfo;
+import com.horizon.wf.definition.pub.IFlowNode;
+import com.horizon.wf.definition.pub.node.INodeControl;
+import com.horizon.wf.definition.pub.node.INodeForm;
+import com.horizon.wf.definition.pub.node.INodeRouter;
+import com.horizon.wf.definition.tools.NodeTypeEnum;
+import com.horizon.wf.entity.db.*;
+import com.horizon.wf.entity.user.INodeUser;
+import com.horizon.wf.expand.impl.IOrganizationInterface;
+import com.horizon.wf.global.*;
+import com.horizon.wf.plugins.PluginsUtil;
+import com.horizon.wf.rule.jsr94.IRuleEngine;
+
+import java.util.*;
+
+/**
+ * 提交操作实现类
+ *
+ * @author liys
+ * @version 1.0
+ * @since v7.0
+ */
+public class ActionSubmit extends BaseForTask implements ICustomAction,
+        IActionForStartSubFlow {
+    private List<INextNode> nextNodes = new ArrayList<INextNode>();
+    private boolean isSendTodo = true;// 是否发送待办
+    private boolean isMakeTaskData = true;// 是否生成task数据
+    private SubflowEnd subflowEnd = null;// 子流程实例结束时,主流程是否可以往下流转处理类
+
+    /**
+     * 本操作需要执行的内容
+     */
+    public boolean execute(ITaskNode curTaskNode) {
+        setFunnameToRunningdata();
+
+        // 提交到退回节点时,如果需要重新选择办理人,则把下面的赋值语句打开即可,不打开则获取退回节点的原来办理人(包含没有办理的人)
+        if (runningdata.getCurTrack().getFlowstatus() == StaticVarExtend.FlowStatus_Reject) {
+            runningdata.getCurTrack().setFlowstatus(
+                    StaticVarExtend.FlowStatus_Normal);
+        }
+        normalSubmit(curTaskNode);
+        // 执行操作完成事件
+        if (StaticVarExtend.F_STATUS_Success == result && executeEventSave()) {
+            handleFirstStart();// 处理第一次操作的 权限
+            if (actionSuccess(resultBean.getNextNodes())) {
+                runningdata.setUpdateTask(true);
+                if("Start".equals(curTaskNode.getNodeid()) && !HZResourceBundle.getInstance().isSaveToDBWhenStartInstance()){
+                    // 开始节点只有没有业务表单
+                    String[] formids={"FlowTrack"};
+                    runningdata.getInitData().setFormids(formids);
+                }else{
+                    // 获取当前人有权限的表单
+                    runningdata.getInitData().setFormids(
+                            ac.setFormIdsByRunningdata(getCurFlowNode(),
+                                    getCurUser()));
+                }
+
+            } else {
+                result = StaticVarExtend.F_STATUS_OtherError;
+            }
+        }
+
+        runningdata.setBackMsg(msg);
+        runningdata.setResultCode(result);
+        return true;
+    }
+
+    protected void setFunnameToRunningdata() {
+        runningdata.setFunname(StaticVarExtend.OPERATOR_FUNNAME_SUBMIT);
+        setActionname("Submit_Msg0001", "提交");
+    }
+
+    /**
+     * 处理第一次操作
+     */
+    private void handleFirstStart() {
+        List<DBWorkAuth> auths = new ArrayList<DBWorkAuth>();
+        DBTrack track = runningdata.getCurTrack();
+        IFlowNode curNode = runningdata.getCurFlowNode();
+        // 是否第一次操作
+        if (isnewdoc < 2) {
+            isNewDoc("2");
+            // 全局读者
+            String flowreaders = changeReaderList(runningdata);
+            if (StringUtilExtend.isNotNull(flowreaders)) {
+                auths.add(makeAuthByAuthId(flowreaders,
+                        StaticVarExtend.AUTH_READER, ""));
+
+                // 增加发送消息
+                DBTodo frTodo = makeDefaultDBTodo();
+                frTodo.setAuthId(flowreaders);
+                frTodo.setTrackactive(String.valueOf(track.getActive()));
+                frTodo.setTrackid(track.getId());
+                frTodo.setTrackstatus(String.valueOf(track.getFlowstatus()));
+                frTodo.setNodeid(getCurNodeid());
+                frTodo.setNodename(track.getNodename());
+                frTodo.setWorkver((track.getVersion() + 1));
+
+                IFlowInfo flowInfo = runningdata.getInstanceDefinition()
+                        .getFlowinfo();
+                String msgType = flowInfo.getReaderMsg();
+
+                String dMsg = StaticVarExtend.Send_Read;
+                // 20150727 liys 修改为默认发送待阅消息,不管定义是否勾选
+                DBTodo nTodo = frTodo.copy();
+                nTodo.setTitle(ac.getTodoTitle(track.getId(), curNode,
+                        runningdata, dMsg, StaticVarExtend.AUTH_READER));
+                nTodo.setStatus(StaticVarExtend.AUTH_READER);
+                todoLst.add(nTodo);
+
+                String[] msgSendTypes = msgType
+                        .split(StaticVarExtend.StrSplitChar);
+                for (String str : msgSendTypes) {
+                    if (null == str || "".equals(str)
+                            || str.equalsIgnoreCase(dMsg)) {
+                        continue;
+                    }
+                    DBTodo oTodo = frTodo.copy();
+                    oTodo.setTitle(ac.getTodoTitle(track.getId(), curNode,
+                            runningdata, str, StaticVarExtend.AUTH_READER));
+                    oTodo.setStatus("");
+                    oTodo._setOtherstatus(str);
+                    todoLst.add(oTodo);
+                }
+
+            }
+
+            if (isnewdoc == 0) {
+                String doneId = getCurUser().getFullName();
+                // 增加创建者权限
+                DBWorkAuth creator = makeAuthByAuthId(doneId,
+                        StaticVarExtend.AUTH_CREATOR, "");
+                creator.setAuthType(StaticVarExtend.UserFix);
+                auths.add(creator);
+            }
+
+        }
+        if (!auths.isEmpty()) {
+            runningdata.setCurAuthToMap(auths);
+        }
+    }
+
+    /**
+     * 将全局读者的list转换成string
+     * @return 转换后的字符串
+     */
+    private String changeReaderList(RunningData rd) {
+        StringBuilder readers = new StringBuilder("");
+        String dataIdentifier = rd.getInitData().getDataIdentifier();
+        List<String> readersList = rd.getInstanceDefinition().getFlowinfo()
+                .getReader();
+        IOrganizationInterface organization = PluginsUtil.getMultiInstance().getOrganization(rd.getInitData().getTenantid());
+        if (CollectionUtil.isListNotEmpty(readersList)) {
+            // 个人,无前缀
+            if (StringUtilExtend.isNotNull(readersList.get(0))) {
+                String[] persons = readersList.get(0).split(
+                        StaticVarExtend.UserSplitChar);
+                for (String s : persons) {
+                    if(!s.startsWith(StaticVarExtend.UserFix+StaticVarExtend.Mark_Fix)){
+                        readers.append(StaticVarExtend.UserFix).append(StaticVarExtend.Mark_Fix);
+                    }
+                    readers.append(s).append(StaticVarExtend.UserSplitChar);
+                }
+            }
+            // 部门,有前缀
+            if (StringUtilExtend.isNotNull(readersList.get(1))) {
+                String[] depts = readersList.get(1).split(
+                        StaticVarExtend.UserSplitChar);
+                for (String s : depts) {
+                    if(!(s.startsWith(StaticVarExtend.DeptFix+StaticVarExtend.Mark_Fix)
+                            || s.startsWith(StaticVarExtend.DeptSubFix+StaticVarExtend.Mark_Fix))){
+                        if(s.startsWith("DF_") || s.startsWith("DL_") || s.startsWith("DJ_")) {
+                            String deptType = s.substring(0, 2);
+                            String deptId = s.substring(3);
+                            String type = null;
+                            if ("DJ".equals(deptType)){
+                                type = "I";
+                            }else if ("DL".equals(deptType)){
+                                type = "C";
+                            }else if ("DF".equals(deptType)){
+                                type = "F";
+                            }
+                            String userId = organization.getDeptSpecialUser(deptId, type, dataIdentifier);
+                            if (StringUtilExtend.isNotNull(userId)) {
+                                readers.append(StaticVarExtend.UserFix).append(StaticVarExtend.Mark_Fix).append(userId);
+                            }
+                            readers.append(StaticVarExtend.SubjectionFix);
+                            readers.append(StaticVarExtend.DeptFix).append(StaticVarExtend.Mark_Fix).append(deptId).append(StaticVarExtend.UserSplitChar);
+                        }else{
+                            readers.append(StaticVarExtend.SubjectionFix);
+                            readers.append(StaticVarExtend.DeptFix).append(StaticVarExtend.Mark_Fix).append(s).append(StaticVarExtend.UserSplitChar);;
+                        }
+                    }else {
+                        readers.append(StaticVarExtend.SubjectionFix).append(s).append(StaticVarExtend.UserSplitChar);
+                    }
+                }
+            }
+            // 群组,无前缀
+            if (StringUtilExtend.isNotNull(readersList.get(2))) {
+                String[] groups = readersList.get(2).split(
+                        StaticVarExtend.UserSplitChar);
+                for (String s : groups) {
+                    readers.append(StaticVarExtend.SubjectionFix);
+                    if(!s.startsWith(StaticVarExtend.GroupFix+StaticVarExtend.Mark_Fix)){
+                        readers.append(StaticVarExtend.GroupFix).append(StaticVarExtend.Mark_Fix);
+                    }
+                    readers.append(s).append(StaticVarExtend.UserSplitChar);
+                }
+            }
+            // 角色,无前缀
+            if (StringUtilExtend.isNotNull(readersList.get(3))) {
+                String[] roles = readersList.get(3).split(
+                        StaticVarExtend.UserSplitChar);
+                for (String s : roles) {
+                    readers.append(StaticVarExtend.SubjectionFix);
+                    if(!s.startsWith(StaticVarExtend.RoleFix+StaticVarExtend.Mark_Fix)){
+                        readers.append(StaticVarExtend.RoleFix).append(StaticVarExtend.Mark_Fix);
+                    }
+                    readers.append(s).append(StaticVarExtend.UserSplitChar);
+                }
+            }
+            // 岗位,无前缀
+            if (StringUtilExtend.isNotNull(readersList.get(4))) {
+                String[] positions = readersList.get(4).split(
+                        StaticVarExtend.UserSplitChar);
+                for (String s : positions) {
+                    readers.append(StaticVarExtend.SubjectionFix);
+                    if(!s.startsWith(StaticVarExtend.PosFix+StaticVarExtend.Mark_Fix)){
+                        readers.append(StaticVarExtend.PosFix).append(StaticVarExtend.Mark_Fix);
+                    }
+                    readers.append(s).append(StaticVarExtend.UserSplitChar);
+                }
+            }
+        }
+
+        String readerScript = rd.getInstanceDefinition().getFlowinfo()
+                .getReaderRuleScript();
+        if (StringUtilExtend.isNotNull(readerScript)) {
+            try {
+                IRuleEngine du = PluginsUtil.getMultiInstance().getRuleEngine();
+                du.setPara("RunningData", rd);
+
+                Object rs = du.exctu(readerScript);
+                if (null != rs) {
+                    readers.append(String.valueOf(rs));
+                }
+            } catch (Exception e) {
+                rd.putMsgToConsole("[err]get readerScript error!");
+            }
+        }
+        return readers.toString();
+    }
+
+    /**
+     * 根据authId生成auth对象
+     *
+     * @param authId
+     * @return
+     */
+    private DBWorkAuth makeAuthByAuthId(String authId, String status,
+                                        String oldStatus) {
+        DBWorkAuth a = new DBWorkAuth();
+        a.setAuthId(authId);
+        a.setAuthNo(0);
+        a.setNodeid(getCurNodeid());
+        a.setNodenum(0);
+        a.setStatus(status);
+        a.setOldStatus(oldStatus);
+
+        a.setTrackid(getCurTrackid());
+        a.setVersion(0);
+        a.setWorkid(getWorkid());
+        return a;
+    }
+
+    /**
+     * 正常提交（准备离开当前节点的提交）
+     *
+     * @param curTaskNode
+     */
+    private void normalSubmit(ITaskNode curTaskNode) {
+        runningdata.putMsgToConsole("[msg]docurNode start.");
+        boolean curResult = curTaskNode.doCurNode();
+        runningdata.putMsgToConsole("[msg]docurNode end.reulst:" + result);
+        // 前台参数
+        if (curResult) {// false时为当前节点不允许离开 如多人处理
+            leaveThisNode(curTaskNode, false);
+        } else {// 不离开当前节点
+            result = curTaskNode.getCurNode().getInitResult();
+            if (StaticVarExtend.F_STATUS_Success == result) {
+                msg = pubInfo.getInfo("Action_Msg0004", "提交成功");
+
+                int curNodeType = getCurNodeType();
+                // 当前节点是顺签和逐级办理的时候将办理人置于selectUsers用来发送待办
+                if (curNodeType == NodeTypeEnum.Node_Order
+                        || curNodeType == NodeTypeEnum.Node_Progressively) {
+                    List<INodeUser> nodeUserList = curTaskNode.getCurNode()
+                            .getListUserByNodeInit();
+                    for (int i = 0, n = nodeUserList.size(); i < n; i++) {
+                        INodeUser nu = nodeUserList.get(i);
+                        String key = curTaskNode.getCurNode().getKeyid()
+                                + StaticVarExtend.MARK_NODE_USER
+                                + nu.getAuthType();
+                        selectedUsers.put(key, nu.getNowid());
+                    }
+                    if (curNodeType == NodeTypeEnum.Node_Order) {
+                        memoBuffer.append(pubInfo.getInfo("Submit_Msg0006",
+                                "顺签办理"));
+                    } else {
+                        memoBuffer.append(pubInfo.getInfo("Submit_Msg0007",
+                                "逐级审批"));
+                    }
+                    doMemoFromSelected(curTaskNode.getCurNode());
+                } else if (curNodeType == NodeTypeEnum.Node_Merger) {
+                    result = StaticVarExtend.F_STATUS_UnitSubmit;
+                    msg = pubInfo.getInfo("Submit_Msg0002", "不符合离开规则,不能离开当前节点");
+                } else if (curNodeType == NodeTypeEnum.Node_Multi) {// 多人处理时将剩余办理人置于selectedUsers供前台显示
+                    isSendTodo = false;
+                    // 并行处理，等待其他人办理
+                    memoBuffer.append(pubInfo.getInfo("Submit_Msg0008",
+                            "多人处理，等待其他人办理"));
+                }
+                isMakeTaskData = false;// 不离开当前节点，不执行task表写入
+            }
+            // else if(StaticVarExtend.F_STATUS_SelectAuthor == result){
+            // //只有内部循环节点才会出现
+            //
+            // }
+            // else if(StaticVarExtend.F_STATUS_SelectNode == result){
+            // //只有内部循环节点才会出现
+            // leaveThisNode(curTaskNode,true);
+            // }
+            else {
+                msg = curTaskNode.getCurNode().getBackMsg();
+            }
+
+        }
+    }
+
+    /**
+     * 离开当前节点 addCurNode,是否增加当前节点到选择列表中
+     */
+    private void leaveThisNode(ITaskNode curTaskNode, boolean addCurNode) {
+        // 获取传入的下一节点和办理人信息
+        initNextNodePara();
+        leaveByRouter(curTaskNode);
+        if (result == StaticVarExtend.F_STATUS_Success) {
+            if (CollectionUtil.isListEmpty(nextNodes)) {
+                result = runningdata.getResultCode();
+                msg = runningdata.getBackMsg();
+                return;
+            }
+            doWithNextNodeResult(true);
+        }
+
+        // 20150513增加下一节点按路由序号排序
+        sortNextNodes();
+
+        resultBean.setNextNodes(nextNodes);// (curTaskNode.getGNextNodes());
+        StringBuilder sb = new StringBuilder(1000);
+        memoBuffer.append(pubInfo.getInfo("Submit_Msg0009", "提交到节点"));
+        for (int i = 0, m = nextNodes.size(); i < m; i++) {
+            INextNode n = nextNodes.get(i);
+            if (n.isSelected()) {
+                sb.append(StaticVarExtend.MARK_NODE_SPLIT).append(
+                        n.getSelectedIdStr());
+                doMemoFromSelected(n);
+            }
+        }
+        if (sb.length() > 0) {
+            sb.deleteCharAt(0);
+            nextNodeId = sb.toString();
+
+        }
+    }
+
+    private void leaveByRouter(ITaskNode curTaskNode) {
+        runningdata.putMsgToConsole("[msg]leaveByRouter start.");
+        // 没有传入选择节点内容时,系统默认根据定义查找下一节点
+        // 前台选择人员设置格式:key=节点id_参与者类型(Author,reader),value=userid(多个使用分号|)
+        // 此处传入的参数在节点进入规则接口中使用
+        if (checkForFree()) {
+            return;
+        }
+        curTaskNode.leaveByRouter(nextNodeList, selectedUsers);
+        result = curTaskNode.getCurNode().getInitResult();
+        int initResult = runningdata.getResultCode();
+        if (initResult != StaticVarExtend.F_STATUS_Success) {
+            initResult = runningdata.getResultCode();
+            msg = runningdata.getBackMsg();
+            return;
+        }
+        msg = curTaskNode.getCurNode().getBackMsg();
+        nextNodes = curTaskNode.getGNextNodes();// 获取符合条件的节点列表
+        runningdata.putMsgToConsole("[msg]leaveByRouter end.result:"
+                + initResult + ";msg:" + msg);
+    }
+
+    /**
+     * 自由提交时,用于检查节点是否有需要增加节点的处理 返回true表示终止程序
+     *
+     * @return
+     */
+    protected boolean checkForFree() {
+        return false;
+    }
+
+    /**
+     * 拿回状态,提交时直接给拿回之前的节点 下一节点进行处理
+     */
+    void doForGetBack(ITaskNode curTaskNode) {
+        DBTrack track = getCurTrack();
+        if (track.getFlowstatus() == StaticVarExtend.FlowStatus_GetBack) {
+            runningdata.putMsgToConsole("[msg]flowstatus = getback");
+            ITrackJson xmlTrack = track._getTrackJson();
+            String doneNodeID = xmlTrack.getTrueRecord();
+            String[] nodes = doneNodeID.split(StaticVar.StrSplitChar);
+            // 获取拿回前的节点
+            if (nodes.length > 1) {
+                List<INodeRouter> routers = curTaskNode.getFlowNode()
+                        .getAllToRouters();
+                String nodeid = nodes[nodes.length - 2];
+                for (int i = 0, n = routers.size(); i < n; i++) {
+                    INodeRouter router = routers.get(i);
+                    if (nodeid.equals(router.getNodeid())) {
+                        nextNodeId = router.getRouterid() + "~" + nodeid;
+                        break;
+                    }
+                }
+                if (StringUtilExtend.isNull(nextNodeId)) {
+                    // 拿回之前的节点跟当前节点无路由连接
+                    runningdata.putMsgToConsole("[msg]get back from jump node");
+                } else {
+                    // 重新初始化下一节点列表
+                    runningdata.putMsgToConsole("[msg]re init nextnodes");
+                    initNextNodePara();
+                }
+            }
+        }
+    }
+
+    private void sortNextNodes() {
+        List<INextNode> nodes = nextNodes;
+        List<INextNode> sortNodes = new ArrayList<INextNode>();
+        List<INextNode> tmpNode = new ArrayList<INextNode>();
+
+        for (int i = 0, n = nodes.size(); i < n; i++) {
+            INextNode node = nodes.get(i);
+            // 排序准备
+            INodeRouter tmpRouter = node.getFromXmlRouter();
+            if (tmpRouter == null) {
+                sortNodes.add(node);
+            } else {
+                tmpNode.add(node);
+            }
+        }
+        Collections.sort(tmpNode, new Comparator<INextNode>() {
+            public int compare(INextNode o1, INextNode o2) {
+                return o1.getFromXmlRouter().getSortnum()
+                        - o2.getFromXmlRouter().getSortnum();
+            }
+        });
+        sortNodes.addAll(tmpNode);
+
+        nextNodes = sortNodes;
+    }
+
+    // =================================================================================
+    /**
+     * 提交成功后执行 用于子流程结束时,对主流程的修改
+     *
+     * @param nextNodes2
+     */
+    private boolean actionSuccess(List<INextNode> nextNodes2) {
+        // 下一节点列表为空直接返回
+        if (CollectionUtil.isListEmpty(nextNodes2) || isNotSaveToDB) {
+            return true;
+        }
+        for (int i = 0, n = nextNodes2.size(); i < n; i++) {
+            INextNode nextNode = nextNodes2.get(i);
+            int nextNodeType = nextNode.getFlowNode().getNodetype();
+            if (ac.isEndNode(nextNodeType)) {
+                // 2016-03-17 liys 实例结束的情况下,对其他活动分支进行关闭
+                if (ac.isEndInstanceNode(nextNodeType)) {
+                    if(nextNodes2.size()>1){
+                        msg=pubInfo.getInfo("Action_Msg0014", "下节点路由包含实例结束节点不允许多选");
+                        return false;
+                    }
+                    runningdata.cancelOtherTrackForEndInstance(getCurTrackid());
+                }
+            } else if (nextNodeType == NodeTypeEnum.Node_Mutual) {
+                // 引擎交互节点,
+                if (!doWithMutualNode(nextNode)) {
+                    return false;
+                }
+            } else if (nextNodeType == NodeTypeEnum.Node_Sub) {
+                // 子流程节点,内嵌子流程时的处理
+                if (!doWithInnerSubFlow(nextNode)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    /**
+     * 引擎交互节点时,处理数据和相关任务
+     *
+     * @param node
+     * @return
+     */
+    private boolean doWithMutualNode(INextNode node) {
+        // 放到ActionExtraData.doWithNextNodesExtraData(RunningData,
+        // List<Object>)中处理
+        // 此处无法获确定trackid
+        return true;
+    }
+
+    /**
+     * 内嵌子流程启动处理
+     *
+     * @param node
+     * @return
+     */
+    private boolean doWithInnerSubFlow(INextNode node) {
+        // 放到ActionExtraData.doWithNextNodesExtraData(RunningData,
+        // List<Object>)中处理
+        return true;
+    }
+
+    /**
+     * 给task表添加数据
+     */
+    public Map<String, List<Object>> actionForTask() {
+        runningdata.putMsgToConsole("[msg]actionForTask start.");
+        Map<String, List<Object>> saveMap = new LinkedHashMap<String, List<Object>>();
+        if (!isMakeTaskData) {// 不执行task表的写入
+            return saveMap;
+        }
+        if (isNotSaveToDB
+                || paraBean.getFunname().equals(
+                StaticVarExtend.OPERATOR_FUNNAME_URGE)) {
+            return saveMap;
+        }
+        // 流程结束,无论是否配置删除版本,task都需要清理
+        if (runningdata.isFlowEnd()) {
+            // 20161122 liys 子流程结束时,对主流程的处理,由actionSuccess方法中移动到此处
+            // 可以避免子流程只是分支结束时,也对主流程的处理
+            subflowEnd = new SubflowEnd(this);
+            if (!subflowEnd.doWithSubFlowEnd()) {
+                // 结束节点时的额外处理
+                runningdata.setResultCode(StaticVarExtend.F_STATUS_OtherError);
+                return null;
+            }
+
+//			List<Object> para = new ArrayList<Object>(1);
+//			para.add(runningdata.getInitData().getWorkid());
+//			List<Object> lst = new ArrayList<Object>();
+//			lst.add(para);
+//			saveMap.put(
+//					("DELETE FROM " + StaticVarExtend.Table_Task + " WHERE WORKID=? "),
+//					lst);
+            DBTask.delSQLByWorkid(saveMap, runningdata.getResultJson(), runningdata.getWork().getId());
+            return saveMap;
+        }
+        actionForTask(saveMap);
+        // 下一节点任务创建
+        for (int i = 0, n = runningdata.getNextTrackList().size(); i < n; i++) {
+            DBTrack tTrack = runningdata.getNextTrackList().get(i);
+            createTaskObj(null, tTrack, saveMap);
+        }
+        runningdata.putMsgToConsole("[msg]actionForTask end.");
+        return saveMap;
+    }
+
+    // =================================================================================
+    /**
+     * 取消分支时调用
+     */
+    public void cancelTrackAction(String cancelTrackids, List<DBWorkAuth> auths) {
+        if (isNotSaveToDB) {
+            return;
+        }
+        makeSendInfoByCurAuthList(auths);
+    }
+
+    /**
+     * 当取消某个路径的激活状态时,对应的权限变化规则设定<br>
+     * (比如把待办的状态改为只读,或者是删除,或者忽略)<br>
+     * 如果不指定,则忽略权限变更(比如Reader不需要处理)<br>
+     * 主要用于合并节点提交时,如果有其他分支未到达时,对未到达的分支的参与者进行处理<br>
+     *
+     * @return key=修改前的权限名称(比如:办理人Author),value=修改后的权限名称(比如:只读权限CReader)
+     */
+    public Map<String, String> getCancelTrackAuthRuleMap() {
+        Map<String, String> map = new HashMap<String, String>();
+        if (!isNotSaveToDB) {
+            // 取消其他分支时,哪些权限需要变更,在map中设置即可
+            map.put(StaticVarExtend.AUTH_AUTHOR, StaticVarExtend.AUTH_CREADER);
+            map.put(StaticVarExtend.AUTH_SECOND_AUTHOR,
+                    StaticVarExtend.AUTH_CREADER);
+            map.put(StaticVarExtend.AUTH_START_HUIQIAN_AUTHOR,
+                    StaticVarExtend.AUTH_CREADER);
+            map.put(StaticVarExtend.AUTH_HUIQIAN_AUTHOR,
+                    StaticVarExtend.AUTH_CREADER);
+            map.put(StaticVarExtend.AUTH_SUBFLOW_AUTHOR,
+                    StaticVarExtend.AUTH_CREADER);
+        }
+        return map;
+    }
+
+    /**
+     * 当前节点权限处理(由操作再次干预参与者的接口)<br>
+     * auths列表中为系统节点默认处理完毕后的当前节点的参与者列表 对应的消息是否需要处理,可以在这个方法中写
+     */
+    public boolean chgCurNodeAuth(List<DBWorkAuth> auths) {
+        if (CollectionUtil.isListNotEmpty(auths)) {
+            makeSendInfoByCurAuthList(auths);
+        }
+        // 20160719 liys 从execute方法中移动此处,解决异步拿回后再次提交时,出现新的分支问题
+        runningdata.getCurTrack().setFlowstatus(
+                StaticVarExtend.FlowStatus_Normal);
+        return true;
+    }
+
+    /**
+     * 保存数据之前的接口方法.例如:消息数据的处理 key=sql,value=parameter
+     */
+    public Map<String, List<Object>> actionBeforeSaveToDB() {
+        Map<String, List<Object>> saveMap = new LinkedHashMap<String, List<Object>>();
+        if (!StaticFunExtend.getActionExtraData()
+                .doWithNextNodesExtraData(this)) {
+            return null;
+        }
+        if (subflowEnd != null) {
+            if (!subflowEnd.mainInstanceContinue(saveMap, getTaskLists())) {
+                return null;
+            }
+        }
+        // 20180312 liys 增加记录:当前节点的已办权限设置的表单信息
+        // 用于满足不同节点的主办提交后变成已办时能显示跟主办节点相关的表单信息
+        // 用于在打开实例时,如果是已办从这个记录中获取之前主办节点时的设置信息
+        if (HZResourceBundle.getInstance().isDoneAuthFormAuthorNode()) {
+            recodeDoneAuthForCurUserInCurNode(saveMap);
+        }
+
+        if (isSendTodo) {
+            sendTodo();
+        }
+        actionBefore(saveMap);
+
+        actionBeforeForSubFlow(saveMap);
+
+        return saveMap;
+    }
+
+    private void recodeDoneAuthForCurUserInCurNode(
+            Map<String, List<Object>> saveMap) {
+        if ("Start".equals(getCurNodeid())) {
+            return;
+        }
+        // 获取已办权限信息
+        IFlowNode curNodeXml = getCurFlowNode();
+        INodeControl doneControl = curNodeXml
+                .getParticipantsControl(StaticVarExtend.AUTH_DONE + "_DO");
+        if (doneControl == null) {
+            return;
+        }
+        List<INodeForm> doneForms = doneControl.getAllNodeForms();
+        boolean isHaveTrack = false;
+        boolean isAgent = StringUtilExtend.isNotNull(getCurUser().getAgentUser());
+        for (INodeForm form : doneForms) {
+            String formId = form.getFormid();
+            if ("FlowTrack".equals(formId)) {
+                isHaveTrack = true;
+                continue;
+            }
+
+            // 记录当前节点,当前人,权限
+            makeDone(form, saveMap, isAgent);
+        }
+        if (isHaveTrack) {
+            makeDone(null, saveMap, isAgent);
+        }
+    }
+
+    private void makeDone(INodeForm form, Map<String, List<Object>> saveMap,
+                          boolean isAgent) {
+        DBDone done = new DBDone();
+        done.setId(StaticFunExtend.getUnid());
+        done.setWorkid(getWorkid());
+        done.setNodeid(getCurNodeid());
+        done.setUserid(getCurUserid());
+        done.setFormid(form == null ? "FlowTrack" : form.getFormid());
+        done.setFormbutton(form == null ? "" : form.getFormButton());
+        done.setFieldauthid(form == null ? "" : form.getRealFormid());
+        done.getSQL(saveMap,runningdata.getResultJson());
+
+        if (isAgent) {
+            done.setId(StaticFunExtend.getUnid());
+            done.setUserid(getCurUser().getAgentUser());
+            done.getSQL(saveMap,runningdata.getResultJson());
+        }
+    }
+
+    /**
+     * 保存之后的接口方法.例如:消息数据的更新
+     */
+    public void actionAfterSaveToDB() {
+        if (isNotSaveToDB) {
+            return;
+        }
+        // 处理多人并行节点，没有离开节点的情况下，不触发“待办变已办”方法的问题;
+        // https://www.huizhengsoft.com/hznetwork/support/know/jump.html?pageId=HZ2881ea7b9f1fde017b9f4333b702c7&formDataId=HZ28831d934da6a4019370bdf42d331a
+        actionStartTodoThread();
+//         if (isSendTodo) {
+//             actionStartTodoThread();
+//         }
+        actionAfterForSubFlow();
+        // 发送定时任务
+        super.actionAfterSaveToDB();
+        //操作执行完毕后的事件执行
+        executeEventAfterToDB();
+    }
+
+    /**
+     * 发送待办(可继承重写)
+     */
+    protected void sendTodo() {
+        sendTodoForSelectedUsers();
+    }
+
+}

src/main/java/com/horizon/wf/core/rule/CotRule.java

@@ -0,0 +1,95 @@
+package com.horizon.wf.core.rule;
+
+import cn.hutool.http.HttpUtil;
+import com.horizon.common.constant.Constants;
+import com.horizon.wf.bean.WorkParaBean;
+import com.horizon.wf.core.runtime.RunningData;
+import com.horizon.wf.definition.pub.IFlowNode;
+import com.horizon.wf.entity.db.DBTrack;
+import com.horizon.wf.entity.db.DBWork;
+import com.horizon.wf.entity.user.IRunUser;
+import com.horizon.wf.global.StaticVarExtend;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 合同业务相关的事件触发器
+ * 用于更新合同状态
+ */
+public class CotRule extends BaseRuleImpl implements IBaseRule {
+
+    /**
+     * 具体的实现,参考下面方法中的说明,所有的实现都差不多结构,
+     * 只有自定义的异常处理接口实现中是没有传入 runningdata的.
+     * 不同的接口 仅仅是额外传入的参数有些差异,额外的参数多数都是可以从runningdata中获取的
+     * 系统为了方便接口的实现,额外传入了一些认为会用到的参数
+     * @return
+     */
+    @Override
+    public boolean executeRule() {
+        // 从引擎获取到核心数据对象(如果接口没有额外传入需要的数据时,可以从此对象中获取)
+        RunningData runningdata = getRunningdata();
+        //事件处理类额外传入参数
+        // 1.执行事件的节点对象
+        IFlowNode eventNode = (IFlowNode) getParameter(StaticVarExtend.Parameter_IFlowNode);
+
+        // 2.当前节点对象
+        IFlowNode curNode = (IFlowNode)getParameter(StaticVarExtend.Parameter_Current_IFlowNode);
+        // 3.引擎调用时,传入的参数对象
+        WorkParaBean paraBean = (WorkParaBean)getParameter(StaticVarExtend.Parameter_WorkParaBean);
+        Map<String, String> varMap = paraBean.getFlowVarMap();
+        String action = paraBean.getActionname();
+        // 4.当前实例对象
+        DBWork work = (DBWork)getParameter(StaticVarExtend.Parameter_DBWork);
+        // 5.当前执行人对象
+        IRunUser user = (IRunUser) getParameter(StaticVarExtend.Parameter_RunUser);
+        // 6.当前路径对象
+        DBTrack track = (DBTrack)getParameter(StaticVarExtend.Parameter_DBTrack);
+        int status = track.getFlowstatus();
+        String nodeId = track.getNodeid();
+        String statusName = track.getFunname();
+        String nodeName = track.getNodename();
+        // 7.需要保存的SQL数据如果需要引擎来保存,请放入此 map中(key=SQL,value=List为SQL中对应的参数)
+        Map<String, List<Object>> dataMap = (Map<String, List<Object>>) getParameter(StaticVarExtend.Parameter_SaveMap);
+        // 8.事件类型
+        String eventType = (String)getParameter("eventType");
+        // 9.事件实际执行内容
+        // 10.返回 true 表示执行成功,引擎从第7步中的dataMap里获取需要保存的数据,引擎继续往下执行,
+        // 返回 false表示执行失败, 引擎会根据事件类型,确定是否继续往下执行
+
+        System.err.println(
+                ",status:" + status +
+                ",nodeId:" + nodeId +
+                ",nodeName:" + nodeName +
+                ",statusName:" + statusName +
+                ",action:" + action +
+                ",eventNodeId:" + eventNode.getNodeid() +
+                ",eventNodeName:" + eventNode.getNodename());
+
+         if(eventNode.getNodeid().contains("End")){
+             status = 170;
+         }else if(eventNode.getNodeid().equals("Node1")){
+             if(statusName.equals("JumpReject") || statusName.equals("Reject")){
+                 status = 130;
+             }else if(statusName.equals("Getback")){
+                 status = 190;
+             }else if(statusName.equals("autofirst")){
+                 status = 110;
+             }
+        }else {
+             status = 110;
+         }
+        String url = Constants.WF_PRE_URL + "/cot/Head/horizonApprovalProcess";
+        // String url = Constants.WF_PRE_URL + "/framework/Schedule/horizonApprovalProcess";
+        String id = varMap.get("id");
+        Map<String, Object> params = new HashMap<>();
+        params.put("id", id);
+        params.put("processInstanceStatus", status);
+        String result = HttpUtil.post(url, params);
+        return true;
+    }
+}
+
+

src/main/java/com/horizon/wf/core/rule/ExampleRule.java

@@ -0,0 +1,340 @@
+package com.horizon.wf.core.rule;
+
+import com.horizon.wf.bean.WorkParaBean;
+import com.horizon.wf.core.runtime.RunningData;
+import com.horizon.wf.core.track.json.impl.ITrackJson;
+import com.horizon.wf.definition.pub.IFlowNode;
+import com.horizon.wf.definition.pub.node.INodeException;
+import com.horizon.wf.definition.pub.node.INodePara;
+import com.horizon.wf.definition.pub.node.INodeRouter;
+import com.horizon.wf.entity.db.DBTrack;
+import com.horizon.wf.entity.db.DBWork;
+import com.horizon.wf.entity.user.IRunUser;
+import com.horizon.wf.global.StaticVar;
+import com.horizon.wf.global.StaticVarExtend;
+import com.horizon.wf.tools.CStrUtil;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 接口实现类的说明示例
+ * 必须继承已有的类 com.horizon.wf.core.rule.BaseRuleImpl
+ */
+public class ExampleRule extends BaseRuleImpl implements IBaseRule {
+
+    /**
+     * 具体的实现,参考下面方法中的说明,所有的实现都差不多结构,
+     * 只有自定义的异常处理接口实现中是没有传入 runningdata的.
+     * 不同的接口 仅仅是额外传入的参数有些差异,额外的参数多数都是可以从runningdata中获取的
+     * 系统为了方便接口的实现,额外传入了一些认为会用到的参数
+     * @return
+     */
+    @Override
+    public boolean executeRule() {
+        // 从引擎获取到核心数据对象(如果接口没有额外传入需要的数据时,可以从此对象中获取)
+        RunningData runningdata = getRunningdata();
+        //事件处理类额外传入参数
+        // 1.执行事件的节点对象
+        IFlowNode eventNode = (IFlowNode) getParameter(StaticVarExtend.Parameter_IFlowNode);
+        // 2.当前节点对象
+        IFlowNode curNode = (IFlowNode)getParameter(StaticVarExtend.Parameter_Current_IFlowNode);
+        // 3.引擎调用时,传入的参数对象
+        WorkParaBean paraBean = (WorkParaBean)getParameter(StaticVarExtend.Parameter_WorkParaBean);
+        Map<String, String> varMap = paraBean.getFlowVarMap();
+        // 4.当前实例对象
+        DBWork work = (DBWork)getParameter(StaticVarExtend.Parameter_DBWork);
+        // 5.当前执行人对象
+        IRunUser user = (IRunUser) getParameter(StaticVarExtend.Parameter_RunUser);
+        // 6.当前路径对象
+        DBTrack track = (DBTrack)getParameter(StaticVarExtend.Parameter_DBTrack);
+        int status = track.getFlowstatus();
+        String nodeId = track.getNodeid();
+        String statusName = track.getFunname();
+        String nodeName = track.getNodename();
+        // 7.需要保存的SQL数据如果需要引擎来保存,请放入此 map中(key=SQL,value=List为SQL中对应的参数)
+        Map<String, List<Object>> dataMap = (Map<String, List<Object>>) getParameter(StaticVarExtend.Parameter_SaveMap);
+        // 8.事件类型
+        String eventType = (String)getParameter("eventType");
+        // 9.事件实际执行内容
+        // System.err.println("zcc");
+        // System.err.println(paraBean.toString());
+        // 10.返回 true 表示执行成功,引擎从第7步中的dataMap里获取需要保存的数据,引擎继续往下执行,
+        // 返回 false表示执行失败, 引擎会根据事件类型,确定是否继续往下执行
+        return true;
+    }
+
+    /**
+     * 内部循环节点
+     * 如果前台没有传入办理人,则判断是否有接口类
+     * @return
+     */
+    private boolean doProgressively(){
+        // 从引擎获取到核心数据对象(如果接口没有额外传入需要的数据时,可以从此对象中获取)
+        RunningData runningdata = getRunningdata();
+        DBWork work = (DBWork)getParameter(StaticVarExtend.Parameter_DBWork);// runningdata.getWork());
+        WorkParaBean paraBean =(WorkParaBean)getParameter(StaticVarExtend.Parameter_WorkParaBean);// 设置前后台对象到接口
+        IFlowNode curNode = (IFlowNode)getParameter(StaticVarExtend.Parameter_Current_IFlowNode);// 逐级审批节点
+        IRunUser user = (IRunUser) getParameter(StaticVarExtend.Parameter_RunUser);// 当前操作者
+        String userid = (String)getParameter(StaticVarExtend.Parameter_Progressive_Userid);// 提交到逐级审批节点的人员id
+
+        // 通过setResult("")方法把下一个办理人的id返回给引擎
+
+        // 返回ture,引擎从返回结果中获取办理人,false则忽略
+        return true;
+    }
+
+    /**
+     * 合并网关 合并处理
+     * @return
+     */
+    private boolean doGatewayMerger(){
+        // 从引擎获取到核心数据对象(如果接口没有额外传入需要的数据时,可以从此对象中获取)
+        RunningData runningdata = getRunningdata();
+
+        WorkParaBean paraBean = (WorkParaBean)getParameter(StaticVarExtend.Parameter_WorkParaBean);
+        IFlowNode curNode = (IFlowNode)getParameter(StaticVarExtend.Parameter_GateWay_IFlowNode);// 当前节点
+        // 所有需要到达合并网关的分支列表
+        List<ITrackJson> lstTrack = (List<ITrackJson>) getParameter(StaticVarExtend.Parameter_GateWay_Alltracks);// 设置所有分支路径信息到接口rd.getAllTrackNeedToGateway(this)
+        DBTrack track = (DBTrack)getParameter(StaticVarExtend.Parameter_DBTrack);// rd.getCurTrack());
+        DBWork work = (DBWork)getParameter(StaticVarExtend.Parameter_DBWork);// rd.getWork());
+        IRunUser user = (IRunUser)getParameter(StaticVarExtend.Parameter_RunUser);// rd.getCurUser());
+
+        // 如果有需要撤销的分支,请使用setResult("")方法把需要撤销的分支路径id返回给引擎
+
+        // 返回是否允许离开 true 允许离开 false 不允许离开
+        return true;
+    }
+
+    /**
+     * 多人并行节点离开规则中的自定义
+     * 调用入口 com.horizon.wf.expand.node.NodeMultiImpl#doNormal
+     * @return
+     */
+    private boolean doNodeMultilLeave(){
+        // 从引擎获取到核心数据对象(如果接口没有额外传入需要的数据时,可以从此对象中获取)
+        RunningData runningdata = getRunningdata();
+
+        WorkParaBean paraBean = (WorkParaBean)getParameter(StaticVarExtend.Parameter_WorkParaBean);
+        IFlowNode curNode = (IFlowNode)getParameter(StaticVarExtend.Parameter_Current_IFlowNode);// 当前节点
+
+        // 返回是否允许离开 true 允许离开 false 不允许离开
+        return true;
+    }
+
+    /**
+     * 合并节点激活方式中的定义实现
+     *
+     * @return
+     */
+    private boolean doMergerEntryType(){
+        // 从引擎获取到核心数据对象(如果接口没有额外传入需要的数据时,可以从此对象中获取)
+        RunningData runningdata = getRunningdata();
+
+        WorkParaBean paraBean = (WorkParaBean)getParameter(StaticVarExtend.Parameter_WorkParaBean);
+        IFlowNode curNode = (IFlowNode)getParameter(StaticVarExtend.Parameter_Current_IFlowNode);// 当前节点
+        IFlowNode mergerNode = (IFlowNode)getParameter(StaticVarExtend.Parameter_Merger_IFlowNode);// 进入的节点
+
+        int allTrackNum = (Integer)getParameter("AllTrackNum"); // 所有需要到达的分支数
+        int reachedNum = (Integer)getParameter("ReachedTrackNum"); // 已经到达的分支数
+
+
+        // 返回是否允许离开 true 允许离开 false 不允许离开
+        return true;
+    }
+    /**
+     * 合并节点的离开方式中的自定义实现
+     * 调用入口 com.horizon.wf.expand.node.NodeMergerImpl#checkMergerNodeLeaveRule
+     * @return
+     */
+    private boolean doMergerLeaveType(){
+        // 从引擎获取到核心数据对象(如果接口没有额外传入需要的数据时,可以从此对象中获取)
+        RunningData runningdata = getRunningdata();
+
+        WorkParaBean paraBean = (WorkParaBean)getParameter(StaticVarExtend.Parameter_WorkParaBean);
+        IFlowNode curNode = (IFlowNode)getParameter(StaticVarExtend.Parameter_Current_IFlowNode); // 当前节点
+        IFlowNode mergerNode = (IFlowNode)getParameter(StaticVarExtend.Parameter_Merger_IFlowNode);
+
+
+        // 返回是否允许离开 true 允许离开 false 不允许离开
+        return true;
+    }
+
+
+    /**
+     * 异常处理接口实现示范代码
+     * 调用入口 com.horizon.wf.action.common.ActionCommon#dealException
+     * @return
+     */
+    private boolean doException(){
+        // 1.引擎调用时,传入的参数对象
+        WorkParaBean paraBean = (WorkParaBean) getParameter(StaticVarExtend.Parameter_WorkParaBean);
+        // 2.当前实例对象
+        DBWork work = (DBWork) getParameter(StaticVarExtend.Parameter_DBWork);
+        // 3.当前路径对象
+        DBTrack track = (DBTrack) getParameter(StaticVarExtend.Parameter_DBTrack);
+        // 4.当前异常定义对象
+        INodeException e = (INodeException) getParameter(StaticVarExtend.Parameter_Exception_INodeException);
+
+        // 5.异常处理内容
+
+        // 返回true,异常执行结束,
+        // 如果返回 false,可以使用setResult指定一个系统默认处理的方式: setResult("2"); 也可以不设置跟返回true一样
+        // 2 = 跳转 ,3= 挂起,4=终止,其他值系统忽略处理
+        return true;
+    }
+
+    /**
+     * 节点进入的扩展实现示例代码(只有在其少数情况下才会用到)
+     * 调用入口 com.horizon.wf.rule.defa.core.EntryRuleDefault#actionInterface
+     * @return
+     */
+    private boolean doNodeEntry(){
+        // 从引擎获取到核心数据对象(如果接口没有额外传入需要的数据时,可以从此对象中获取)
+        RunningData runningdata = getRunningdata();
+        // 要进入的节点对象
+        IFlowNode entryNode = (IFlowNode) getParameter(StaticVar.Para_EntryRules_IXmlNode);
+        // 指向要进入的节点的路由
+        INodeRouter fromRouter =(INodeRouter) getParameter(StaticVar.Para_EntryRules_IXmlRouter);
+        // 节点进入的方式,1按路由方向进入,2=退回的方式进入,3=跳转的方式进入
+        int leaveType = (Integer)getParameter(StaticVar.Para_EntryRules_LeaveType);
+        // 退回时使用的参数,一般是要退回的节点原来所在的路径id
+        String oldTrackid =(String)getParameter(StaticVar.Para_EntryRules_OldTrackidForReject);
+
+        //需要执行的代码
+
+        // 返回true 表示节点允许进入,false表示不允许进入
+        return true;
+    }
+    /**
+     * 节点离开的扩展实现示例代码(只有在其少数情况下才会用到)
+     * 调用入口 com.horizon.wf.rule.defa.core.LeaveRuleDefault
+     * @return
+     */
+    private boolean doNodeLeave(){
+        // 从引擎获取到核心数据对象(如果接口没有额外传入需要的数据时,可以从此对象中获取)
+        RunningData runningdata = getRunningdata();
+        // 当前节点对象(离开只有当前节点才会有)
+        IFlowNode curNode = (IFlowNode) getParameter(StaticVar.Para_LeaveRules_IXmlNode);
+
+        // 需要执行的代码
+        // 比如要实现在节点离开时想要对节点参数进行修改的功能如下:
+        List<INodePara> paraList = runningdata.getCurFlowNode().getAllNodePara();
+        INodePara para = paraList.get(0);
+
+        String initValue = para.getInitialValue();
+        // 获取当前节点参数的数据
+        String oldValue = runningdata.getThisNodeParaValue(para.getParaId());
+        int tmp = 0;
+        if(CStrUtil.isNull(oldValue)){
+            tmp = Integer.parseInt(initValue);
+        }
+        else{
+            tmp = Integer.parseInt(oldValue);
+        }
+        tmp += 1;
+        // 给当前节点参数赋值
+        runningdata.setThisNodeParaValue(para.getParaId(),""+tmp);
+        // -----上面的代码,仅供参考----------
+
+        // 返回true 表示节点允许离开,false表示不允许离开
+        return true;
+    }
+
+    /**
+     * 节点事件处理实现类的示范代码
+     * 调用入口 com.horizon.wf.rule.event.EventUtil#excuteEvents
+     * @return
+     */
+    private boolean doNodeEvent(){
+        // 从引擎获取到核心数据对象(如果接口没有额外传入需要的数据时,可以从此对象中获取)
+        RunningData runningdata = getRunningdata();
+        //事件处理类额外传入参数
+        // 1.执行事件的节点对象
+        IFlowNode eventNode = (IFlowNode) getParameter(StaticVarExtend.Parameter_IFlowNode);
+        // 2.当前节点对象
+        IFlowNode curNode = (IFlowNode)getParameter(StaticVarExtend.Parameter_Current_IFlowNode);
+        // 3.引擎调用时,传入的参数对象
+        WorkParaBean paraBean = (WorkParaBean)getParameter(StaticVarExtend.Parameter_WorkParaBean);
+        // 4.当前实例对象
+        DBWork work = (DBWork)getParameter(StaticVarExtend.Parameter_DBWork);
+        // 5.当前执行人对象
+        IRunUser user = (IRunUser) getParameter(StaticVarExtend.Parameter_RunUser);
+        // 6.当前路径对象
+        DBTrack track = (DBTrack)getParameter(StaticVarExtend.Parameter_DBTrack);
+        // 7.需要保存的SQL数据如果需要引擎来保存,请放入此 map中(key=SQL,value=List为SQL中对应的参数)
+        Map<String, List<Object>> dataMap = (Map<String, List<Object>>) getParameter(StaticVarExtend.Parameter_SaveMap);
+        // 8.事件类型
+        String eventType = (String)getParameter("eventType");
+        // 9.事件实际执行内容
+
+        // 10.返回 true 表示执行成功,引擎从第7步中的dataMap里获取需要保存的数据,引擎继续往下执行,
+        // 返回 false表示执行失败, 引擎会根据事件类型,确定是否继续往下执行
+        return true;
+    }
+
+    /**
+     * 事件节点的进入扩展类
+     * @return
+     */
+    private boolean doEventNodeEntry(){
+        // 从引擎获取到核心数据对象(如果接口没有额外传入需要的数据时,可以从此对象中获取)
+        RunningData runningdata = getRunningdata();
+
+        WorkParaBean paraBean = (WorkParaBean)getParameter(StaticVarExtend.Parameter_WorkParaBean);// 设置前后台对象到接口
+        DBWork work = (DBWork) getParameter(StaticVarExtend.Parameter_DBWork);
+        IRunUser user = (IRunUser)getParameter(StaticVarExtend.Parameter_RunUser);
+        DBTrack track = (DBTrack)getParameter(StaticVarExtend.Parameter_DBTrack);
+        // 如果需要引擎保存数据,则放入savemap中,引擎会从中获取到
+        Map<String, List<Object>> saveMap = (Map<String,List<Object>>)getParameter(StaticVarExtend.Parameter_SaveMap);
+
+        // 返回true,允许事件节点进入,false 不允许
+        return true;
+    }
+
+    /**
+     * 自定义接口实现 获取办理人的示范代码
+     * 调用入口 com.horizon.wf.rule.defa.core.EntryRuleDefault#getUserFromCustom
+     * @return
+     */
+    private boolean doCustomUser(){
+        // 从引擎获取到核心数据对象(如果接口没有额外传入需要的数据时,可以从此对象中获取)
+        RunningData runningdata = getRunningdata();
+        // 下面参数为获取办理人时,额外传入的对象
+        // 1.引擎调用时,传入的参数对象
+        WorkParaBean paraBean = (WorkParaBean)getParameter(StaticVarExtend.Parameter_WorkParaBean);
+        // 2.流程定义中用来获取自定义办理人时设置的数据
+        String customer = (String)getParameter(StaticVarExtend.Parameter_CustomeUser_Para);
+        // 3.获取办理人的节点定义对象
+        IFlowNode flowNode = (IFlowNode) getParameter(StaticVarExtend.Parameter_CustomeUser_IFlowNode);
+        // 4.获取到的办理人ID
+        String userId = "";
+        // 5.获取的办理人返回
+        setResult(userId);
+        // 6.返回
+        // true表示获取成功,引擎会从 第5步设置的返回值中获取结果  false,引擎忽略获取结果
+        return true;
+    }
+
+
+    /**
+     * 路由条件判断接口实现的示范代码
+     * @return
+     */
+    private boolean doRouter(){
+        // 从引擎获取到核心数据对象(如果接口没有额外传入需要的数据时,可以从此对象中获取)
+        RunningData runningdata = getRunningdata();
+        // 下面两个参数是此接口类被调用时,引擎额外传入的对象供以当前接口实现类使用
+        // 1.获取路由定义对象 ,通过router可以获取到在流程定义中定义的数据
+        INodeRouter router = (INodeRouter)getParameter(StaticVarExtend.Para_RouterRules_Router);
+        // 2.获取引擎执行时路由判断时的默认结果 ture or false( true表示此路由可以通过,false表示不能通过)
+        boolean isPass = (Boolean) getParameter(StaticVarExtend.Para_RouterRules_IsPass);
+        // 3.自行处理判断内容
+
+        // 4. 最终返回 此路由是否允许通过
+        // true 允许通过  flase 不允许通过
+        return true;
+    }
+}
+
+

src/main/java/com/horizon/wf/third/hz/todo/TodoImpl.java

@@ -0,0 +1,65 @@
+package com.horizon.wf.third.hz.todo;
+
+import java.util.Map;
+
+import com.horizon.wf.expand.impl.ITodoInterface;
+
+/**
+ * 作者:李勇 创建日期:2008-09-19 跟待办相关的实现类
+ * workflow-pub.xml
+ * @author Administrator
+ * 
+ */
+@SuppressWarnings({"rawtypes"})
+public class TodoImpl implements ITodoInterface {
+	public void setTenantid(String tenantid){
+		
+	}
+	/**
+	 * 发送邮件,未实现
+	 */
+	public boolean sendMail(Map lhm){
+		return true;
+//		return MailUtil.sendMail(lhm, "0");
+	}
+	
+	/**
+	 * 发送系统提醒消息,未实现
+	 * @param lhm
+	 * @return
+	 */
+	public boolean sendMsg(Map lhm){
+		return true;
+//		return AlertUtil.saveAlert(lhm);
+	}
+	
+	/**
+	 * 发送短信,未实现
+	 * @param lhm
+	 * @return
+	 */
+	public boolean sendNode(Map lhm){
+//		System.out.println("短信发送");
+		return true;
+	}
+	
+	/**
+	 * 发送RTF,未实现
+	 * @param lhm
+	 * @return
+	 */
+	public boolean sendRTF(Map lhm){
+		return true;
+	}
+	
+	/**
+	 * 发送其他消息,未实现
+	 * @param lhm
+	 * @return
+	 */
+	public boolean sendOther(Map lhm){
+		return true;
+	}
+
+	
+}

src/main/java/com/horizon/wf/util/PushWorkflowToPortal.java

@@ -0,0 +1,251 @@
+package com.horizon.wf.util;
+
+import cn.hutool.http.HttpRequest;
+import cn.hutool.http.HttpResponse;
+import cn.hutool.http.HttpUtil;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.horizon.cache.api.HCacheClient;
+import com.horizon.common.collect.Lists;
+import com.horizon.common.collect.Maps;
+import com.horizon.common.constant.Constants;
+import com.horizon.core.HorizonCore;
+import com.horizon.db.Access;
+import com.horizon.third.adapter.OrganizationAdapter;
+import com.horizon.wf.bean.WorkParaBean;
+
+import java.sql.SQLOutput;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
+public class PushWorkflowToPortal {
+
+    private static String cacheGroup = "SendMsgToHall";
+    /**
+     * 如果需要往第三方数据写入待办相关数据
+     * tmpJson JSON格式的数组
+     *
+     * SqlType=INSERT时
+     * InsertFields = 已经拼好的要插入的字段,字符串
+     * InsertPara = 插入时对应的值,数组
+     *
+     * SqlType=UPDATE或者DELETE时
+     * WhereCondition = 已经拼好的查询条件字段,字符串
+     * WhereFields = 查询条件字段列表,数组
+     * WherePara = 查询条件对应的参数值,数组
+     *
+     * SqlType=UPDATE时
+     * SetStr = 已经拼好的需要更新的字段,字符串
+     * SetFields = 更新字段列表,数组
+     * SetPara = 更新字段对应的参数值,数组
+     */
+    public static void sendTodoData(String type, JSONArray tmpJson, WorkParaBean paraBean, String workid) {
+        if(type.equals("dataToSend")){
+            //待办、待阅数据
+            Map<String, Map<String, String>> insertSaveMap = Maps.newHashMap();
+            //待办变已办、待阅变已阅、待办变可阅数据
+            Map<String, Map<String, String>> updateSaveMap = Maps.newHashMap();
+            sendTodoData(tmpJson, paraBean, insertSaveMap, updateSaveMap, workid);
+            // System.out.println("+=============================");
+            //在这里调用门户的接口
+            if(!insertSaveMap.isEmpty()){
+                // select creator from tw_hz_instance where id = 'workid'
+                // HorizonCore.USER_ID.value()
+                String creator = "";
+                if(workid != null && !workid.isEmpty()){
+                    String sql = "select creator from tw_hz_instance where id = ?";
+                    List<String> list = Lists.newArrayList();
+                    list.add(workid);
+                    //单条数据查询
+                    //返回第一条数据，list
+                    //返回第一条数据，map，key=小写字段名，value=值
+                    Map resmap = Access.getSingleMap(sql, list);
+                    // System.err.println(resmap);
+                    creator = (String) resmap.get("creator");
+                }else{
+                    creator = HorizonCore.USER_ID.value();
+                }
+
+                for(Map.Entry<String, Map<String, String>> entry : insertSaveMap.entrySet()){
+                    String scheduleId = entry.getKey();
+                    Map<String, String> value = entry.getValue();
+
+                    String subjectionId = value.get("subjectionId");
+                    String workId = value.get("workId");
+                    String trackId = value.get("trackId");
+                    String flowId = value.get("flowId");
+                    String nodeId = value.get("nodeId");
+                    String flowName = value.get("flowName");
+
+                    String title = value.get("title");
+
+                    String startTime = value.get("sendTime");
+                    String nextUserId = value.get("authId");
+
+                    // String businessParam = value.get("title");
+
+                    JSONObject jsonObject = new JSONObject();
+                    jsonObject.put("scheduleId", scheduleId);
+                    jsonObject.put("title", title);
+                    jsonObject.put("startUserId", creator);
+                    jsonObject.put("startTime", startTime);
+                    jsonObject.put("nextUserId", nextUserId);
+                    jsonObject.put("toWebPath", "/workflow/detail");
+
+                    JSONObject businessParam = new JSONObject();
+                    businessParam.put("flowId", flowId);
+                    businessParam.put("flowName", flowName);
+                    businessParam.put("workId", workId);
+                    businessParam.put("trackId", trackId);
+                    businessParam.put("subjectionId", subjectionId);
+                    businessParam.put("nodeId", nodeId);
+                    businessParam.put("type", "3");
+                    jsonObject.put("businessParam", businessParam.toJSONString());
+
+                    String url = Constants.WF_PRE_URL + "/framework/Schedule/horizonAdd";
+                    Map<String, Object> params = new HashMap<>();
+                    params.put("json", jsonObject.toJSONString());
+
+                    String result = HttpUtil.post(url, params);
+                    // System.out.println("INSERT: "+result);
+                }
+            }
+            if(!updateSaveMap.isEmpty()){
+                // System.err.println(updateSaveMap);
+                for(Map.Entry<String, Map<String, String>> entry : updateSaveMap.entrySet()){
+                    String scheduleId = entry.getKey();
+                    Map<String, String> value = entry.getValue();
+                    String url = Constants.WF_PRE_URL + "/framework/Schedule/horizonUpdateDealFlag";
+                    Map<String, Object> params = new HashMap<>();
+                    params.put("scheduleId", scheduleId);
+
+                    String result = HttpUtil.post(url, params);
+                    // System.out.println("UPDATE: "+result);
+                }
+            }
+        }
+    }
+
+    private static void sendTodoData(JSONArray dataToSend, WorkParaBean paraBean,
+                                     Map<String, Map<String, String>> insertSaveMap, Map<String, Map<String, String>> updateSaveMap, String workid){
+        OrganizationAdapter organizationAdapter = new OrganizationAdapter();
+        if(dataToSend == null || dataToSend.size() <= 0){
+            return;
+        }
+
+        //2022-06-29 新增
+        //判断是不是创建流程,如果只有一条，并且是insert，则表示是创建流程
+        if(dataToSend.size()==1 && "INSERT".equals(dataToSend.getJSONObject(0).getString("SqlType"))) {
+            //将流程的实例信息放到session中
+            HCacheClient.put(cacheGroup,"TODO"+workid,dataToSend.getJSONObject(0), 0L);
+            return;
+        }
+
+        //2022-06-29 end
+        for(int i = 0; i < dataToSend.size(); i++){
+            JSONObject currentItem = dataToSend.getJSONObject(i);
+
+            //2022-06-29 新增 如果是更新，在缓存中查找是否有workid，有的就是新流程暂存，加入insert
+            if(currentItem.getString("SqlType").equals("UPDATE")){
+                JSONObject cacheTodo = HCacheClient.get(cacheGroup,"TODO"+paraBean.getWorkId());
+                if(cacheTodo!=null && cacheTodo.size()>0){
+                    currentItem = cacheTodo;
+                    HCacheClient.remove(cacheGroup,"TODO"+paraBean.getWorkId());
+                }
+            }
+            //2022-06-29 end
+            String sqlType = currentItem.getString("SqlType");
+            String flag = currentItem.getString("FLAG");
+            if(sqlType.equals("INSERT")){ //待办
+                String[] insertFields = currentItem.getString("InsertFields").split(",");
+                if(insertFields.length == 0){
+                    continue;
+                }
+                JSONArray insertParas = currentItem.getJSONArray("InsertPara");
+                Map<String,String> insertTodo = Maps.newHashMap();
+                for(int index = 0; index < insertFields.length; index++){
+                    insertTodo.put(insertFields[index], insertParas.getString(index));
+                }
+                String status = insertTodo.get("STATUS"); //Author主办
+                String statusNo = insertTodo.get("STATUS_NO"); //Author主办
+                String authId = insertTodo.get("AUTH_ID"); //办理人id
+                // String agentId = insertTodo.get("AGENT_ID"); //代办人id
+                Map<String, String> author = organizationAdapter.getUserById(authId, paraBean.getFlowIdentifier());
+                String authName = author.get("name"); //办理人姓名
+                String authLoginName = author.get("login_name"); //办理人账号
+                // Map<String, String> agentor = organizationAdapter.getUserById(agentId, paraBean.getFlowIdentifier());
+                // String agentName = agentor.get("name"); //代办人姓名
+                // String agentLoginName = agentor.get("login_name"); //代办人账号
+                String workId = insertTodo.get("WORKID");
+                String trackId = insertTodo.get("TRACKID");
+                String flowId = insertTodo.get("FLOWID");
+                String flowName = insertTodo.get("FLOWNAME");
+                String nodeId = insertTodo.get("NODEID");
+                String title = insertTodo.get("TITLE");
+                String sendTime = insertTodo.get("SENDTIME"); //sendtime
+                String subjectionType = insertTodo.get("SUBJECTION_TYPE"); //办理人所属组织type D部门 G群组 P岗位
+                String subjectionId = insertTodo.get("SUBJECTION_ID"); //办理人所属组织id
+                String id = insertTodo.get("ID"); //待办数据的唯一标识
+                Map<String, String> map = insertSaveMap.get(id);
+                if(null==map || map.isEmpty()){
+                    map = Maps.newHashMap();
+                    map.put("flowId", flowId);
+                    map.put("workId", workId);
+                    map.put("trackId", trackId);
+                    map.put("title", title);
+                    map.put("flowName", flowName);
+                    map.put("nodeId", nodeId);
+                }
+                map.put("authId", authId);
+                map.put("authName", authName);
+                map.put("authLoginName", authLoginName);
+                // map.put("agentId", agentId);
+                // map.put("agentName", agentName);
+                // map.put("agentLoginName", agentLoginName);
+                map.put("sendTime", sendTime);
+                map.put("subjectionType", subjectionType);
+                map.put("subjectionId", subjectionId);
+                map.put("status", status);
+                map.put("statusNo", statusNo);
+                map.put("id", id);
+                insertSaveMap.put(id, map);
+
+            } else if(sqlType.equals("UPDATE")&&flag.equals("DONE")){ //待办变已办
+                JSONArray todoIds = currentItem.getJSONArray("WherePara");
+                String workId = paraBean.getWorkId(); //workid
+                String[] setFields = currentItem.getString("SetFields").substring(1, currentItem.getString("SetFields").length()-1).split(",");
+                if(setFields.length == 0){
+                    continue;
+                }
+                JSONArray setParas = currentItem.getJSONArray("SetPara");
+                Map<String,String> updateTodo = Maps.newHashMap();
+                for(int index = 0; index < setFields.length; index++){
+                    updateTodo.put(setFields[index].trim(), setParas.getString(index));
+                }
+                String dotime = updateTodo.get("dotime"); //办理时间
+                String status = updateTodo.get("status"); //状态
+                String statusNo = updateTodo.get("statusNo"); //状态编号
+                String title = updateTodo.get("title"); //title
+                String id = todoIds.getString(0);
+                Map<String, String> map = updateSaveMap.get(id);
+                if(null==map || map.isEmpty()){
+                    map = Maps.newHashMap();
+                    map.put("dotime", dotime);
+                    map.put("statusNo", statusNo);
+                    map.put("status", status);
+                    map.put("workId", workId);
+                    map.put("title", title);
+                } else {
+                    map.put("dotime", dotime);
+                    map.put("statusNo", statusNo);
+                    map.put("status", status);
+                }
+                map.put("id", id);
+                updateSaveMap.put(id, map);
+            }
+        }
+    }
+}
+

src/main/resources/workflow-conf/workflow-web.xml

@@ -10,7 +10,7 @@
 
     <context:property-placeholder ignore-unresolvable="true" location="classpath:workflow-conf/properties/horizon.properties" />
     <!-- 开启spring注解支持 需要配置 -->
-    <context:component-scan base-package="com.horizon.**.org,com.horizon.**.web" use-default-filters="false">
+    <context:component-scan base-package="com.horizon.**.web" use-default-filters="false">
         <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
     </context:component-scan>
     <mvc:default-servlet-handler/>