vue2-client 1.15.14 → 1.15.15

package/src/pages/WorkflowDetail/WorkflowPageDetail/WorkFlowHandle.vue

@@ -90,6 +90,40 @@
               @x-form-item-emit-func="formItemEmitFunc"
               @onSubmit="submitForm"/>
             <a-divider/>
+
+            <!-- 分支节点状态提示 -->
+            <a-alert
+              v-if="isBranchLastNode.isBranchNode && !isBranchLastNode.isLastBranch"
+              type="info"
+              show-icon
+              style="margin-bottom: 16px"
+            >
+              <template slot="message">
+                <span style="font-weight: bold;">分支节点等待中</span>
+              </template>
+              <template slot="description">
+                <div>当前为分支节点，其他分支仍在进行中。完成当前分支后将等待其他分支完成，然后自动汇合到下一环节。</div>
+                <div style="margin-top: 8px; color: #666; font-size: 12px;">
+                  <a-icon type="info-circle" style="margin-right: 4px;" />
+                  提示：此操作无需选择下一环节负责人，系统将自动处理流程流转。
+                </div>
+              </template>
+            </a-alert>
+
+            <a-alert
+              v-if="isBranchLastNode.isBranchNode && isBranchLastNode.isLastBranch"
+              type="success"
+              show-icon
+              style="margin-bottom: 16px"
+            >
+              <template slot="message">
+                <span style="font-weight: bold;">分支汇合节点</span>
+              </template>
+              <template slot="description">
+                <div>您正在处理最后一个未完成的分支节点，完成后将触发分支汇合并进入下一环节。</div>
+              </template>
+            </a-alert>
+
             <a-form v-show="!lastStep" label-align="left" :label-col="{ span: 3 }" :wrapper-col="{ span: 13 }">
               <a-form-item v-if="showStepNextBtn" label="操作类型" required>
                 <a-radio-group v-model="operationType" @change="handleOperationTypeChange">
@@ -97,9 +131,14 @@
                   <a-radio value="skip">{{ stepNextBtnTitle }}</a-radio>
                 </a-radio-group>
               </a-form-item>
-              <!-- 智能分支人员选择组件 -->
-              <WorkflowPersonSelector ref="personSelector"/>
+
+              <!-- 智能分支人员选择组件 - 只有非分支节点或最后一个分支才显示 -->
+              <WorkflowPersonSelector
+                v-if="!isBranchLastNode.isBranchNode || isBranchLastNode.isLastBranch"
+                ref="personSelector"/>
+
               <a-form-item
+                v-if="!isBranchLastNode.isBranchNode || isBranchLastNode.isLastBranch"
                 label="下一环节截止时间"
                 :validate-status="deadlineValidateStatus"
                 :help="deadlineHelp"
@@ -142,7 +181,13 @@
                   <template>
                     <a-popover v-if="operationType === 'submit'">
                       <template slot="content">
-                        <p>{{ nextBtnTitle }}</p>
+                        <p v-if="isBranchLastNode.isBranchNode && !isBranchLastNode.isLastBranch">
+                          完成当前分支，等待其他分支完成后自动汇合
+                        </p>
+                        <p v-else-if="isBranchLastNode.isBranchNode && isBranchLastNode.isLastBranch">
+                          完成最后一个分支并触发汇合到下一环节
+                        </p>
+                        <p v-else>{{ nextBtnTitle }}</p>
                       </template>
                       <a-button
                         v-show="!lastStep"
@@ -262,6 +307,55 @@ export default {
       return this
     },
     ...mapState('account', { currUser: 'user' }),
