取消驳回，支持回退

oa-back/ruoyi-flowable/src/main/java/com/ruoyi/flowable/controller/FlowTaskController.java

         return flowTaskService.getNextFlowNodeByStart(flowTaskVo);
     }
 
-    @ApiOperation(value = "判断当前节点是否发起人节点")
-    @PostMapping(value = "/isStartUserNode")
-    public AjaxResult checkIsStartUserNode(@RequestBody FlowTaskVo flowTaskVo) {
-        return flowTaskService.checkIsStartUserNode(flowTaskVo);
-    }
-
-    @ApiOperation(value = "判断登录人是否当前节点人")
-    @PostMapping(value = "/isCurrentNodeAssignee")
-    public AjaxResult getCurrentNodeAssignee(@RequestBody FlowTaskVo flowTaskVo) {
-        return flowTaskService.getCurrentNodeAssignee(flowTaskVo);
-    }
-
     /**
      * 生成流程图
      *

oa-back/ruoyi-flowable/src/main/java/com/ruoyi/flowable/service/IFlowTaskService.java

 
     AjaxResult getNextFlowNodeByStart(FlowTaskVo flowTaskVo);
 
-    /**
-     * 判断当前节点是否发起人节点
-     * @param flowTaskVo 任务
-     * @return
-     */
-    AjaxResult checkIsStartUserNode(FlowTaskVo flowTaskVo);
-
-    /**
-     * 判断登录人是否当前节点人
-     * @param flowTaskVo 任务
-     * @return
-     */
-    AjaxResult getCurrentNodeAssignee(FlowTaskVo flowTaskVo);
-
     /**
      * 流程初始化表单
      * @param deployId

oa-back/ruoyi-flowable/src/main/java/com/ruoyi/flowable/service/impl/FlowTaskServiceImpl.java

 import org.flowable.common.engine.api.FlowableException;
 import org.flowable.common.engine.api.FlowableObjectNotFoundException;
 import org.flowable.common.engine.impl.identity.Authentication;
-import org.flowable.engine.*;
+import org.flowable.engine.ProcessEngineConfiguration;
 import org.flowable.engine.history.HistoricActivityInstance;
 import org.flowable.engine.history.HistoricProcessInstance;
 import org.flowable.engine.history.HistoricProcessInstanceQuery;
         if (Objects.isNull(task)) {
             return AjaxResult.error("任务不存在");
         }
-
         if (DelegationState.PENDING.equals(task.getDelegationState())) {
-            taskService.addComment(taskVo.getTaskId(), taskVo.getInstanceId(), FlowComment.DELEGATE.getType(), taskVo.getComment());
+            taskService.addComment(taskVo.getTaskId(), taskVo.getInstanceId(), FlowComment.DELEGATE.getRemark(), taskVo.getComment());
             taskService.resolveTask(taskVo.getTaskId(), taskVo.getVariables());
         } else {
-            //如果pass变量是通过，存入流程任务变量表
-            if (Objects.nonNull(taskVo.getVariables().get("pass")) && taskVo.getVariables().get("pass").equals("通过")) {
-                runtimeService.setVariable(task.getExecutionId(), "pass", taskVo.getVariables().get("pass"));
-                taskService.addComment(taskVo.getTaskId(), taskVo.getInstanceId(), FlowComment.NORMAL.getRemark(), taskVo.getComment());
-            }
-            else {
-                taskService.addComment(taskVo.getTaskId(), taskVo.getInstanceId(), FlowComment.REJECT.getRemark(), taskVo.getComment());
-                Long userId = SecurityUtils.getLoginUser().getUser().getUserId();
-                taskService.setAssignee(taskVo.getTaskId(), userId.toString());
-                taskService.complete(taskVo.getTaskId(), taskVo.getVariables());
-            }
+            taskService.addComment(taskVo.getTaskId(), taskVo.getInstanceId(), FlowComment.NORMAL.getRemark(), taskVo.getComment());
+            Long userId = SecurityUtils.getLoginUser().getUser().getUserId();
+            taskService.setAssignee(taskVo.getTaskId(), userId.toString());
+            taskService.complete(taskVo.getTaskId(), taskVo.getVariables());
         }
-
         return AjaxResult.success();
     }
 
             runtimeService.createChangeActivityStateBuilder()
                     .processInstanceId(task.getProcessInstanceId())
                     .moveActivityIdsToSingleActivityId(currentIds, flowTaskVo.getTargetKey()).changeState();
+            String currentTaskId = taskService.createTaskQuery().singleResult().getId();
+            List<HistoricTaskInstance> htiList = historyService.createHistoricTaskInstanceQuery()
+                    .processInstanceId(task.getProcessInstanceId()).taskDefinitionKey(flowTaskVo.getTargetKey())
+                    .list();
+            String taskAssignee = "";
+            for (HistoricTaskInstance hti: htiList) {
+                if (!hti.getId().equals(currentTaskId)) {
+                    taskAssignee = hti.getAssignee();
+                    break;
+                }
+            }
+            taskService.setAssignee(currentTaskId, taskAssignee);
         } catch (FlowableObjectNotFoundException e) {
             throw new CustomException("未找到流程实例，流程可能已发生变化");
         } catch (FlowableException e) {
      * @param flowTaskVo 任务
      * @return
      */
