## 创建

**服务描述**
<table>
    <tr>
        <td>方法名称</td>
        <td>create</td>
        <td>中文名称</td>
        <td>创建流程实例对象</td>
    </tr>
    <tr>
        <td>功能描述</td>
        <td colspan="3">此服务用于创建流程实例对象</td>
    </tr>
    <tr>
        <td colspan="4" align="center">接口信息</td>
    </tr>
    <tr>
        <td>接口类型</td>
        <td>api</td>
        <td>交互频度</td>
        <td>非周期</td>
    </tr>
    <tr>
        <td>接口协议</td>
        <td>直接方法调用</td>
        <td>响应时间</td>
        <td></td>
    </tr>
   <tr>
        <td>备注</td>
        <td colspan="3">IWorkResult create(WorkParaBean workParaBean)</td>
    </tr>
</table>
**参数说明**

| 参数名称             | 类型      | 是否必填 | 描述                                      |
|------------------|---------|------|-----------------------------------------|
| flowId           | String  | √    | 流程id                                    |
| userId           | String  | √    | 当前操作人id                                 |
| tenantCode       | String  | √    | 当前租户id                                  |
| userName         | String  | 非必填  | 当前操作人名称                                 |
| deptName         | String  | 非必填  | 当前操作人所属部门名称                             |
| dataIdentifier   | String  | √    | 业务数据的数据源                                |
| flowIdentifier   | String  | √    | 流程数据的数据源                                |
| doNotToFirstNode | boolean | 非必填  | 是否不自动提交到第一个节点，默认是提交到第一个节点。false：提交到下一节点 |
**调用示例**
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
inparam.setUserId("xxx");							//当前操作人id
inparam.setUserName("xxx");						//当前操作人名称
inparam.setDeptName("xxx");						//部门名称
inparam.setFlowIdentifier("xxx");		//流程数据的数据源
inparam.setDataIdentifier("xxx");			//业务数据的数据源
inparam.setFlowId("xxx");            //流程定义的流程ID值
IWorkResult result = opr.create(inparam);	    //创建实例
```
## 打开
**服务描述**
<table>
    <tr>
        <td>方法名称</td>
        <td>open</td>
        <td>中文名称</td>
        <td>打开流程实例</td>
    </tr>
    <tr>
        <td>功能描述</td>
        <td colspan="3">此服务用于打开流程实例</td>
    </tr>
    <tr>
        <td colspan="4" align="center">接口信息</td>
    </tr>
    <tr>
        <td>接口类型</td>
        <td>api</td>
        <td>交互频度</td>
        <td>非周期</td>
    </tr>
    <tr>
        <td>接口协议</td>
        <td>直接方法调用</td>
        <td>响应时间</td>
        <td></td>
    </tr>
    <tr>
        <td>备注</td>
        <td colspan="3">IWorkResult open(WorkParaBean workParaBean)</td>
    </tr>
</table>
**参数说明**

| 参数名称                           | 类型     | 是否必填 | 描述                          |
|--------------------------------|--------|------|-----------------------------|
| workId                         | String | √    | 实例id                        |
| trackId                        | String | √    | 路径id                        |
| userId                         | String | √    | 当前操作人id                     |
| tenantCode                     | String | √    | 当前租户id                      |
| userName                       | String | 非必填  | 当前操作人名称                     |
| deptName                       | String | 非必填  | 部门名称                        |
| dataIdentifier                 | String | √    | 业务数据的数据源                    |
| flowIdentifier                 | String | √    | 流程数据的数据源                    |
| bussinessClassForOpenByService | String | 非必填  | 设置在service中打开实例时,获取业务数据的实现类 |
**调用示例**
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
inparam.setUserId("xxx");							//当前操作人id
inparam.setUserName("xxx");						//当前操作人名称
inparam.setDeptName("xxx");						//部门名称
inparam.setFlowIdentifier("xxx");			//流程数据的数据源
inparam.setDataIdentifier("xxx");			//业务数据的数据源
inparam.setWorkId("xxxx");           //实例ID
inparam.setTrackId("xxx");            //路径ID
IWorkResult result = opr.open(inparam); //打开实例 
```
## 关闭
**服务描述**
<table>
    <tr>
        <td>方法名称</td>
        <td>close</td>
        <td>中文名称</td>
        <td>关闭流程实例</td>
    </tr>
    <tr>
        <td>功能描述</td>
        <td colspan="3">此服务用于打开流程实例</td>
    </tr>
    <tr>
        <td colspan="4" align="center">接口信息</td>
    </tr>
    <tr>
        <td>接口类型</td>
        <td>api</td>
        <td>交互频度</td>
        <td>非周期</td>
    </tr>
    <tr>
        <td>接口协议</td>
        <td>直接方法调用</td>
        <td>响应时间</td>
        <td></td>
    </tr>
    <tr>
        <td>备注</td>
        <td colspan="3">void close(String workid,String trackid,String userid)</td>
    </tr>
</table>
**参数说明**

| 参数名称    | 类型     | 是否必填 | 描述      |
|---------|--------|------|---------|
| workId  | String | √    | 实例id    |
| trackId | String | √    | 路径id    |
| userId  | String | √    | 当前操作人id |
**调用示例**
```
IWorkflowOperator opr = new WorkflowOperator();	//流程操作对象
opr.close("workid","trackid","userid");
```
## 获取历史记录
**服务描述**
<table>
    <tr>
        <td>方法名称</td>
        <td>getHistory</td>
        <td>中文名称</td>
        <td>获取历史记录</td>
    </tr>
    <tr>
        <td>功能描述</td>
        <td colspan="3">此服务用于获取实例历史记录</td>
    </tr>
    <tr>
        <td colspan="4" align="center">接口信息</td>
    </tr>
    <tr>
        <td>接口类型</td>
        <td>api</td>
        <td>交互频度</td>
        <td>非周期</td>
    </tr>
    <tr>
        <td>接口协议</td>
        <td>直接方法调用</td>
        <td>响应时间</td>
        <td></td>
    </tr>
    <tr>
        <td>备注</td>
        <td colspan="3">List&lt;DBLog&gt; getHistory(String workid, String identifier)</td>
    </tr>
</table>
**参数说明**