+    // 判断当前节点的分支状态
+    isBranchLastNode () {
+      // 默认返回值
+      const defaultResult = {
+        isBranchNode: false, // 是否为分支流程中的节点
+        isLastBranch: false // 是否为最后一个未完成的分支（需要选择下一环节人员）
+      }
+
+      // 如果是最后一步或没有下一步或者不能提交，则不是分支节点
+      if (this.lastStep || !this.nextBtnTo || !this.canSubmit) {
+        return defaultResult
+      }
+
+      // 检查下一个节点是否为分支退出节点
+      const nextStep = this.stepsDefine.find(step => step.id === this.nextBtnTo)
+
+      // 如果下一个节点的flowRole不是branchExit，说明不是分支的最后一个节点
+      if (!nextStep || nextStep.properties?.flowRole !== 'branchExit') {
+        return defaultResult
+      }
+
+      // 获取分支退出节点等待的所有分支步骤ID
+      const waitStepIds = nextStep.properties.waitStepIds || []
+      if (waitStepIds.length === 0) {
+        return {
+          isBranchNode: true,
+          isLastBranch: true // 如果没有等待步骤配置，默认认为是最后一个
+        }
+      }
+
+      // 当前步骤必须在等待列表中才算是分支节点
+      if (!waitStepIds.includes(this.activeStepId)) {
+        return defaultResult
+      }
+
+      // 检查除当前步骤外的其他分支步骤状态
+      const otherBranchSteps = waitStepIds.filter(stepId => stepId !== this.activeStepId)
+
+      // 判断其他所有分支步骤是否都已完成（状态为2）
+      const allOtherBranchesCompleted = otherBranchSteps.every(stepId => {
+        const step = this.stepsForChild.find(s => s.id === stepId)
+        return step && step.status === 2 // 已处理
+      })
+
+      return {
+        isBranchNode: true, // 当前节点是分支流程中的节点
+        isLastBranch: allOtherBranchesCompleted // 只有当其他所有分支都已完成时，当前分支才是最后一个
+      }
+    },
     canSubmit () {
       // 对于超级管理员直接认为可以提交
       if (this.currUser.rolesnames.indexOf('超级管理员') > -1) {
@@ -271,10 +365,9 @@ export default {
       if (!this.currentStepId) {
         return false
       }
-
+      const activeStep = this.stepsForChild.find(item => item.id === this.activeStepId)
       // 如果当前选中节点不是正在进行的节点，则判断viewers权限
-      if (this.activeStepId !== this.currentStepId) {
-        const activeStep = this.stepsForChild.find(item => item.id === this.activeStepId)
+      if (this.activeStepId !== this.currentStepId && activeStep != null && activeStep.status !== 1) {
         // 历史节点为当前登录人操作则不做查看数据权限校验
         if (activeStep.handler === this.currUser.name) {
           return true
@@ -297,7 +390,7 @@ export default {
           return true
         }
       } else {
-        const step = this.stepsForChild.find(item => item.id === this.currentStepId)
+        const step = this.stepsForChild.find(item => item.id === this.activeStepId)
         // 检查角色和部门权限
         if (step && step.properties && step.properties.chargePerson) {
           if (step.properties.chargePerson.personList && step.properties.chargePerson.personList.length > 0) {
@@ -420,8 +513,9 @@ export default {
       // 分支节点相关数据
       branchNodes: [], // 需要选择人员的分支节点列表
       branchChargePersons: {}, // 分支节点人员选择 格式：{stepId: personId}
-      isWfResultBranch: false, // 是否包含WF_RESULT的分支
-      calculatedTargetNode: null // 前台计算出的目标节点
+      needMultipleBranchSelection: false, // 是否需要为多个分支节点预先选择人员（包含WF_RESULT的条件分支或并行分支）
+      calculatedTargetNode: null, // 前台计算出的目标节点
+      currentBranchActions: null // 缓存当前的分支动作，避免重复调用
     }
   },
   async mounted () {
@@ -456,6 +550,17 @@ export default {
     details: {
       type: Object,
       required: true
+    },
+    // 展开详情初始化的节点
+    // 适用于不让第一个节点默认展示的情况
+    initStepId: {
+      type: [String, Number],
+      required: false,
+      default: null
+    },
+    renderCurrentNode: {
+      type: Boolean,
+      default: true
     }
   },
   methods: {
@@ -484,8 +589,9 @@ export default {
       // 清理分支节点相关数据
       this.branchNodes = []
       this.branchChargePersons = {}
-      this.isWfResultBranch = false
+      this.needMultipleBranchSelection = false
       this.calculatedTargetNode = null
+      this.currentBranchActions = null
     },
     async showQueryFormItemFunc () {
       if (this.attr.showQueryFormItemFunc) {
@@ -520,8 +626,15 @@ export default {
         workflowId: this.workflowId
       })
         .then(res => {
-          this.currentStepId = res.id
-          const currentStep = this.stepsForChild.find(item => item.id === res.id)
+          // 优先级：主动传入的 > 获取到的
+          this.currentStepId = this.initStepId || res.id
+
+          // 如果指定了具体节点，同时设置activeStepId
+          if (this.initStepId) {
+            this.activeStepId = this.initStepId
+          }
+
+          const currentStep = this.stepsForChild.find(item => item.id === this.currentStepId)
           res.state = currentStep.name
           // 获取到当前步骤后复制下一步时间
           this.deadline = this.getDefaultDeadline(currentStep.properties?.otherProperty?.nextNodeInterval)
@@ -553,43 +666,73 @@ export default {
             }
           )
         })
+      }).catch(err => {
+        if (err && err.message === 'Form validation failed') {
+          this.$message.error('请检查表单必填项！')
+        } else {
+          // 对于其他错误，继续向上抛出
+          throw err
+        }
       })
     },
     // 三个按钮点击后逻辑
     async nextClick () {
+      // 检查是否为非最后分支节点
+      const branchStatus = this.isBranchLastNode
+      const isWaitingBranch = branchStatus.isBranchNode && !branchStatus.isLastBranch
+
       const extraData = this.getApplyStepExtraData(this.nextBtnTo)
       if (!extraData) {
         return
       }
+
+      // 确认对话框
+      const confirmContent = isWaitingBranch
+        ? '确定完成当前分支么？完成后将等待其他分支，不会立即流转到下一环节。'
+        : '确定提交么？提交之后数据不可更改！'
+
       await new Promise(resolve => {
         this.$confirm({
           title: '提交确认',
-          content: '确定提交么？提交之后数据不可更改！',
+          content: confirmContent,
           onOk () {
             resolve()
             return Promise.resolve()
           }
         })
       })
+
       this.$refs.xAddForm.asyncSubmit().then(res => {
         this.submitForm(res).then(_ => {
           postByServiceName(workFlowViewApi.submitToNextStep, extraData)
             .then(
               () => {
-                const extra = {
-                  setHandler: this.getStepHandler(),
-                  setDeadline: this.deadline,
-                  notes: this.note.trim()
+                let successMessage = '提交成功'
+
+                // 只有非等待分支节点才保存工作流日志
+                if (!isWaitingBranch) {
+                  const branchStatus = this.isBranchLastNode
+                  const operation = branchStatus.isBranchNode && branchStatus.isLastBranch ? '分支汇合' : '提交'
+
+                  const extra = {
+                    setHandler: this.getStepHandler(),
+                    setDeadline: this.deadline,
+                    notes: this.note.trim()
+                  }
+                  this.saveWorkflowLog(operation, this.generateBranchStepChangeText(this.currentStepId), extra)
+                } else {
+                  successMessage = '分支完成，等待其他分支完成后自动汇合'
                 }
-                this.saveWorkflowLog('提交', this.generateStepChangeText(this.currentStepId, this.nextBtnTo), extra)
-                this.$message.success('提交成功')
+
+                this.$message.success(successMessage)
                 this.loading = true
                 this.loadingHistory = true
                 this.$emit('nextClick', {
                   note: this.note.trim(),
                   form: res.realForm,
                   workflowId: this.workflowId,
-...this.generateStepChange(this.currentStepId, this.nextBtnTo)
+                  isBranchWaiting: isWaitingBranch, // 标记是否为分支等待状态
+                  ...this.generateStepChange(this.currentStepId, this.nextBtnTo)
                 })
                 this.$emit('refresh')
                 this.onClose()
@@ -601,6 +744,13 @@ export default {
               }
             )
         })
+      }).catch((err) => {
+        if (err && err.message === 'Form validation failed') {
+          this.$message.error('请检查表单必填项！')
+        } else {
+          // 对于其他错误，继续向上抛出
+          throw err
+        }
       })
     },
     async preClick () {
@@ -645,13 +795,13 @@ export default {
                   setDeadline: this.deadline,
                   notes: this.note.trim()
                 }
-                this.saveWorkflowLog('跳过', this.generateStepChangeText(this.currentStepId, this.stepNextBtnTo), extra)
+                this.saveWorkflowLog('跳过', this.generateBranchStepChangeText(this.currentStepId), extra)
                 this.$message.success('提交成功')
                 this.$emit('nextClick', {
                   note: this.note.trim(),
                   form: res.realForm,
                   workflowId: this.workflowId,
-...this.generateStepChange(this.currentStepId, this.stepNextBtnTo)
+                  ...this.generateStepChange(this.currentStepId, this.stepNextBtnTo)
                 })
                 this.loading = true
                 this.loadingHistory = true
@@ -665,6 +815,13 @@ export default {
               }
             )
         })
+      }).catch(err => {
+        if (err && err.message === 'Form validation failed') {
+          this.$message.error('请检查表单必填项！')
+        } else {
+          // 对于其他错误，继续向上抛出
+          throw err
+        }
       })
     },
     // 获取当前步骤节点，连通的节点
@@ -674,7 +831,6 @@ export default {
         id: this.workflowId
       })
         .then(async res => {
-          res = JSON.parse(res.value)
           this.directions = []
           this.stepsDefine = res.steps
           await this.resolveDirections()
@@ -685,7 +841,7 @@ export default {
     },
     // 分析当前节点，能通向的节点
     async resolveDirections () {
-      const currentStep = this.stepsForChild.find(item => item.id === this.currentStepId)
+      const currentStep = this.stepsForChild.find(item => item.id === this.activeStepId)
       if (currentStep?.properties?.actions) {
         this.currentDirections = currentStep.properties.actions
       }
@@ -706,6 +862,10 @@ export default {
     getStepNameByStepId (stepId) {
       return this.stepsDefine.find(item => item.id === stepId)?.name
     },
+    // 根据步骤id获取步骤状态
+    getStepStatusByStepId (stepId) {
+      return this.stepsForChild.find(item => item.id === stepId)?.status
+    },
     // 表单提交的回调
     submitForm (obj) {
       this.formValid = true
@@ -713,7 +873,7 @@ export default {
       const time = this.format(new Date(), 'yyyy-MM-dd hh:mm:ss')
       return postByServiceName(workFlowViewApi.saveWorkFlowStepFormData, {
         workflowId: this.workflowId,
-        stepId: this.currentStepId,
+        stepId: this.activeStepId,
         form: formData,
         data: time,
         handler: this.currUser.name,
@@ -733,8 +893,8 @@ export default {
         )
     },
     // 获取当前步骤定义内容，构建组件
-    buildComp () {
-      const properties = this.stepsDefine.find(item => item.id === this.currentStep.id).properties
+    async buildComp (stepId) {
+      const properties = this.stepsDefine.find(item => item.id === stepId).properties
       // 表单的渲染
       if (properties.form && properties.form.formJson) {
         this.stepDefine = properties.form.formJson
@@ -753,11 +913,10 @@ export default {
       }
       // Tab的渲染
       this.tabDesigner = properties.tabDesigner
-      if (this.tabDesigner) {
-        this.showTab = true
-      } else {
-        this.showTab = false
-      }
+      this.showTab = !!this.tabDesigner
+      // 以当前激活节点分析节点
+      await this.resolveDirections()
+      this.resolveStep()
     },
     // 根据当前节点，判断之后流程，以及按钮的显示
     workflowControl () {
@@ -835,7 +994,7 @@ export default {
     // 加载完成
     resolveStep () {
       // 获取当前步骤的按钮组配置
-      const currentStep = this.stepsDefine.find(item => item.id === this.currentStepId)
+      const currentStep = this.stepsDefine.find(item => item.id === this.activeStepId)
       if (currentStep && currentStep.properties && currentStep.properties.buttonGroup) {
         this.buttonGroup = currentStep.properties.buttonGroup
       } else {
@@ -845,18 +1004,18 @@ export default {
     },
     // 流程图组件给当前组件传值用，stepNo为用户点击的非当前步骤
     async activeStep (stepId) {
-      console.log('activeStep', stepId)
       // 开启加载
       this.loadingHistory = true
       this.activeStepId = stepId
       // 获取激活节点的步骤名
       this.activeStepName = this.getStepNameByStepId(stepId)
+      const status = this.getStepStatusByStepId(stepId)
       // 清空回显数据
       this.formCompletedData = {}
       let formCompletedDataPreview = null
       this.getStepDefine(stepId)
-      // 判断激活的节点，是不是待完成节点
-      if (this.activeStepName !== this.currentStep.state || this.workflowState) {
+      // 判断激活的节点，是不是待完成节点 (当前节点或者 当前节点状态是1的)
+      if ((this.activeStepName !== this.currentStep.state && status !== 1) || this.workflowState) {
         // 获取激活节点历史数据，和字段定义
         await this.getCompletedFormData(stepId)
         // 将回显数据拷贝，避免引用传递
@@ -914,7 +1073,13 @@ export default {
       } else {
         this.loadingHistory = false
         this.beforeStepActive = false
-        this.buildComp()
+        if (!this.renderCurrentNode) {
+          this.formCompletedDataPreview = null
+          this.showTab = false
+          this.beforeStepActive = true
+          return
+        }
+        await this.buildComp(this.activeStepId)
       }
     },
     // 获取已经完成步骤的数据
@@ -937,15 +1102,14 @@ export default {
       const stepName = this.getStepNameByStepId(stepId)
       this.targetStepDefine = this.getSingleStepDefine(stepName).formJson
     },
-    // 获取指定步骤额外数据
+    // 获取提交步骤的额外数据
     getApplyStepExtraData (stepId) {
-      // if (!this.checkDeadline(true)) {
-      //   return false
-      // }
+      // 验证人员选择 - 只有在需要显示人员选择器的情况下才验证
+      // 判断条件与模板中的 WorkflowPersonSelector 显示条件保持一致
+      const shouldShowPersonSelector = !this.isBranchLastNode.isBranchNode || this.isBranchLastNode.isLastBranch
 
-      // 验证人员选择
-      if (this.needSelectPerson) {
-        if (this.isWfResultBranch) {
+      if (shouldShowPersonSelector && this.needSelectPerson) {
+        if (this.needMultipleBranchSelection) {
           // 多分支情况：检查是否所有需要的分支都选择了人员
           const missingSelections = this.branchNodes.filter(node => !this.branchChargePersons[node.stepId])
           if (missingSelections.length > 0) {
@@ -962,35 +1126,66 @@ export default {
         }
       }
 
-      const stepHandler = this.getStepHandler()
+      // 统一获取目标步骤IDs
+      let stepIds = []
+      if (this.needMultipleBranchSelection) {
+        // 多分支选择：获取所有分支的目标stepId（包括不需要选择人员的）
+        if (!this.currentBranchActions) {
+          this.currentBranchActions = this.getBranchActions()
+        }
+        stepIds = this.currentBranchActions.allBranchActions.map(action => action.to)
+      } else if (this.calculatedTargetNode) {
+        // 条件判断节点：使用计算出的目标节点
+        stepIds = [this.calculatedTargetNode]
+      } else {
+        // 普通节点：使用传入的stepId
+        stepIds = [stepId]
+      }
+      // 处理bug 有的时候没带到 branchChargePersons 先循环在同一地方处理
+      stepIds.forEach(stepItemId => {
+        if (!this.branchChargePersons[stepItemId]) {
+          const chargePerson = this.stepsForChild.find(item => item.id === stepItemId)?.properties?.chargePerson
+          this.branchChargePersons[stepItemId] = this.normalizeChargePersonFormat(chargePerson)
+        }
+      })
 
       return {
         workflowId: this.workflowId,
-        stepId,
+        activeStepId: this.activeStepId,
+        stepId, // 当前步骤ID
+        stepIds, // 目标步骤IDs数组（统一格式）
         name: this.getStepNameByStepId(stepId),
-        handler: stepHandler,
+        handler: this.getStepHandler(),
         handlerId: this.checkedChargePerson,
         needSelectPerson: this.needSelectPerson,
         personList: this.chargePerson.personList,
         deadline: this.deadline,
         submitUser: this.currUser.name,
         submitUserId: this.currUser.id,
-        // 新增：分支节点信息
         branchChargePersons: this.branchChargePersons
       }
     },
+
     // 获取当前选择的负责人
     getStepHandler () {
       let stepHandler
 
-      if (this.isWfResultBranch) {
-        // 多分支情况：返回所有已选择的人员信息
+      if (this.needMultipleBranchSelection) {
+        // 多分支情况：返回所有分支的人员信息
         const selectedHandlers = []
         for (const node of this.branchNodes) {
-          const personId = this.branchChargePersons[node.stepId]
-          if (personId) {
+          const branchData = this.branchChargePersons[node.stepId]
+
+          if (node.needSelectPerson && branchData) {
+            // 需要选择人员的分支：显示选中的人员
             const personName = this.getBranchPersonName(node.stepId)
             selectedHandlers.push(`${node.stepName}:${personName}`)
+          } else if (!node.needSelectPerson && branchData) {
+            // 不需要选择人员的分支：显示角色/部门配置
+            if (branchData.personList && branchData.personList.length > 0) {
+              const personNames = branchData.personList.map(item => item.name).join(',')
+              selectedHandlers.push(`${node.stepName}:${personNames}`)
+            }
           }
         }
         stepHandler = selectedHandlers.join(';')
@@ -1020,18 +1215,58 @@ export default {
     },
     // 生成工作流日志步骤变化描述
     generateStepChangeText (fromStepId, toStepId) {
-      return `第${fromStepId}步: ${this.getStepNameByStepId(fromStepId)} --> 第${toStepId}步: ${this.getStepNameByStepId(toStepId)}`
+      // 如果是多分支场景，toStepId可能是数组或字符串
+      if (this.needMultipleBranchSelection && Array.isArray(toStepId)) {
+        const targetSteps = toStepId.map(id => `第${id}步: ${this.getStepNameByStepId(id)}`).join('、')
+        return `第${fromStepId}步: ${this.getStepNameByStepId(fromStepId)} --> ${targetSteps}`
+      } else if (this.needMultipleBranchSelection && typeof toStepId === 'string') {
+        // 如果传入的是目标步骤名称字符串
+        return `第${fromStepId}步: ${this.getStepNameByStepId(fromStepId)} --> ${toStepId}`
+      } else {
+        // 单步骤场景
+        return `第${fromStepId}步: ${this.getStepNameByStepId(fromStepId)} --> 第${toStepId}步: ${this.getStepNameByStepId(toStepId)}`
+      }
     },
+
+    // 生成多分支场景的步骤变化描述
+    generateBranchStepChangeText (fromStepId) {
+      if (!this.needMultipleBranchSelection) {
+        return this.generateStepChangeText(fromStepId, this.nextBtnTo)
+      }
+
+      // 使用所有分支节点生成描述
+      const targetSteps = this.branchNodes.map(node => `第${node.stepId}步: ${node.stepName}`).join('、')
+      return `第${fromStepId}步: ${this.getStepNameByStepId(fromStepId)} --> ${targetSteps}`
+    },
+
     generateStepChange (fromStepId, toStepId) {
+      // 获取目标步骤IDs数组
+      let stepIds = []
+
+      if (this.needMultipleBranchSelection) {
+        // 多分支选择：获取所有分支的目标stepId（包括不需要选择人员的）
+        if (!this.currentBranchActions) {
+          this.currentBranchActions = this.getBranchActions()
+        }
+        stepIds = this.currentBranchActions.allBranchActions.map(action => action.to)
+      } else if (this.calculatedTargetNode) {
+        // 条件判断节点：使用计算出的目标节点
+        stepIds = [this.calculatedTargetNode]
+      } else {
+        // 普通节点：使用传入的stepId
+        stepIds = [toStepId]
+      }
+
       return {
         formStepId: fromStepId,
         fromStepId,
-        toStepId,
+        stepId: toStepId,
+        stepIds: stepIds,
         formStep: this.getStepNameByStepId(fromStepId),
         fromStep: this.getStepNameByStepId(fromStepId),
-        toStep: this.getStepNameByStepId(toStepId),
+        toStep: this.getStepNameByStepId(stepIds[0]),
         successStepId: this.stepsDefine[this.stepsDefine.length - 1].id,
-        successStep: this.stepsDefine[this.stepsDefine.length - 1].name,
+        successStep: this.stepsDefine[this.stepsDefine.length - 1].name
       }
     },
     // 保存工作流日志
@@ -1129,26 +1364,73 @@ export default {
 
     // 分析分支节点并设置选择框
     async analyzeBranchNodes () {
-      const conditionalActions = this.currentDirections.filter(action => action.type === 'conditionalBranch')
-      // 如果没有分支节点，处理普通单线流程
-      if (conditionalActions.length === 0) {
-        this.branchNodes = []
-        this.isWfResultBranch = false
+      try {
+        // 初始化状态
+        this.resetBranchSelection()
+
+        // 获取所有类型的分支动作并缓存
+        this.currentBranchActions = this.getBranchActions()
+
+        // 如果没有任何分支，处理普通流程
+        if (!this.currentBranchActions.hasAnyBranch) {
+          await this.handleNormalFlow()
+          return
+        }
+
+        // 判断是否需要多分支选择
+        this.needMultipleBranchSelection = this.shouldUseMultipleBranchSelection(this.currentBranchActions)
 
+        if (this.needMultipleBranchSelection) {
+          // 需要为多个分支预先选择人员
+          await this.setupMultipleBranchSelection(this.currentBranchActions.allBranchActions)
+        } else {
+          // 可以前台实时计算的条件分支
+          await this.calculateTargetNodeFromForm(this.currentBranchActions.conditionalActions)
+        }
+      } catch (error) {
+        console.error('分析分支节点失败:', error)
+        this.$message.error('工作流分支配置异常，请联系管理员')
+        // 降级处理：使用普通流程
         await this.handleNormalFlow()
-        return
       }
+    },
 
-      this.isWfResultBranch = this.checkIfContainsWfResult()
+    // 重置分支选择状态
+    resetBranchSelection () {
+      this.branchNodes = []
+      this.branchChargePersons = {}
+      this.needMultipleBranchSelection = false
+      this.calculatedTargetNode = null
+      this.currentBranchActions = null
+    },
 
-      if (this.isWfResultBranch) {
-        // 包含WF_RESULT，需要显示所有可能分支的人员选择
-        await this.setupMultipleBranchSelection(conditionalActions)
-      } else {
-        this.branchNodes = []
-        // 不包含WF_RESULT，可以前台实时计算
-        await this.calculateTargetNodeFromForm(conditionalActions)
+    // 获取分支动作分类
+    getBranchActions () {
+      const conditionalActions = this.currentDirections.filter(action => action.type === 'conditionalBranch')
+      const parallelActions = this.currentDirections.filter(action => action.type === 'parallelBranch')
+      const allBranchActions = [...conditionalActions, ...parallelActions]
+
+      return {
+        conditionalActions,
+        parallelActions,
+        allBranchActions,
+        hasAnyBranch: allBranchActions.length > 0
+      }
+    },
+
+    // 判断是否应该使用多分支选择模式
+    shouldUseMultipleBranchSelection (branchActions) {
+      // 情况1: 有并行分支
+      if (branchActions.parallelActions.length > 0) {
+        return true
+      }
+
+      // 情况2: 条件分支包含WF_RESULT（后台结果决定）
+      if (branchActions.conditionalActions.length > 0) {
+        return this.checkIfContainsWfResult()
       }
+
+      return false
     },
 
     // 根据表单数据计算目标节点
@@ -1157,7 +1439,17 @@ export default {
         conditionalActions = this.currentDirections.filter(action => action.type === 'conditionalBranch')
       }
 
-      if (conditionalActions.length === 0) return
+      if (conditionalActions.length === 0) {
+        // 如果当前节点不是在分支流程中，才清空人员选择
+        // 避免在并行分支节点中误清除人员选择框
+        const currentStep = this.stepsForChild.find(item => item.id === this.activeStepId)
+        const isInBranch = currentStep?.properties?.branchPath
+
+        if (!isInBranch) {
+          this.clearPersonSelection()
+        }
+        return
+      }
 
       try {
         const formData = this.$refs.xAddForm?.form || {}
@@ -1168,32 +1460,56 @@ export default {
             const result = await this.evaluateExpression(action.expression, formData)
             if (result) {
               this.calculatedTargetNode = action.to
-              // 设置对应节点的人员选择
-              const stepDefine = this.stepsDefine.find(step => step.id === action.to)
-              if (stepDefine?.properties?.chargePerson?.needSelectPerson) {
-                this.chargePerson = stepDefine?.properties?.chargePerson
-                this.checkedChargePerson = undefined
-                this.chargePersonOptions = await this.getChargePersonOptionsForStep(action.to)
-                // 如果只有一个选项，自动选中
-                if (this.chargePersonOptions.length === 1) {
-                  this.checkedChargePerson = this.chargePersonOptions[0].value
-                }
-                this.needSelectPerson = true
-              } else {
-                this.needSelectPerson = false
-                this.chargePersonOptions = []
-              }
+              await this.setupSingleTargetPersonSelection(action.to)
               return
             }
           }
         }
+        console.log('this.calculatedTargetNode', this.calculatedTargetNode)
         // 如果没有匹配的条件，清空选择
-        this.calculatedTargetNode = null
-        this.needSelectPerson = false
-        this.chargePersonOptions = []
+        this.clearPersonSelection()
       } catch (error) {
         console.warn('计算目标节点失败:', error)
-        this.calculatedTargetNode = null
+        this.clearPersonSelection()
+      }
+    },
+
+    // 清空人员选择
+    clearPersonSelection () {
+      this.calculatedTargetNode = null
+      this.needSelectPerson = false
+      this.chargePersonOptions = []
+      this.checkedChargePerson = undefined
+    },
+
+    // 设置单个目标节点的人员选择
+    async setupSingleTargetPersonSelection (stepId) {
+      const stepDefine = this.stepsDefine.find(step => step.id === stepId)
+
+      if (!stepDefine?.properties?.chargePerson?.needSelectPerson) {
+        this.needSelectPerson = false
+        this.chargePersonOptions = []
+        return
+      }
+
+      // 设置人员选择
+      this.chargePerson = stepDefine.properties.chargePerson
+      this.checkedChargePerson = undefined
+      this.chargePersonOptions = await this.getChargePersonOptionsForStep(stepId)
+
+      // 如果只有一个选项，自动选中
+      if (this.chargePersonOptions.length === 1) {
+        this.checkedChargePerson = this.chargePersonOptions[0].value
+      }
+
+      this.needSelectPerson = true
+    },
+
+    // 表单数据变化处理函数（将通过provide传递给表单组件）
+    async handleFormDataChange (formData) {
+      // 只有在不是多分支选择模式且当前活动步骤有条件分支动作时才重新计算
+      if (!this.needMultipleBranchSelection && this.currentDirections.some(action => action.type === 'conditionalBranch')) {
+        await this.calculateTargetNodeFromForm()
       }
     },
 
@@ -1220,8 +1536,22 @@ export default {
       if (!define?.properties?.chargePerson) return []
 
       const chargePerson = define.properties.chargePerson
-      this.chargePerson = chargePerson
-      // 如果是旧的格式 转换成新的格式
+      this.chargePerson = this.normalizeChargePersonFormat(chargePerson)
+
+      if (!chargePerson.needSelectPerson || !chargePerson.personList) return []
+
+      // 获取所有用户信息
+      const allUser = await postByServiceName(commonApi.getAllUserOptionList, {})
+
+      // 根据配置筛选用户
+      const options = this.filterUsersByPersonConfig(chargePerson.personList, allUser)
+
+      // 去重处理
+      return Array.from(new Map(options.map(item => [item.value, item])).values())
+    },
+
+    // 标准化人员配置格式（兼容旧格式）
+    normalizeChargePersonFormat (chargePerson) {
       if (chargePerson.role || chargePerson.department) {
         chargePerson.needSelectPerson = true
         chargePerson.personList = [{
@@ -1229,25 +1559,23 @@ export default {
           name: chargePerson.role || chargePerson.department
         }]
       }
+      return chargePerson
+    },
 
-      if (!chargePerson.needSelectPerson || !chargePerson.personList) return []
-
-      // 获取所有用户信息
-      const allUser = await postByServiceName(commonApi.getAllUserOptionList, {})
-
-      // 使用reduce累积结果
-      const options = chargePerson.personList.reduce((acc, personItem) => {
+    // 根据人员配置筛选用户
+    filterUsersByPersonConfig (personList, allUsers) {
+      return personList.reduce((acc, personItem) => {
         let filteredUsers = []
 
         if (personItem.type === 'role') {
-          filteredUsers = allUser.filter(user =>
+          filteredUsers = allUsers.filter(user =>
             user.rolestr && user.rolestr.split(',').includes(personItem.name)
           ).map(user => ({
             label: user.label,
             value: user.value
           }))
         } else if (personItem.type === 'department') {
-          filteredUsers = allUser.filter(user =>
+          filteredUsers = allUsers.filter(user =>
             user.depname === personItem.name
           ).map(user => ({
             label: user.label,
@@ -1257,84 +1585,83 @@ export default {
 
         return [...acc, ...filteredUsers]
       }, [])
-
-      // 去重处理
-      return Array.from(new Map(options.map(item => [item.value, item])).values())
     },
 
-    // 设置多分支人员选择（包含WF_RESULT的情况）
-    async setupMultipleBranchSelection (conditionalActions) {
+    // 设置多分支人员选择
+    async setupMultipleBranchSelection (branchActions) {
       this.branchNodes = []
       this.branchChargePersons = {}
+      let hasPersonSelection = false
 
-      for (const action of conditionalActions) {
+      for (const action of branchActions) {
         const stepDefine = this.stepsDefine.find(step => step.id === action.to)
-        if (stepDefine?.properties?.chargePerson?.needSelectPerson) {
-          // 都使用多分支了 肯定是新数据 那么不用做兼容处理
-          this.chargePerson = stepDefine?.properties?.chargePerson
-          // 获取这个节点的人员选项
+        const chargePerson = stepDefine?.properties?.chargePerson
+
+        // 所有分支节点都加入branchNodes，保持数据结构完整
+        const nodeData = {
+          stepId: action.to,
+          stepName: this.getStepNameByStepId(action.to),
+          chargePerson: chargePerson,
+          needSelectPerson: chargePerson?.needSelectPerson || false,
+          chargePersonOptions: []
+        }
+
+        if (chargePerson?.needSelectPerson) {
+          // 需要选择人员的分支
           const chargePersonOptions = await this.getChargePersonOptionsForStep(action.to)
+          nodeData.chargePersonOptions = chargePersonOptions
 
-          this.branchNodes.push({
-            stepId: action.to,
-            stepName: this.getStepNameByStepId(action.to),
-            chargePerson: stepDefine.properties.chargePerson,
-            chargePersonOptions: chargePersonOptions
-          })
           // 初始化选择值
           this.branchChargePersons[action.to] = undefined
+          hasPersonSelection = true
         } else {
-          this.branchChargePersons[action.to] = stepDefine?.properties?.chargePerson
+          // 不需要选择人员的分支，直接存储配置
+          this.branchChargePersons[action.to] = chargePerson
         }
+
+        this.branchNodes.push(nodeData)
       }
 
-      // 如果没有需要选择人员的分支，隐藏选择区域
-      this.needSelectPerson = this.branchNodes.length > 0
+      // 只有当存在需要选择人员的分支时才显示选择区域
+      this.needSelectPerson = hasPersonSelection
     },
 
     // 处理普通单线流程（没有分支的情况）
     async handleNormalFlow () {
-      let targetStepId = this.nextBtnTo
-      if (this.operationType === 'skip') {
-        targetStepId = this.stepNextBtnTo
-      }
+      const targetStepId = this.operationType === 'skip' ? this.stepNextBtnTo : this.nextBtnTo
 
       this.calculatedTargetNode = targetStepId
       const stepDefine = this.stepsDefine.find(step => step.id === targetStepId)
+
+      if (!stepDefine) {
+        console.warn('未找到目标步骤定义:', targetStepId)
+        this.clearPersonSelection()
+        return
+      }
+
       const defineProperties = stepDefine.properties
       this.chargePerson = defineProperties?.chargePerson
-      if (defineProperties.chargePerson?.role || defineProperties.chargePerson?.department) {
-        defineProperties.chargePerson.needSelectPerson = true
-        defineProperties.chargePerson.personList = [{
-          type: defineProperties.chargePerson.role ? 'role' : 'department',
-          name: defineProperties.chargePerson.role || defineProperties.chargePerson.department
-        }]
+
+      // 兼容旧格式
+      if (defineProperties.chargePerson) {
+        defineProperties.chargePerson = this.normalizeChargePersonFormat(defineProperties.chargePerson)
       }
-      console.warn('defineProperties', defineProperties)
 
       if (defineProperties?.chargePerson?.needSelectPerson) {
-        // 获取人员选项并设置
-        this.checkedChargePerson = undefined
-        this.chargePersonOptions = await this.getChargePersonOptionsForStep(targetStepId)
-        // 如果只有一个选项，自动选中
-        if (this.chargePersonOptions.length === 1) {
-          this.checkedChargePerson = this.chargePersonOptions[0].value
+        await this.setupSingleTargetPersonSelection(targetStepId)
+        // 确保 branchChargePersons 中有该节点的数据结构
+        this.branchChargePersons[targetStepId] = {
+          handler: '',
+          handlerId: undefined,
+          ...defineProperties.chargePerson
         }
-        this.needSelectPerson = true
-        console.warn('设置人员选择，选项数量:', this.chargePersonOptions.length)
       } else {
-        this.branchChargePersons[targetStepId] = stepDefine?.properties?.chargePerson
+        // 不需要选择人员的情况，直接存储配置
+        this.branchChargePersons[targetStepId] = defineProperties?.chargePerson || {}
         this.needSelectPerson = false
         this.chargePersonOptions = []
-        console.warn('无需选择人员')
-      }
-    },
-    // 表单数据变化处理函数（将通过provide传递给表单组件）
-    async handleFormDataChange (formData) {
-      if (!this.isWfResultBranch) {
-        await this.calculateTargetNodeFromForm()
       }
-    },
+    }
   },
   watch: {}
 }