-    public AjaxResult checkIsStartUserNode(FlowTaskVo flowTaskVo) {
+    public boolean checkIsStartUserNode(FlowTaskVo flowTaskVo) {
         //判断当前是否是第一个发起任务节点，若是就put变量isStartNode为True,让相应的表单可以编辑
         boolean isStartNode= false;
         // 当前任务 task
                 }
             }
         }
-        return AjaxResult.success(isStartNode);
+        return isStartNode;
     }
-
-    /**
-     * 判断登录人是否当前节点人
-     *
-     * @param flowTaskVo 任务
-     * @return
-     */
-    public AjaxResult getCurrentNodeAssignee(FlowTaskVo flowTaskVo) {
-        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
-        TaskService taskService = processEngine.getTaskService();
-        String assignee = taskService.createTaskQuery().taskId(flowTaskVo.getTaskId()).singleResult().getAssignee();
-        return AjaxResult.success(Objects.equals(assignee, SecurityUtils.getLoginUser().getUser().getUserId().toString()));
-    }
-
     /**
      * 流程初始化表单
      *
                 Map<String, Object> newParameters = JSON.parseObject(JSON.toJSONString(parameters.get("variables")), Map.class);
                 FlowTaskVo flowTaskVo = new FlowTaskVo();
                 flowTaskVo.setTaskId(taskId);
-//                newParameters.put("disabled", !((Boolean) checkIsStartUserNode(flowTaskVo).get("data")));
+//                newParameters.put("disabled", !checkIsStartUserNode(flowTaskVo));
                 result.put("formData", newParameters);
                 return AjaxResult.success("", result);
             }

oa-ui/src/api/flowable/todo.js

   })
 }
 
-// 判断当前节点是否发起人节点
-export function checkIsStartUserNode(data) {
-  return request({
-    url: '/flowable/task/isStartUserNode',
-    method: 'post',
-    data: data
-  })
-}
-
-// 判断登录人是否当前节点人
-export function getCurrentNodeAssignee(data) {
-  return request({
-    url: '/flowable/task/isCurrentNodeAssignee',
-    method: 'post',
-    data: data
-  })
-}
-
 // 部署流程实例
 export function deployStart(deployId) {
   return request({

oa-ui/src/views/flowable/form/scTable.vue

       </tr>
     </table>
     <el-row justify="center" type="flex" style="margin-top:20px;"
-      v-if="tableForm.taskName == undefined || tableForm.taskName == '员工修改'">
+      v-if="tableForm.taskName == undefined || tableForm.taskName == '员工填报'">
       <el-button type="primary" @click="submit">提交</el-button>
       <el-button>取消</el-button>
     </el-row>
             this.form['role' + i] = this.tableForm['role' + i]
         }
       }
-      if (this.tableForm.taskName == '项目负责人审核') {
+      if (this.tableForm.taskName == '负责人审核') {
         this.isPiLeader = true;
         this.isDeptLeader = false;
         this.isManager = false;
         this.isDeptLeader = true;
         this.isManager = false;
         this.isStaff = false;
-      } else if (this.tableForm.taskName == '分管领导审核') {
+      } else if (this.tableForm.taskName == '分管审核') {
         this.isPiLeader = false;
         this.isDeptLeader = false;
         this.isManager = true;
         this.isStaff = false;
-      } else if (this.tableForm.taskName == '员工修改') {
+      } else if (this.tableForm.taskName == '员工填报') {
         this.isPiLeader = false;
         this.isDeptLeader = false;
         this.isManager = false;

oa-ui/src/views/flowable/task/myProcess/send/index.vue

             this.taskOpen = true;
             this.taskTitle = "选择任务接收";
           } else {
-            const variables = this.formData.valData;
-            const formData = this.formData.formData;
-            formData.disabled = true;
-            formData.formBtns = false;
-            if (this.procDefId) {
-              variables.variables = formData;
-              // 启动流程并将表单数据加入流程变量
-              definitionStart(this.procDefId, JSON.stringify(variables)).then(res => {
+            if (this.formData.formData == undefined) {
+              definitionStart(this.procDefId, { approval: this.checkValues, formId: this.formId }).then(res => {
                 this.$modal.msgSuccess(res.msg);
                 this.goBack();
               })
             }
+            else {
+              const variables = this.formData.valData;
+              const formData = this.formData.formData;
+              formData.disabled = true;
+              formData.formBtns = false;
+              if (this.procDefId) {
+                variables.variables = formData;
+                // 启动流程并将表单数据加入流程变量
+                definitionStart(this.procDefId, JSON.stringify(variables)).then(res => {
+                  this.$modal.msgSuccess(res.msg);
+                  this.goBack();
+                })
+              }
+            }
           }
         }
       })

oa-ui/src/views/flowable/task/todo/detail/index.vue

         <!--表单信息-->
         <el-tab-pane label="表单信息" name="1">
           <ScTable :tableForm="tableForm" @submit="handleComplete"></ScTable>
-          <el-row type="flex" justify="center" v-if="taskName != '员工修改'">
+          <el-row type="flex" justify="center" v-if="taskName != '员工填报'">
             <el-button v-if="!formKeyExist" icon="el-icon-edit-outline" type="success" size="mini"
               @click="handleComplete">审核通过
             </el-button>
-            <!-- <el-button icon="el-icon-refresh-left" type="warning" size="mini" @click="handleReturn">退回</el-button> -->
-            <el-button icon="el-icon-circle-close" type="danger" size="mini" @click="handleReject">驳回</el-button>
+            <el-button icon="el-icon-refresh-left" type="warning" size="mini" @click="handleReturn">退回</el-button>
+            <!-- <el-button icon="el-icon-circle-close" type="danger" size="mini" @click="handleReject">驳回</el-button> -->
           </el-row>
         </el-tab-pane>
         <!--流程流转记录-->
         </span>
       </el-dialog>
       <!--驳回流程-->
-      <el-dialog :title="rejectTitle" :visible.sync="rejectOpen" width="40%" append-to-body>
-        <el-form ref="taskForm" :model="taskForm" label-width="80px">
+      <el-dialog :title="rejectTitle" :visible.sync="rejectOpen" width="60%" append-to-body>
+        <el-form ref="taskForm" :model="taskForm">
+          <el-form-item prop="targetKey">
+            <flow-user v-if="checkSendUser" :checkType="checkType" @handleUserSelect="handleUserSelect"></flow-user>
+          </el-form-item>
           <el-form-item label="驳回意见" prop="comment" :rules="[{ required: true, message: '请输入意见', trigger: 'blur' }]">
             <el-input style="width: 50%" type="textarea" v-model="taskForm.comment" placeholder="请输入意见" />
           </el-form-item>
   </div>
 </template>
 
+
 <script>
 import { flowRecord } from "@/api/flowable/finished";
 import FlowUser from '@/components/flow/User'
   getNextFlowNode,
   delegate,
   flowTaskForm,
-  checkIsStartUserNode
 } from "@/api/flowable/todo";
-import { getAssess, modifyAssess } from '@/api/oa/assess/assess'
 import flow from '@/views/flowable/task/todo/detail/flow'
 import "@riophae/vue-treeselect/dist/vue-treeselect.css";
 import { listUser } from "@/api/system/user";
+import { getAssess, modifyAssess, submitAssess } from '@/api/oa/assess/assess';
 import ScTable from "../../../form/scTable.vue";
-import { submitAssess } from '@/api/oa/assess/assess.js'
-import { MessageBox } from 'element-ui'
 
 export default {
   name: "Record",
         variables: {
           variables: {}
         },
-        check: true
       },
       assignee: null,
       formConf: {}, // 默认表单数据
       let formData = new FormData();
       let form = JSON.stringify(this.tableForm);
       formData.append("form", form);
-      debugger
       this.submitForm(formData);
     },
     /** 用户审批任务 */
         this.$modal.msgError("请选择流程接收角色组!");
         return;
       }