| 参数名称       | 类型     | 是否必填 | 描述    |
|------------|--------|------|-------|
| workid     | String | √    | 实例id  |
| identifier | String | √    | 数据库标识 |
**调用示例**
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
List<DBLog> logList = opr.getHistory("workid","identifier");
```
## 通用操作说明
>通用操作具体包含的实例操作有：启动流程，提交，增加协办、协办提交，内部提交，会签提交，会签，退回，任意退回，退回提交，拿回，暂存，撤办，跳转，前加签、加签，减签，补发，分支补发，转办，认领，暂停，替换处理人，终止，阅知，已阅，催办，启动子流程。

下表是用来说明提交，暂存等操作参数设置说明。必填项用“■”表示，非必填项用“▲”表示，参数无效用“●”表示。其中非必填项有些是在特定条件下非必填。

**参考参数和方法说明列表**

| 参数名称                       | 启动流程 | 提交  | 增加协办 | 协办提交 | 内部提交 | 自由提交 | 会签  | 会签提交 | 退回  | 任意退回 | 退回提交 | 内部退回 | 拿回  | 暂存  | 撤办  | 跳转  | 前 加签 | 加签  | 减签  | 补发  | 分支补发 | 转办  | 认领  | 暂停  | 替换办理人 | 终止  | 阅知  | 已阅  | 催办  | 启动子流程 |
|----------------------------|------|-----|------|------|------|------|-----|------|-----|------|------|------|-----|-----|-----|-----|------|-----|-----|-----|------|-----|-----|-----|-------|-----|-----|-----|-----|-------|
| flowId                     | ■    | ●   | ●    | ●    | ●    | ●    | ●   | ●    | ●   | ●    | ●    | ●    | ●   | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●     | ●   | ●   | ●   | ●   | ●     |
| workId                     | ●    | ■   | ■    | ■    | ■    | ■    | ■   | ■    | ■   | ■    | ■    | ■    | ■   | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■     | ■   | ■   | ■   | ■   | ■     |
| trackId                    | ●    | ■   | ■    | ■    | ■    | ■    | ■   | ■    | ■   | ■    | ■    | ■    | ■   | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■     | ■   | ■   | ■   | ■   | ■     |
| userId                     | ■    | ■   | ■    | ■    | ■    | ■    | ■   | ■    | ■   | ■    | ■    | ■    | ■   | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■     | ■   | ■   | ■   | ■   | ■     |
| tenantCode                 | ■    | ■   | ■    | ■    | ■    | ■    | ■   | ■    | ■   | ■    | ■    | ■    | ■   | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■     | ■   | ■   | ■   | ■   | ■     |
| userName                   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲    | ▲   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲   | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲     | ▲   | ▲   | ▲   | ▲   | ▲     |
| deptName                   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲    | ▲   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲   | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲     | ▲   | ▲   | ▲   | ▲   | ▲     |
| funname                    | ■    | ■   | ■    | ■    | ■    | ■    | ■   | ■    | ■   | ■    | ■    | ■    | ■   | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■     | ■   | ■   | ■   | ■   | ■     |
| actionname                 | ■    | ■   | ■    | ■    | ■    | ■    | ■   | ■    | ■   | ■    | ■    | ■    | ■   | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■     | ■   | ■   | ■   | ■   | ■     |
| actionClass                | ■    | ■   | ■    | ■    | ■    | ■    | ■   | ■    | ■   | ■    | ■    | ■    | ■   | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■     | ■   | ■   | ■   | ■   | ■     |
| bussinessClass             | ▲    | ▲   | ▲    | ▲    | ▲    | ▲    | ▲   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲   | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲     | ▲   | ▲   | ▲   | ▲   | ▲     |
| nodeId                     | ●    | ■   | ■    | ■    | ■    | ■    | ■   | ■    | ■   | ■    | ■    | ■    | ■   | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■    | ■   | ●   | ■   | ■     | ■   | ■   | ■   | ■   | ■     |
| msgSendFlagMap             | ●    | ▲   | ▲    | ▲    | ▲    | ▲    | ▲   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲   | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲     | ▲   | ▲   | ▲   | ▲   | ▲     |
| flowVarMap                 | ●    | ▲   | ▲    | ▲    | ▲    | ▲    | ▲   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲   | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲     | ▲   | ▲   | ▲   | ▲   | ▲     |
| nextNodeId                 | ●    | ■   | ■    | ■    | ■    | ■    | ●   | ■    | ▲   | ■    | ■    | ▲    | ●   | ●   | ■   | ■   | ■    | ■   | ■   | ■   | ■    | ■   | ●   | ■   | ■     | ■   | ■   | ■   | ■   | ■     |
| title                      | ▲    | ▲   | ▲    | ▲    | ▲    | ▲    | ▲   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲   | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲    | ▲   | ●   | ▲   | ▲     | ▲   | ▲   | ▲   | ▲   | ▲     |
| messageMoulds              | ▲    | ▲   | ▲    | ▲    | ▲    | ▲    | ▲   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲   | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲    | ▲   | ●   | ▲   | ▲     | ▲   | ▲   | ▲   | ▲   | ▲     |
| otherPara                  | ▲    | ▲   | ▲    | ▲    | ▲    | ▲    | ▲   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲   | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲    | ▲   | ●   | ▲   | ▲     | ▲   | ▲   | ▲   | ▲   | ▲     |
| selectAuthorMap            | ■    | ■   | ■    | ■    | ■    | ■    | ■   | ■    | ■   | ■    | ■    | ■    | ■   | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■    | ■   | ●   | ■   | ■     | ■   | ■   | ■   | ■   | ■     |
| selectAuthorNameMap        | ▲    | ▲   | ▲    | ▲    | ▲    | ▲    | ▲   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲   | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲    | ▲   | ●   | ▲   | ▲     | ▲   | ▲   | ▲   | ▲   | ▲     |
| selectSubFlowid            | ●    | ●   | ●    | ●    | ●    | ●    | ●   | ●    | ●   | ●    | ●    | ●    | ●   | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●     | ●   | ●   | ●   | ●   | ■     |
| urlApp                     | ▲    | ▲   | ▲    | ▲    | ▲    | ▲    | ▲   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲   | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲     | ▲   | ▲   | ▲   | ▲   | ▲     |
| dataIdentifier             | ■    | ■   | ■    | ■    | ■    | ■    | ■   | ■    | ■   | ■    | ■    | ■    | ■   | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■     | ■   | ■   | ■   | ■   | ■     |
| flowIdentifier             | ■    | ■   | ■    | ■    | ■    | ■    | ■   | ■    | ■   | ■    | ■    | ■    | ■   | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■     | ■   | ■   | ■   | ■   | ■     |
| allUserids                 | ▲    | ▲   | ▲    | ▲    | ▲    | ▲    | ▲   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲   | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ●   | ▲     | ●   | ▲   | ▲   | ●   | ▲     |
| parentWorkid               | ●    | ●   | ●    | ●    | ●    | ●    | ●   | ●    | ●   | ●    | ●    | ●    | ●   | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●     | ●   | ●   | ●   | ●   | ▲     |
| outerConfig                | ▲    | ▲   | ▲    | ▲    | ▲    | ▲    | ▲   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲   | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲    | ▲   | ●   | ●   | ▲     | ●   | ▲   | ▲   | ●   | ▲     |
| comment                    | ▲    | ▲   | ▲    | ▲    | ▲    | ▲    | ▲   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲   | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲     | ▲   | ▲   | ▲   | ▲   | ▲     |
| sxComment                  | ▲    | ▲   | ▲    | ▲    | ▲    | ▲    | ▲   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲   | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲     | ▲   | ▲   | ▲   | ▲   | ▲     |
| submitflag                 | ■    | ■   | ■    | ■    | ■    | ■    | ■   | ■    | ■   | ■    | ■    | ■    | ■   | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■    | ■   | ■   | ■   | ■     | ■   | ■   | ■   | ■   | ■     |
| clearMemAfterAction        | ▲    | ▲   | ▲    | ▲    | ▲    | ▲    | ▲   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲   | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲    | ▲   | ●   | ▲   | ▲     | ▲   | ▲   | ▲   | ▲   | ▲     |
| isMultiInstanceTransaction | ▲    | ▲   | ▲    | ▲    | ▲    | ▲    | ▲   | ▲    | ▲   | ▲    | ▲    | ▲    | ▲   | ▲   | ▲   | ▲   | ▲    | ▲   | ▲   | ▲   | ▲    | ▲   | ●   | ▲   | ▲     | ▲   | ▲   | ▲   | ▲   | ▲     |
| rejectOtherBranch          | ●    | ●   | ●    | ●    | ●    | ●    | ●   | ●    | ●   | ■    | ●    | ●    | ●   | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●     | ●   | ●   | ●   | ●   | ●     |
| nextNodeName               | ●    | ●   | ●    | ●    | ●    | ■    | ●   | ●    | ●   | ●    | ●    | ●    | ●   | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●     | ●   | ●   | ●   | ●   | ●     |
| nextNodeModuleName         | ●    | ●   | ●    | ●    | ●    | ▲    | ●   | ●    | ●   | ●    | ●    | ●    | ●   | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●     | ●   | ●   | ●   | ●   | ●     |
| nextNodeX                  | ●    | ●   | ●    | ●    | ●    | ▲    | ●   | ●    | ●   | ●    | ●    | ●    | ●   | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●     | ●   | ●   | ●   | ●   | ●     |
| nextNodeY                  | ●    | ●   | ●    | ●    | ●    | ▲    | ●   | ●    | ●   | ●    | ●    | ●    | ●   | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●     | ●   | ●   | ●   | ●   | ●     |
| nextNodePosX               | ●    | ●   | ●    | ●    | ●    | ▲    | ●   | ●    | ●   | ●    | ●    | ●    | ●   | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●     | ●   | ●   | ●   | ●   | ●     |
| nextNodePosY               | ●    | ●   | ●    | ●    | ●    | ▲    | ●   | ●    | ●   | ●    | ●    | ●    | ●   | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●    | ●   | ●   | ●   | ●     | ●   | ●   | ●   | ●   | ●     |

**服务描述**
<table>
    <tr>
        <td>方法名称</td>
        <td>operator</td>
        <td>中文名称</td>
        <td>流程实例提交</td>
    </tr>
    <tr>
        <td>功能描述</td>
        <td colspan="3">此服务用于流程实例通用操作，如提交、加签等全部通用操作。</td>
    </tr>
    <tr>
        <td colspan="4" align="center">接口信息</td>
    </tr>
    <tr>
        <td>接口类型</td>
        <td>api</td>
        <td>交互频度</td>
        <td>非周期</td>
    </tr>
    <tr>
        <td>接口协议</td>
        <td>直接方法调用</td>
        <td>响应时间</td>
        <td></td>
    </tr>
    <tr>
        <td>备注</td>
        <td colspan="3">IWorkResult operator(WorkParaBean workParaBean)</td>
    </tr>
</table>
****

### 启动流程
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setFlowId(flowId);					//流程定义id
inparam.setUserId(userId);					//当前操作人id
inparam. setTenantCode(tenantCode)       //租户id        
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
inparam.setDoNotToFirstNode(false);         //第一个节点是否提交
//操作的实现类(全路径) 
inparam.setActionClass("com.horizon.wf.action.ActionSubmitFirst");	
inparam.setFunname("Startflow");			//实例操作标识
inparam.setActionname("启动流程");		//操作名称
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//2.执行操作，不需要与后台交互
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){ 
//3.2后台自动返回的信息
}else{    
	result. getBackMsg();      
}     
```
### 提交
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id        
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionSubmit");
inparam.setFunname("Submit");			//实例操作标识
inparam.setActionname("提交");		//操作名称
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//设置提交节点：路由id~节点id
inparam.setNextNodeId("Line2~Node2");
// 设置办理人/协办/读者 id
Map<String,String> selectAuthorMap = inparam.getSelectAuthorMap();
selectAuthorMap.put("Line2-Author"," U_admin/D_HZ28821856ef63420156ef63429c0000");
selectAuthorMap.put("Line2-SecondAuthor"," U_ HZ28821856ef63420156ef6342a20002/D_HZ28821856ef63420156ef6342a20001 ");
selectAuthorMap.put("Line2-Reader"," U_admin/D_HZ28821856ef63420156ef63429c0000");
// 设置办理人/协办/读者姓名
Map<String,String> selectAuthorNameMap = inparam.getSelectAuthorNameMap();
selectAuthorNameMap.put("Line2-Author", "管理员(慧正通软)");
selectAuthorNameMap.put("Line2-SecondAuthor"," 用户01(测试部门01)");
selectAuthorNameMap.put("Line2-Reader", "管理员(慧正通软)");
// 设置节点办理时限 key为下一节点id，value为时限类型和时限数目，分号拼
// 接，时限类型为固定值，0：自然日，1：工作日
inparam .putNodeLimitSetMap("node2", "0;3");
//2.执行操作，不需要与后台交互
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
	//3.2后台自动返回的信息
}else{    
	result. getBackMsg();      
} 
```

### 多分支-调用示例
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id        
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionSubmit");
inparam.setFunname("Submit");			//实例操作标识
inparam.setActionname("提交");		//操作名称
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//设置提交节点：路由id~节点id，多个提交节点之间用“&”隔开
inparam.setNextNodeId("Line2~Node2&Line3~Subflow3");
Map<String,String> selectAuthorMap = inparam.getSelectAuthorMap();
// 设置第一个节点 办理人/协办/读者 id
selectAuthorMap.put("Line2-Author"," U_admin/D_HZ28821856ef63420156ef63429c0000");
selectAuthorMap.put("Line2-SecondAuthor"," U_ HZ28821856ef63420156ef6342a20002/D_HZ28821856ef63420156ef6342a20001 ");
selectAuthorMap.put("Line2-Reader"," U_admin/D_HZ28821856ef63420156ef63429c0000");
// 设置第二个节点读者 id
selectAuthorMap.put("Line3- Reader"," U_ HZ28821856ef63420156ef6342a20002/D_HZ28821856ef63420156ef6342a20001 ");
// 设置第一个节点办理人/协办/读者姓名
Map<String,String> selectAuthorNameMap = inparam.getSelectAuthorNameMap();
selectAuthorNameMap.put("Line2-Author", "管理员(慧正通软)");
selectAuthorNameMap.put("Line2-SecondAuthor"," 用户01(测试部门01)");
selectAuthorNameMap.put("Line2-Reader", "管理员(慧正通软)");
// 设置第二个节点读者姓名
selectAuthorNameMap.put("Line3-SecondAuthor"," 用户01(测试部门01)");
// 设置节点办理时限 key为提交节点id，value为时限类型和时限数目，分号拼
// 接，时限类型为固定值，0：自然日，1：工作日
// 设置第一个提交节点办理时限
inparam .putNodeLimitSetMap("node2", "0;3");
// 设置第二个提交节点办理时限
inparam .putNodeLimitSetMap("Subflow3", "1;2");
//2.执行操作，不需要与后台交互
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
//3.2后台自动返回的信息
}else{    
    result. getBackMsg();      
}
```
### 增加协办
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id        
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionAddSecondAuthor");
inparam.setFunname("addSecondauthor");			//实例操作标识
inparam.setActionname("增加协办");		//操作名称
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
inparam.setNextNodeId(nodeId) //设置协办节点，与当前节点相同
// 增加协办id
Map<String,String> selectAuthorMap = inparam.getSelectAuthorMap();
selectAuthorMap.put("Node1-Author","
HZ28821856ef63420156ef6342a20002/D_HZ28821856ef63420156ef6342a20001 ");
//增加协办姓名
Map<String,String> selectAuthorNameMap = inparam.getSelectAuthorNameMap();
selectAuthorNameMap.put("Node1-Author", "用户01(测试部门01)");
//2.执行操作，不需要与后台交互
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
}
//3.2后台自动返回的信息
else{    
result. getBackMsg();      
}
```
### 协办提交
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id        
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionSubmitNotLeave");
inparam.setFunname("SecondSubmit");			//实例操作标识
inparam.setActionname("协办提交");		//操作名称
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//2.执行操作，不需要与后台交互
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
}
//3.2后台自动返回的信息
else{    
result. getBackMsg();      
}
``` 
### 内部提交
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id        
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionSubmitForProgressively");
inparam.setFunname("innerSubmit");			//实例操作标识
inparam.setActionname("内部提交");		//操作名称
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
inparam.setNextNodeId(nodeId) //设置内部提交节点，与当前节点相同
//设置内部提交办理人id
Map<String,String> selectAuthorMap = inparam.getSelectAuthorMap();
selectAuthorMap.put("Node2-Author","
HZ28821856ef63420156ef6342a20002/D_HZ28821856ef63420156ef6342a20001 ");
//设置内部提交办理人姓名
Map<String,String> selectAuthorNameMap = inparam.getSelectAuthorNameMap();
selectAuthorNameMap.put("Node2-Author", "用户01(测试部门01)");
//2.执行操作，不需要与后台交互
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
//3.2后台自动返回的信息
}else{    
    result. getBackMsg();      
}
```
### 自由提交
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id        
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionSubmitForFree");
inparam.setFunname("freeSubmit");			//实例操作标识
inparam.setActionname("自由提交");		//操作名称
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//自由提交无需设置提交自由节点id，但需设置自由节点名称
inparam.setNextNodeName("测试自由节点");
inparam.setNextNodeX (12); //设置在页面的横坐标
inparam.setNextNodeY (25); //设置在页面的纵坐标
// 设置自由节点办理人/协办/读者 id，key为字符串“Node-Author、
// Node-SecondAuthor、Node-Reader”固定值
Map<String,String> selectAuthorMap = inparam.getSelectAuthorMap();
selectAuthorMap.put("Node-Author","U_admin/D_HZ28821856ef63420156ef63429c0000");
selectAuthorMap.put("Node-SecondAuthor","U_ HZ28821856ef63420156ef6342a20002/D_HZ28821856ef63420156ef6342a20001");
selectAuthorMap.put("Node-Reader","U_admin/D_HZ28821856ef63420156ef63429c0000");
// 设置自由节点办理人/协办/读者姓名，key为字符串“Node-Author、
// Node-SecondAuthor、Node-Reader”固定值
Map<String,String> selectAuthorNameMap = inparam.getSelectAuthorNameMap();
selectAuthorNameMap.put("Node-Author", "管理员(慧正通软)");
selectAuthorNameMap.put("Node-SecondAuthor"," 用户01(测试部门01)");
selectAuthorNameMap.put("Node-Reader", "管理员(慧正通软)");
// 设置节点办理时限key为字符串“Node”固定值，value为时限类型和时限数// 目，分号拼接，时限类型为固定值，0：自然日，1：工作日
inparam .putNodeLimitSetMap("Node", "0;3");
//2.执行操作，不需要与后台交互
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
}
//3.2后台自动返回的信息
else{    
result. getBackMsg();      
}
```
###	退回提交
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id        
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionSubmitForReject");
inparam.setFunname("RejectSubmit");			//实例操作标识
inparam.setActionname("退回提交");		//操作名称
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//2.执行操作，不需要与后台交互
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
}
//3.2后台自动返回的信息
else {    
result. getBackMsg();      
}
```

### 会签
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionHuiQian");
inparam.setFunname("Huiqian");			//实例操作标识
inparam.setActionname("会签");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//会签办理人，必须设置，也可以调用inparam. setSelectAuthorMap(map)
inparam. putSelectAuthor ("Author","U_admin") ;
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//2.执行操作
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
}
//3.2该节点类型不支持相应的操作---会签
else if(cp== StaticVarExtend.F_STATUS_Not_Operator_Nodetype){
//前台页面提示
}
//3.3后台自动返回的信息
else{    
result. getBackMsg();      
}
```
###	会签提交
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionSubmitHuiqian");
inparam.setFunname("HuiqianSubmit");			//实例操作标识
inparam.setActionname("会签提交");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//2.执行操作
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if (cp == StaticVarExtend.F_STATUS_Success){
}
//3.2后台自动返回的信息
else {    
result. getBackMsg();      
}
```
### 退回
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionReject");
inparam.setFunname("Reject");			//实例操作标识
inparam.setActionname("退回");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//2.执行操作，不需要与后台交互,系统自动退回到上一个办理过的节点
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if (cp == StaticVarExtend.F_STATUS_Success) {
//3.2后台自动返回的信息
}else {    
    result.getBackMsg();      
}
```
### 任意退回
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("1");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionRejectByJump");
inparam.setFunname("JumpReject");			//实例操作标识
inparam.setActionname("任意退回");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//如果知道要退回的节点ID，可以直接设置;如果不清楚，可以先不设置
inparam.setNextNodeId ("Node1");
//设置是否设置连带退回标识,1：是  0：否 默认是0
inparam. setRejectOtherBranch ("1");
//2.执行操作,与后台交互
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.获取消息发送方式
String msgFlag = "";  	
List< INextNode> nodes = result.getNextNodes();
if(!(nodes ==null || nodes.size()==0)){
 INodeAuthUser nodeAuthUser = nodes.get(0).getFlowNode().getParticipantsUserList().get(0);
 if(wb != null){
  if(null != nodeAuthUser){
  //默认取后边第0个节点的：第一身份的消息发送方式
  msgFlag = nodeAuthUser.getSendMsgFlag() ;
  }
 }
}
//4.操作返回值的判断
//4.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
//调用选择具体的成功操作方法
successRejectOper(result);
}
//4.2提示需要选择要退回的节点
else if(cp == StaticVarExtend.F_STATUS_SelectNode){
//获取跳转的节点信息，遍历List，把参数设置到iniparam中重新执行操作。
if(nodes==null || nodes.size()==0){
//没有节点可选择，页面可以直接关闭
}else{
//遍历Node节点信息
for(int i=0,n=nodes.size();i<n;i++){
//可以选择的节点Id
String selectNodeId = ((IXmlNode)nodes.get(i)).getNodeid();
//可以选择的节点名称            
String selectNodeName = ((IXmlNode)nodes.get(i)).getNodename();
//页面处理选择的节点信息，把参数设置到iniparam中重新执行操作
}
}
}
//4.3提示需要选择办理人
else if(cp == StaticVarExtend.F_STATUS_SelectAuthor){
//获取办理人信息，把参数设置到iniparam中重新执行操作。
//调用 “提交”操作的示例代码selectAuthor()方法
selectAuthor(result);
}
//4.4提示办理人为空
else if(cp == StaticVarExtend.F_STATUS_NoAuthor){
//界面显示提示信息
}
//4.5后台自动返回的信息
else{    
result. getBackMsg();      
}
//任意退回提示成功后的操作
private void successRejectOper(IWorkResult result){
boolean haveNormal = false;//是否有办理人(标志)
//办理人身份ID
String[] participantId_success=
result.getFlowInfo().getParticipantTypes().split(";");
//办理人身份名称
String[] participantName_success =
result.getFlowInfo().getParticipantNames().split(";");
//办理人信息
LinkedHashMap selectAuthorMap_success = (LinkedHashMap)
result.getWorkParaBean().getSelectAuthorMap();
//退回的节点Id
String nodeId = result. getWorkParaBean().getNextNodeId();
IXmlNode tempNextNode = result.getFlowInfo().getNodeById(nodeId);
int nodetype = tempNextNode.getNodetype();		//节点类型
String nodeName = tempNextNode.getNodename();	//节点名称
if(nodetype==StaticVarExtend.Node_Mutual){//多引擎交互节点
//界面提示已经到引擎交互节点
}else{
//显示办理人
haveNormal = true;
//参与者信息
List<IXmlUser> userList = tempNextNode.getParticipantsUserList();
String selUserFunCurNode = "";
String tempParticipantId_success = "";
String tempParticipantName_success = "";
for(IXmlUser tempUser:userList){
StringBuffer tempAuthor = new StringBuffer();
tempParticipantId_success = tempUser.getAuthName();
for(int j=0;j<participantId_success.length;j++){
if(tempParticipantId_success.equals(participantId_success[j])){
tempParticipantName_success = participantName_success[j];
break;
}
}
//要选择的办理人Id
String tempId = "";
//要选择的办理人名称
String tempName = "";
if(selectAuthorMap_success!=null && selectAuthorMap_success
.get(nodeId+"-"+tempParticipantId_success)!=null){
tempId = (String)selectAuthorMap_success
.get(nodeId+"-"+tempParticipantId_success);
if(tempId.endsWith(";")){
tempId = tempId.substring(0,tempId.length()-1);
}
}
if(StringUtil.hasValue(tempId)){
//根据办理人Id从组织机构获得办理人名称,需要在此处对tempName赋值
}
tempAuthor.append(tempName);
if(tempAuthor.toString().length()>0){
//界面显示办理人信息
}
}//end for for(IXmlUser tempUser:userList)
}//end for 非多引擎交互节点
/**
* 满足以下情况时，才显示消息发送方式的选择框
* haveNormal:是否有办理人(标志) 为true
* StaticVarWorkFlowFrame.ReChgMsgFlag:是否需要在提交时重新指定发送消息的方式 为true
*/
if(haveNormal && StaticVarWorkFlowFrame.ReChgMsgFlag){
//页面显示要选择的消息处理方式
}
//此处可以通过页面设置是否连带退回属性RejectOtherBranch
}
```
###	内部退回
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("1");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionRejectForInner");
inparam.setFunname("innerreject");			//实例操作标识
inparam.setActionname("内部退回");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源

//2.执行操作,与后台交互
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if (cp == StaticVarExtend.F_STATUS_Success) {

}
//3.2后台自动返回的信息
else {    
result.getBackMsg();      
}
```
### 拿回
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionGetBack");
inparam.setFunname("Getback");			//实例操作标识
inparam.setActionname("拿回");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源