-      this.$delete(this.taskForm.variables, "pass");
+      // if (!this.taskForm.comment) {
+      //   this.$modal.msgError("请输入审批意见!");
+      //   return;
+      // }
       if (this.taskForm && this.formKeyExist) {
         // 表单是否禁用
         this.taskForm.formData.formData.disabled = true;
     handleReject() {
       this.rejectOpen = true;
       this.rejectTitle = "驳回流程";
-      console.log(this.flowRecordList);
-      
     },
     /** 驳回任务 */
     taskReject() {
-      if (this.taskForm.variables === null) {
-        this.taskForm.variables = {};
-      }
-      this.$set(this.taskForm.variables, "pass", "驳回");
-      complete(this.taskForm).then(response => {
-        this.$modal.msgSuccess(response.msg);
-        this.goBack();
+      this.$refs["taskForm"].validate(valid => {
+        if (valid) {
+          rejectTask(this.taskForm).then(res => {
+            this.$modal.msgSuccess(res.msg);
+            this.goBack();
+          });
+        }
       });
-      // this.$refs["taskForm"].validate(valid => {
-      //   if (valid) {
-      //     rejectTask(this.taskForm).then(res => {
-      //       this.$modal.msgSuccess(res.msg);
-      //       this.goBack();
-      //     });
-      //   }
-      // });
     },
     /** 可退回任务列表 */
     handleReturn() {
       if (this.taskForm.variables === null) {
         this.taskForm.variables = {};
       }
-      //排他网关，表达式，多节点情况下，审核通过，先将流程表达式pass变量存入，便于查找流程下一节点
-      this.$set(this.taskForm.variables, "pass", "通过");
-      complete(this.taskForm).then(response => {
-        const params = { taskId: this.taskForm.taskId }
-        // 根据当前任务或者流程设计配置的下一步节点 todo 暂时未涉及到考虑网关、表达式和多节点情况（todo已在上一步实现）
-        getNextFlowNode(params).then(res => {
-          const data = res.data;
-          debugger
-          this.taskForm.formData = formData;
-          if (data) {
-            if (data.dataType === 'dynamic') {
-              if (data.type === 'assignee') { // 指定人员
-                this.checkSendUser = true;
-                this.checkType = "single";
-              } else if (data.type === 'candidateUsers') {  // 候选人员(多个)
-                this.checkSendUser = true;
-                this.checkType = "multiple";
-              } else if (data.type === 'candidateGroups') { // 指定组(所属角色接收任务)
-                this.checkSendRole = true;
-              } else { // 会签
-                // 流程设计指定的 elementVariable 作为会签人员列表
-                this.multiInstanceVars = data.vars;
-                this.checkSendUser = true;
-                this.checkType = "multiple";
-              }
+      // 根据当前任务或者流程设计配置的下一步节点 todo 暂时未涉及到考虑网关、表达式和多节点情况
+      const params = { taskId: this.taskForm.taskId }
+      getNextFlowNode(params).then(res => {
+        const data = res.data;
+        this.taskForm.formData = formData;
+        if (data) {
+          if (data.dataType === 'dynamic') {
+            if (data.type === 'assignee') { // 指定人员
+              this.checkSendUser = true;
+              this.checkType = "single";
+            } else if (data.type === 'candidateUsers') {  // 候选人员(多个)
+              this.checkSendUser = true;
+              this.checkType = "multiple";
+            } else if (data.type === 'candidateGroups') { // 指定组(所属角色接收任务)
+              this.checkSendRole = true;
+            } else { // 会签
+              // 流程设计指定的 elementVariable 作为会签人员列表
+              this.multiInstanceVars = data.vars;
+              this.checkSendUser = true;
+              this.checkType = "multiple";
             }
           }
-          this.completeOpen = true;
-          this.completeTitle = "选择下一节点审核人";
-        })
-      });
+        }
+        this.completeOpen = true;
+        this.completeTitle = "选择下一节点审核人";
+      })
     },
   },
 };
 <style lang="scss" scoped>
 .test-form {
   margin: 15px auto;
-  // width: 800px;
-  padding: 20px;
+  width: 800px;
+  padding: 15px;
 }
 
 .clearfix:before,