//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");

//2.执行操作，不需要与后台交互
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();

//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){

}
//3.2后台自动返回的信息
else{    
result. getBackMsg();      
}
```
### 暂存
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionSave");
inparam.setFunname("Save");			//实例操作标识
inparam.setActionname("暂存");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//2.执行操作，不需要与后台交互
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
//3.2后台自动返回的信息
}else{
    result. getBackMsg();      
}
```
### 撤办
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionCancel");
inparam.setFunname("Cancel");			//实例操作标识
inparam.setActionname("撤办");		//操作名称
//2.执行操作，不需要与后台交互
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
//3.2后台自动返回的信息
}else{    
    result. getBackMsg();      
}
```
### 跳转
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("1");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionGoto");
inparam.setFunname("Goto");			//实例操作标识
inparam.setActionname("跳转");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//下面两个参数如果事先知道，可以设置，如果不知道可以通过虚拟提交获取
//后再进行设置。
//下一节点办理人,也可以调用inparam. setSelectAuthorMap(map)
inparam. putSelectAuthor ("Node1-Author","U_admin") ;	  
inparam.setNextNodeId("Node1");   //提交的下一个节点
//2.执行操作
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.获取消息发送方式
String msgFlag = "";  	
IXmlUser iXmlUser = result.getNextNodes().get(0).getParticipantsUserList().get(0);
if(result != null && iXmlUser!=null){
//默认取后边第0个节点的：第一身份的消息发送方式
msgFlag = iXmlUser.getSendMsgFlag();
}
//4.操作返回值的判断
//4.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
//成功处理方式
//调用 “任意退回”操作的示例代码sucessRejectOper()方法
successRejectOper(result);
}
//4.2需要选择节点
else if(cp == StaticVarExtend.F_STATUS_SelectNode){    
//获取跳转的节点信息，遍历List，把参数设置到iniparam中重新执行操作。
List<INextNode> nodes = result.getNextNodes();
if(nodes==null || nodes.size()==0){
//没有节点可选择，页面可以直接关闭
}else{
//遍历Node节点信息
for(int i=0,n=nodes.size();i<n;i++){
//可以选择的节点Id
String selectNodeId = ((IXmlNode)nodes.get(i)).getNodeid();
//可以选择的节点名称            
String selectNodeName = ((IXmlNode)nodes.get(i)).getNodename();
//页面处理选择的节点信息，把参数设置到iniparam中重新执行操作
}
}
}
//4.3提示需要选择办理人
else if(cp == StaticVarExtend.F_STATUS_SelectAuthor){
//获取办理人信息，把参数设置到iniparam中重新执行操作。
//调用 “提交”操作的示例代码selectAuthor()方法
selectAuthor(result);
}
//4.4提示办理人为空
else if(cp == StaticVarExtend.F_STATUS_NoAuthor){
//界面显示提示信息
}else{    //4.5后台自动返回的信息
    result.getBackMsg();      
}
```
### 前加签
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionJiaQianBefore");
inparam.setFunname("jiaqianBefore");			//实例操作标识
inparam.setActionname("前加签");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
nparam.setNextNodeId(nodeId);              //当前节点Id
// 前加签办理人，必须设置
Map<String,String> selectAuthorMap = inparam.getSelectAuthorMap();
selectAuthorMap.put("Node2-Author","
HZ28821856ef63420156ef6342a20002/D_HZ28821856ef63420156ef6342a20001 ");
// 前加签办理姓名
Map<String,String> selectAuthorNameMap = inparam.getSelectAuthorNameMap();
selectAuthorNameMap.put("Node1-Author", "用户01(测试部门01)");
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
Inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//2.执行操作
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
}
//3.2该节点类型不支持相应的操作---前加签
else if(cp== StaticVarExtend.F_STATUS_Not_Operator_Nodetype){
//前台页面提示
}else{ //3.3后台自动返回的信息   
    result. getBackMsg();      
}
```
### 加签
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionJiaQian");
inparam.setFunname("Jiaqian");			//实例操作标识
inparam.setActionname("加签");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
Inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
inparam.setNextNodeId(nodeId);              //当前节点Id
// 加签办理人，必须设置，key为:节点id-Author
Map<String,String> selectAuthorMap = inparam.getSelectAuthorMap();
selectAuthorMap.put("Node2- Author ","HZ28821856ef63420156ef6342a20002/D_HZ28821856ef63420156ef6342a20001");
// 加签办理姓名，key为:节点id-Done
Map<String,String> selectAuthorNameMap = inparam.getSelectAuthorNameMap();
selectAuthorNameMap.put("Node2-Author", "用户01(测试部门01)");
//2.执行操作
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
}
//3.2该节点类型不支持相应的操作---加签
else if(cp== StaticVarExtend.F_STATUS_Not_Operator_Nodetype){
//前台页面提示
}
//3.3后台自动返回的信息
else{    
result. getBackMsg();      
}
```
### 减签
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionReduceAuthor");
inparam.setFunname("reduceAuthor");			//实例操作标识
inparam.setActionname("减签");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
inparam.setNextNodeId(nodeId);              //当前节点Id
// 减签办理人，必须设置，key为:节点id-Done
Map<String,String> selectAuthorMap = inparam.getSelectAuthorMap();
selectAuthorMap.put("Node2-Done","HZ28821856ef63420156ef6342a20002/D_HZ28821856ef63420156ef6342a20001");
// 减签办理姓名，key为:节点id-Done
Map<String,String> selectAuthorNameMap = inparam.getSelectAuthorNameMap();
selectAuthorNameMap.put("Node2-Done ", "用户01(测试部门01)");
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
Inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//2.执行操作
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
}
//3.2该节点类型不支持相应的操作---减签
else if(cp== StaticVarExtend.F_STATUS_Not_Operator_Nodetype){
//前台页面提示
}
//3.3后台自动返回的信息
else{    
result. getBackMsg();      
}
```
### 补发
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionReissue");
inparam.setFunname("Reissue");			//实例操作标识
inparam.setActionname("补发");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//要补发的办理人，必须设置，也可以调用inparam. setSelectAuthorMap(map)
inparam. putSelectAuthor ("Author","U_admin") ;
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//2.执行操作
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
}
//3.2该节点类型不支持相应的操作---补发
else if(cp== StaticVarExtend.F_STATUS_Not_Operator_Nodetype){
//前台页面提示
}else{//3.3后台自动返回的信息    
    result. getBackMsg();      
}
```
### 分支补发
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("1");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionReissueRouter");
inparam.setFunname("RreissueRouter");			//实例操作标识
inparam.setActionname("分支补发");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//下面两个参数如果事先知道，可以设置，如果不知道可以通过虚拟提交获取
//后再进行设置。
//下一节点办理人,也可以调用inparam. setSelectAuthorMap(map)
inparam. putSelectAuthor ("Line1-Author","U_admin") ;	  
inparam.setNextNodeId("Line1~Node1");   //提交的下一个节点
//2.执行操作
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.获取消息发送方式
String msgFlag = "";  	
if(null != result.getNextNodes() && result.getNextNodes().size()>0){
if(null != result.getNextNodes().get(0)){
List< INodeAuthUser> xmlUsers = result.getNextNodes().getFlowNode().get(0).getParticipantsUserList();
if(null != xmlUsers && xmlUsers.size()>0){
IXmlUser iXmlUser = xmlUsers.get(0);
if(null != iXmlUser){
//默认取后边第0个节点的：第一身份的消息发送方式
msgFlag = iXmlUser.getSendMsgFlag();
}
}
}
}
//4.操作返回值的判断
//4.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
successReissueRouterOper(result);//成功处理方式 重写
}
//4.2提示选择人员
else if(cp == StaticVarExtend.F_STATUS_SelectAuthor){    
if(result.getNextNodes()!=null && result.getNextNodes().size()>1){
int submitFlag = 0;//正式提交,后续需要设置setSubmitflag("0")属性
//调用选择具体的节点方法
selectReissueRouterNode(result);
}else{
//获取办理人信息，把参数设置到iniparam中重新执行操作。
//调用 “提交”操作的示例代码selectAuthor()方法
selectAuthor(result);
}     
}  
//4.4提示选择节点
else if(cp == StaticVarExtend.F_STATUS_SelectNode){    
int submitFlag = 1;//正式提交,后续需要设置setSubmitflag("1")属性
//选择具体的节点
selectReissueRouterNode (result);     
}  
//4.5提示办理人为空
else if(cp == StaticVarExtend.F_STATUS_NoAuthor){    
//前台页面提示处理
}
//4.6进入规则调用错误
else if(cp == StaticVarExtend.F_STATUS_EntryRule_Error){    
//前台页面提示处理
}
//4.7离开规则调用错误
else if(cp == StaticVarExtend.F_STATUS_LeaveRule_Error){    
//前台页面提示处理
}  
//4.8启动规则调用错误
else if(cp == StaticVarExtend.F_STATUS_StartRule_Error){    
//前台页面提示处理
}   
//4.9无法获取下一节点
else if(cp == StaticVarExtend.F_STATUS_NoFound){    
//前台页面提示处理
}  
//4.10流程结束
else if(cp == StaticVarExtend.F_STATUS_FlowEnd){    
//前台页面提示处理
}
//4.11子流程未结束
else if(cp == StaticVarExtend.F_STATUS_SubFlowNoEnd){    
//前台页面提示处理
}
//4.12流程暂停
else if(cp == StaticVarExtend.F_STATUS_FlowPause){    
//前台页面提示处理
}
//4.13流程异常终止
else if(cp == StaticVarExtend.F_STATUS_FlowErrorEnd){    
//前台页面提示处理
}   
//4.14后台自动返回的信息
else{    
result. getBackMsg();      
}

//分支补发提示成功后的操作
public void successReissueRouterOper (IWorkResult result){
boolean haveNormal = false;//是否有办理人(标志)
//办理人身份ID
String[] participantId_success=
result.getFlowInfo().getParticipantTypes().split(";");
//办理人身份名称
String[] participantName_success =
result.getFlowInfo().getParticipantNames().split(";");
//办理人信息
LinkedHashMap selectAuthorMap_success = (LinkedHashMap)
result.getWorkParaBean().getSelectAuthorMap();
//补发操作的节点信息
if(result.getNextNodes()!=null){
//遍历下一节点列表信息
for(int i=0,n= result.getNextNodes().size();i<n;i++){
IXmlNode tempNextNode = result.getNextNodes().get(i);
int nodetype = tempNextNode.getNodetype();		//节点类型
String nodeId = tempNextNode.getNodeid();		//节点ID
String nodeName = tempNextNode.getNodename();	//节点名称
if(nodetype==StaticVarExtend.Node_Mutual){//多引擎交互节点
//界面提示已经到引擎交互节点
}else{
//显示办理人
List<IXmlUser> userList = tempNextNode.getParticipantsUserList();
String selUserFunCurNode = "";
        //最后返回要显示的办理人变量
        String tempParticipantId_success = "";
		String tempParticipantName_success = "";
           //遍历办理人信息
           for(IXmlUser tempUser:userList){
				tempParticipantId_success = tempUser.getAuthName();
				for(int j=0;j<participantId_success.length;j++){
                   if(tempParticipantId_success.
                              equals(participantId_success[j])){
			             tempParticipantName_success = 
                                        participantName_success[j];
				       break;
				     }
			     } //end for participantId_success.length
			    //办理人Id
                 String tempId = "";
			    //办理人Name
                 String tempName = "";
			    if(selectAuthorMap_success!=null &&  
                   selectAuthorMap_success.
                       get(nodeId+"-"+tempParticipantId_success)!=null){
					      tempId = (String)selectAuthorMap_success
                          .get(nodeId+"-"+tempParticipantId_success);
					     if(tempId.endsWith(";")){
						     tempId = tempId.substring(0,tempId.length()-1);
					     }
			     }
                 //根据办理人Id从组织机构获得办理人名称,需要在此处对tempName赋值
			    
			    if(StringUtil.hasValue(tempId)){
				    haveNormal = true;//当tempId有值，是否有办理人(标志)为true
				//此处需要在页面显示办理人信息 tempParticipantName_success
              //和tempName
								
			    }
		 }//end for IXmlUser
      }//end for 非多引擎交互节点

     }//end for result.getNextNodes();
    }//end if result.getNextNodes()!=null
    /**
			 * 满足以下情况时，才显示消息发送方式的选择框
			 * haveNormal:是否有办理人(标志) 为true
			 * StaticVarWorkFlowFrame.ReChgMsgFlag:是否需要在提交时重新指定发送消息的方式 为true
			 */
	if(haveNormal && StaticVarWorkFlowFrame.ReChgMsgFlag){
          //页面显示要选择的消息处理方式
     }
}
//分支补发提示选择节点的操作
private  void selectReissueRouterNode (IWorkResult result){
List nodes = result.getNextNodes();//可选的节点信息
//办理人信息
LinkedHashMap tmpAuthorMap = (LinkedHashMap) result.getTmpAuthorMap();
LinkedHashMap selectAuthorMap = (LinkedHashMap)
result.getWorkParaBean().getSelectAuthorMap();
LinkedHashMap initAuthorMap = (LinkedHashMap)
result.getInitAuthorMap();
if(nodes!=null){
for(int i=0,n=nodes.size();i<n;i++) {
IXmlNode node = (IXmlNode)nodes.get(i);
String nodeId = node.getNodeid();			//节点id
String nodeName = node.getNodename();		//节点名称
//设置选中的节点Id
String selectid = nodeId;
//设置选中的节点名称
String selectname = nodeName;
//判断给定的路由是否选中
boolean isSelected = result.isSelectedRouter(nodeId);
//此处页面可以根据是否选中状态显示节点信息
//如果是选中状态
if(isSelected){
int tmpSwitch = result.getResultByNodeid(nodeId);
//获取流程定义的参与者信息
String[] participantId =
result.getFlowInfo().getParticipantTypes().split(";");
String[] participantName =
result.getFlowInfo().getParticipantNames().split(";");
List<IXmlUser> userList = node.getParticipantsUserList();
switch(tmpSwitch) {
case StaticVarExtend.F_STATUS_Success://成功信息显示处理
case StaticVarExtend.F_STATUS_SelectAuthor://人员选择处理
//参考selectAuthor()处理。
case StaticVarExtend.F_STATUS_NoFound://无法获取下一节点
case StaticVarExtend.F_STATUS_SubFlowNoEnd://子流程未结束
case StaticVarExtend.F_STATUS_FlowEnd://流程结束
case StaticVarExtend.F_STATUS_FlowPause://流程暂停
case StaticVarExtend.F_STATUS_FlowErrorEnd://流程异常终止
default:
result. getBackMsg();//其他错误信息处理                 
}//end for switch(tmpSwitch)
}//end for (isSelected)
}//end for for循环
}//end for tpRouter!=null
}
```
### 转办
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionMove");
inparam.setFunname("Move");			//实例操作标识
inparam.setActionname("转办");		//操作名称
//要转办的办理人，必须设置，也可以调用inparam. setSelectAuthorMap(map)
inparam. putSelectAuthor ("Author","U_admin") ;
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//2.执行操作
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
}
//3.2该节点类型不支持相应的操作---转办
else if(cp== StaticVarExtend.F_STATUS_Not_Operator_Nodetype){
//前台页面提示
}
//3.3后台自动返回的信息
else{    
result. getBackMsg();      
}
```
### 暂停
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionPause");
inparam.setFunname("Pause");			//实例操作标识
inparam.setActionname("暂停");		//操作名称
//执行操作，不需要与后台交互
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
}else{//后台自动返回的信息    
    result. getBackMsg();      
}
```
### 替换处理人
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionReplaceAuthor");
inparam.setFunname("Replace");			//实例操作标识
inparam.setActionname("替换办理人");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//要替换的办理人，必须设置，也可以调用inparam. setSelectAuthorMap(map)
inparam. putSelectAuthor ("Author","U_admin") ;
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//2.执行操作
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
}
//3.2该节点类型不支持相应的操作---替换办理人
else if(cp== StaticVarExtend.F_STATUS_Not_Operator_Nodetype){
//前台页面提示
}else{//3.3后台自动返回的信息    
    result. getBackMsg();      
}
```
### 终止
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionStop");
inparam.setFunname("Stop");			//实例操作标识
inparam.setActionname("终止");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//执行操作，不需要与后台交互
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
}else{//后台自动返回的信息    
    result. getBackMsg();      
}
```
###	阅知
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionAddReader ");
inparam.setFunname("AddReader");			//实例操作标识
inparam.setActionname("阅知");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//要阅知的办理人，必须设置，也可以调用inparam. setSelectAuthorMap(map)
inparam. putSelectAuthor ("Reader","U_admin") ;
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//2.执行操作
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//3.操作返回值的判断
//3.1操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
}
//3.2该节点类型不支持相应的操作---阅知
else if(cp== StaticVarExtend.F_STATUS_Not_Operator_Nodetype){
//前台页面提示
}else{//3.3后台自动返回的信息  
    result. getBackMsg();      
}
```
###	已阅
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionReaded");
inparam.setFunname("readed");			//实例操作标识
inparam.setActionname("已阅");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//执行操作，不需要与后台交互
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
}else{//后台自动返回的信息  
    result. getBackMsg();      
}
```
###	催办
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("1");//是否确认进行操作 0:确认  1:前后台交互
inparam.setActionClass("com.horizon.wf.action.ActionReMsg");	//操作的
//实现类(全路径)
inparam.setFunname("Urge");			//实例操作标识
inparam.setActionname("催办");		//操作名称
inparam.setComment ("催办意见内容");		//催办时的意见内容
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//执行操作，预提交与后台交互
IWorkResult result = opr.operator(inparam);	  
int cp = result.getResult();
//执行操作成功
if(cp==StaticVarExtend.F_STATUS_Success){
}
//催办次数超过设置
else if(cp==StaticVarExtend.F_STATUS_OverReMsg){
result.getBackMsg();
}else{//后台自动返回的信息
    result.getBackMsg();
}
```
### 启动子流程
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //租户id
inparam.setSubmitflag("1");//是否确认进行操作 0:确认  1:前后台交互
inparam.setActionClass("com.horizon.wf.action.ActionStartMultiSubFlow");
//操作的实现类(全路径)
//或者,需要与流程定义设置的启动子流程使用的操作类保持一致。
inparam.setActionClass("com.horizon.wf.action.ActionStartSubFlow");
inparam.setFunname("subflow");			//实例操作标识
inparam.setActionname("启动子流程");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//可设置业务数据处理类，不设置时流程引擎不处理业务数据
inparam.setBussinessClass("com.horizon.workflow.support.data.BusinessDataOperate");
//如果知道要启动的子流程id，可以直接设置，
//如果不清楚子流程的具体信息，可以先不设置以下的信息，返回子流程列表信息
inparam.setSelectSubFlowid("xxx");
// 增加子流程程办理人id，key为子流程id
Map<String,String> selectAuthorMap = inparam.getSelectAuthorMap();
selectAuthorMap.put("subflowId ","
HZ28821856ef63420156ef6342a20002/D_HZ28821856ef63420156ef6342a20001 ");
//增加子流程程办理人姓名，key为子流程id
Map<String,String> selectAuthorNameMap = inparam.getSelectAuthorNameMap();
selectAuthorNameMap.put("subflowId", "用户01(测试部门01)");
//执行操作，预提交与后台交互
IWorkResult result = opr.operator(inparam);	  
int cp = result.getResult();
//已经启动过子流程,这时不允许再次启动子流程.
if(cp == StaticVarExtend.F_STATUS_IsHaveSubFlow){   
//获取正在运行的子流程
List< DBRelationSubflow> dBWorkList = result.getSubflowWorks();
}
//需要选择子流程,含已经启动的子流程
else if(cp == StaticVarExtend.F_STATUS_NeedSelSubFlow){
//获得已启动的子流程
List< DBRelationSubflow > dBWorkList = result.getSubflowWorks();
//获得可选择启动的子流程列表,从返回列表选择要启动的子流程，把参数设
//置到iniparam中重新执行操作。
List< INodeSubflow> iXMLSubFlowInfoList = result. getNodeSubflows();
//通过遍历iXMLSubFlowInfoList，获得子流程的Id和子流程名称。
if(iXMLSubFlowInfoList!=null && iXMLSubFlowInfoList.size()>0){
for(int i=0;i<iXMLSubFlowInfoList.size();i++){
IXMLSubFlowInfo subFlowInfo = iXMLSubFlowInfoList.get(i);
//子流程Id
String subFlowId = subFlowInfo.getSubFlowId();
//子流程名称
String subFlowName = subFlowInfo.getSubFlowName(); 			 
}				
}
}
//启动子流程成功
else if(cp == StaticVarExtend.F_STATUS_Success){
 //通过返回值，可以获取启动子流程成功后返回的实例Id以及主流程的实例Id。
 String workid = result. getSubflowWorkResult().getWorkid()
 String parentworkid = result. getWorkid();
}else{//后台自动返回的信息    
    result. getBackMsg();      
}
```
### 认领
```
IWorkflowOperator opr = WorkflowFactory.getWorkflowOperator();	//流程操作对象
WorkParaBean inparam = new WorkParaBean();		//操作参数对象
//1.根据打开的流程实例，从返回值信息获得必要值设置参数
inparam.setUserId(userId);					//当前操作人id
inparam.setWorkId(workId);				//实例id
inparam.setTrackId(trackId);				//路径id
inparam.setNodeId(nodeId);              //当前节点Id
inparam. setTenantCode(tenantCode)       //当前节点Id
inparam.setSubmitflag("0");//是否确认进行操作 0:确认  1:前后台交互
//操作的实现类(全路径)
inparam.setActionClass("com.horizon.wf.action.ActionClaim");
inparam.setFunname("Claim");			//实例操作标识
inparam.setSubjection (deptid);			//部门Id
inparam.setActionname("认领");		//操作名称
inparam.setDataIdentifier("xxx");            //业务数据数据源
inparam.setFlowIdentifier("xxx");            //流程引擎数据源
//执行操作，不需要与后台交互
IWorkResult result = opr.operator(inparam);
int cp = result.getResult();
//操作成功
if(cp == StaticVarExtend.F_STATUS_Success){
}else{//后台自动返回的信息    
   result. getBackMsg();      
} 
```