@lambo-design/workflow-approve 1.0.0-beta.140 → 1.0.0-beta.142

package/src/components/reject-node-table.vue

@@ -0,0 +1,837 @@
+<template>
+  <div class="reject-node-prototype">
+    <Table
+      border
+      size="small"
+      :data="tableRows"
+      :columns="tableColumns"
+      :span-method="spanMethod"
+      :row-class-name="rowClassName"
+      @on-row-click="handleRowClick"
+    />
+
+    <Form :label-width="90" class="reject-node-prototype__takeover-form">
+      <FormItem label="驳回给：">
+        <RadioGroup v-model="rejectToTakeOver" @on-change="handleRejectToTakeOverChange">
+          <Radio label="original">原办理人</Radio>
+          <Radio label="actual">实际办理人</Radio>
+        </RadioGroup>
+      </FormItem>
+    </Form>
+
+    <div class="reject-node-prototype__summary">
+      当前选择：<strong>{{ selectedSummary || '未选择' }}</strong>
+    </div>
+  </div>
+</template>
+
+<script>
+export default {
+  name: 'RejectNodeTable',
+  props: {
+    nodes: {
+      type: Array,
+      default: () => []
+    },
+    currentTaskNode: {
+      type: [String, Number],
+      default: ''
+    },
+    defaultRejectToTakeOver: {
+      type: Boolean,
+      default: false
+    },
+    visible: {
+      type: Boolean,
+      default: false
+    }
+  },
+  data() {
+    return {
+      rejectNodeCollapsedGroupKeys: [],
+      selectedRejectNodeTaskNodes: [],
+      selectedRejectNodePathKeys: [],
+      selectedRejectNodePathEntries: [],
+      selectedRejectNodeNames: [],
+      rejectToTakeOver: this.defaultRejectToTakeOver ? 'actual' : 'original'
+    }
+  },
+  computed: {
+    tableRows() {
+      if (!Array.isArray(this.nodes) || this.nodes.length === 0) {
+        return []
+      }
+      return this.buildRejectNodeTableRows()
+    },
+    tableColumns() {
+      const self = this
+      return [
+        {
+          title: '',
+          key: 'selected',
+          width: 56,
+          align: 'center',
+          renderHeader: h => h('span'),
+          render: (h, params) => {
+            if (params.row.type === 'group') {
+              return h('div', {
+                class: 'reject-node-prototype__group-cell'
+              }, [
+                h('Button', {
+                  class: 'reject-node-prototype__group-toggle',
+                  props: { type: 'text' },
+                  style: {
+                    paddingLeft: `${Math.max((params.row.groupLevel || 1) - 1, 0) * 16}px`
+                  },
+                  on: {
+                    click: event => {
+                      event.stopPropagation()
+                      self.toggleRejectNodeGroup(params.row)
+                    }
+                  }
+                }, [
+                  h('span', {
+                    class: 'reject-node-prototype__group-arrow'
+                  }, self.isRejectNodeGroupCollapsed(params.row.groupId) ? '▸' : '▾'),
+                  h('span', {
+                    class: 'reject-node-prototype__group-label'
+                  }, params.row.groupName || params.row.gatewayLabel || '无网关')
+                ])
+              ].filter(Boolean))
+            }
+            const checked = self.isRejectNodeSelected(params.row)
+            const disabled = self.isRejectNodeDisabled(params.row) && !checked
+            return h('Checkbox', {
+              props: {
+                value: checked,
+                disabled
+              },
+              nativeOn: {
+                click: event => event.stopPropagation()
+              },
+              on: {
+                'on-change': value => {
+                  self.toggleRejectNodeSelection(params.row, value)
+                }
+              }
+            })
+          }
+        },
+        {
+          title: '节点名称',
+          key: 'taskName',
+          minWidth: 180,
+          render: (h, params) => {
+            if (params.row.type === 'group') {
+              return h('div')
+            }
+            return h('div', {
+              class: 'reject-node-prototype__name-cell',
+              style: {
+                paddingLeft: `${Math.min(params.row.depth || 0, 4) * 16}px`
+              }
+            }, [
+              h('span', {
+                class: {
+                  'reject-node-prototype__node-name': true,
+                  'is-current': String(params.row.taskNode) === String(this.currentTaskNode)
+                }
+              }, params.row.taskName || params.row.name || params.row.title || '')
+            ])
+          }
+        },
+        {
+          title: '节点状态',
+          key: 'auditResult',
+          width: 160,
+          align: 'center',
+          render: (h, params) => {
+            if (params.row.type === 'group') {
+              return h('div')
+            }
+            const status = self.getRejectNodeStatus(params.row)
+            return h('Tag', { props: { color: status.color } }, status.label)
+          }
+        }
+      ]
+    },
+    selectedSummary() {
+      return this.selectedRejectNodeNames.join('、')
+    }
+  },
+  watch: {
+    visible: {
+      immediate: true,
+      handler(value) {
+        if (value) {
+          this.resetSelection()
+          return
+        }
+        this.resetSelection(false)
+      }
+    },
+    nodes: {
+      deep: true,
+      handler() {
+        if (this.visible) {
+          this.resetSelection()
+        }
+      }
+    }
+  },
+  methods: {
+    resetSelection(emitChange = true) {
+      this.rejectNodeCollapsedGroupKeys = []
+      this.selectedRejectNodeTaskNodes = []
+      this.selectedRejectNodePathKeys = []
+      this.selectedRejectNodePathEntries = []
+      this.selectedRejectNodeNames = []
+      this.rejectToTakeOver = this.defaultRejectToTakeOver ? 'actual' : 'original'
+      if (emitChange) {
+        this.emitSelectionChange()
+      }
+    },
+    emitSelectionChange() {
+      this.$emit('selection-change', {
+        taskNodes: this.selectedRejectNodeTaskNodes.slice(),
+        taskNames: this.selectedRejectNodeNames.slice(),
+        pathKeys: this.selectedRejectNodePathKeys.slice(),
+        pathEntries: this.selectedRejectNodePathEntries.map(item => ({
+          pathKey: item.pathKey,
+          pathIds: Array.isArray(item.pathIds) ? item.pathIds.slice() : []
+        })),
+        rejectToTakeOver: this.rejectToTakeOver
+      })
+    },
+    handleRejectToTakeOverChange() {
+      this.emitSelectionChange()
+    },
+    handleRowClick(row) {
+      if (!row) {
+        return
+      }
+      if (row.type === 'group') {
+        this.toggleRejectNodeGroup(row)
+        return
+      }
+      this.toggleRejectNodeSelection(row)
+    },
+    normalizeRejectNode(node, nodeIndex, nodeNameMap) {
+      const rejectPaths = Array.isArray(node?.rejectPaths) ? node.rejectPaths : []
+      const startGatewayPaths = Array.isArray(node?.startGatewayPaths) ? node.startGatewayPaths : []
+      const pathEntries = rejectPaths
+        .map((path, index) => {
+          const pathIds = Array.isArray(path) ? path.filter(Boolean).map(item => String(item)) : []
+          const pathKey = pathIds.join('>')
+          const gatewayPath = Array.isArray(startGatewayPaths[index]) ? startGatewayPaths[index] : []
+          const gatewayLabel = this.formatGatewayPathLabel(gatewayPath)
+          const pathLabel = this.formatRejectPathLabel(pathIds, nodeNameMap)
+          const pathOrder = pathIds.indexOf(String(node?.taskNode))
+          return {
+            pathKey,
+            pathLabel,
+            gatewayLabel,
+            gatewayPath,
+            pathOrder: pathOrder === -1 ? pathIds.length : pathOrder,
+            pathIds
+          }
+        })
+        .filter(item => item.pathKey)
+        .sort((left, right) => this.compareRejectNodePathEntries(left, right))
+
+      return {
+        ...node,
+        _nodeIndex: nodeIndex,
+        pathEntries,
+        pathKeys: pathEntries.map(item => item.pathKey)
+      }
+    },
+    formatRejectPathLabel(pathIds, nodeNameMap) {
+      return pathIds.map(id => nodeNameMap.get(id) || id).join(' > ')
+    },
+    formatGatewayPathLabel(gatewayPath) {
+      if (!Array.isArray(gatewayPath) || gatewayPath.length === 0) {
+        return ''
+      }
+      return gatewayPath
+        .map(item => item.groupName || item.groupId)
+        .filter(Boolean)
+        .join(' > ')
+    },
+    getRejectNodePrimaryGatewayPath(node) {
+      const pathEntries = Array.isArray(node?.pathEntries) && node.pathEntries.length > 0
+        ? node.pathEntries
+        : this.normalizeRejectNode(node, 0, new Map()).pathEntries
+      const primaryEntry = pathEntries.find(item => Array.isArray(item?.gatewayPath) && item.gatewayPath.length > 0)
+      return Array.isArray(primaryEntry?.gatewayPath) ? primaryEntry.gatewayPath : []
+    },
+    getRejectNodeGatewaySortKey(gatewayPath) {
+      if (!Array.isArray(gatewayPath) || gatewayPath.length === 0) {
+        return ''
+      }
+      return gatewayPath
+        .map(item => String(item?.groupId || item?.groupName || ''))
+        .filter(Boolean)
+        .join('>')
+    },
+    compareRejectNodePathEntries(left, right) {
+      const leftDepth = Array.isArray(left?.gatewayPath) ? left.gatewayPath.length : 0
+      const rightDepth = Array.isArray(right?.gatewayPath) ? right.gatewayPath.length : 0
+      if (leftDepth !== rightDepth) {
+        return leftDepth - rightDepth
+      }
+      const leftGatewayKey = this.getRejectNodeGatewaySortKey(left?.gatewayPath)
+      const rightGatewayKey = this.getRejectNodeGatewaySortKey(right?.gatewayPath)
+      if (leftGatewayKey !== rightGatewayKey) {
+        return leftGatewayKey.localeCompare(rightGatewayKey)
+      }
+      const leftPathOrder = typeof left?.pathOrder === 'number' ? left.pathOrder : Number.MAX_SAFE_INTEGER
+      const rightPathOrder = typeof right?.pathOrder === 'number' ? right.pathOrder : Number.MAX_SAFE_INTEGER
+      if (leftPathOrder !== rightPathOrder) {
+        return leftPathOrder - rightPathOrder
+      }
+      return String(left?.pathKey || '').localeCompare(String(right?.pathKey || ''))
+    },
+    getRejectNodePathKeys(node) {
+      if (Array.isArray(node?.pathKeys) && node.pathKeys.length > 0) {
+        return node.pathKeys
+      }
+      if (node?.pathKey) {
+        return [node.pathKey]
+      }
+      return this.normalizeRejectNode(node, 0, new Map()).pathKeys
+    },
+    isRejectNodeSelected(row) {
+      if (!row || row.type !== 'node') {
+        return false
+      }
+      return this.selectedRejectNodeTaskNodes.includes(String(row.taskNode))
+    },
+    getRejectNodePathKeysByTaskNode(taskNode) {
+      if (!taskNode) {
+        return []
+      }
+      const nodes = Array.isArray(this.nodes)
+        ? this.nodes.filter(item => item && String(item.taskNode) === String(taskNode))
+        : []
+      if (!nodes.length) {
+        return []
+      }
+      const pathKeys = []
+      nodes.forEach(node => {
+        this.getRejectNodePathKeys(node).forEach(pathKey => {
+          if (pathKey && !pathKeys.includes(pathKey)) {
+            pathKeys.push(pathKey)
+          }
+        })
+      })
+      return pathKeys
+    },
+    getRejectNodePathEntriesByTaskNode(taskNode) {
+      if (!taskNode) {
+        return []
+      }
+      const nodes = Array.isArray(this.nodes)
+        ? this.nodes.filter(item => item && String(item.taskNode) === String(taskNode))
+        : []
+      if (!nodes.length) {
+        return []
+      }
+      const pathEntries = []
+      nodes.forEach(node => {
+        this.normalizeRejectNode(node, 0, new Map()).pathEntries.forEach(pathEntry => {
+          if (!pathEntry || !pathEntry.pathKey) {
+            return
+          }
+          if (!pathEntries.some(item => item.pathKey === pathEntry.pathKey)) {
+            pathEntries.push({
+              pathKey: pathEntry.pathKey,
+              pathIds: Array.isArray(pathEntry.pathIds) ? pathEntry.pathIds.slice() : []
+            })
+          }
+        })
+      })
+      return pathEntries
+    },
+    isRejectPathRelated(pathIdsA, pathIdsB) {
+      if (!Array.isArray(pathIdsA) || !Array.isArray(pathIdsB) || pathIdsA.length === 0 || pathIdsB.length === 0) {
+        return false
+      }
+      const minLength = Math.min(pathIdsA.length, pathIdsB.length)
+      for (let i = 0; i < minLength; i += 1) {
+        if (String(pathIdsA[i]) !== String(pathIdsB[i])) {
+          return false
+        }
+      }
+      return true
+    },
+    syncSelection(taskNodeList) {
+      const uniqueTaskNodes = Array.from(new Set((taskNodeList || []).map(item => String(item)).filter(Boolean)))
+      this.selectedRejectNodeTaskNodes = uniqueTaskNodes
+
+      const selectedNames = []
+      const selectedPathKeys = []
+      const selectedPathEntries = []
+      uniqueTaskNodes.forEach(taskNode => {
+        const node = Array.isArray(this.nodes) ? this.nodes.find(item => item && String(item.taskNode) === taskNode) : null
+        const nodeName = node ? (node.taskName || node.name || node.title || '') : ''
+        if (nodeName) {
+          selectedNames.push(nodeName)
+        }
+        this.getRejectNodePathEntriesByTaskNode(taskNode).forEach(pathEntry => {
+          if (!pathEntry || !pathEntry.pathKey) {
+            return
+          }
+          if (!selectedPathKeys.includes(pathEntry.pathKey)) {
+            selectedPathKeys.push(pathEntry.pathKey)
+          }
+          const exists = selectedPathEntries.some(item => item.pathKey === pathEntry.pathKey)
+          if (!exists) {
+            selectedPathEntries.push({
+              pathKey: pathEntry.pathKey,
+              pathIds: Array.isArray(pathEntry.pathIds) ? pathEntry.pathIds.slice() : []
+            })
+          }
+        })
+      })
+      this.selectedRejectNodeNames = selectedNames
+      this.selectedRejectNodePathKeys = selectedPathKeys
+      this.selectedRejectNodePathEntries = selectedPathEntries
+      this.emitSelectionChange()
+    },
+    toggleRejectNodeSelection(row, checked) {
+      if (!row || row.type !== 'node') {
+        return
+      }
+      const taskNode = String(row.taskNode)
+      const selectedTaskNodes = this.selectedRejectNodeTaskNodes.slice()
+      const existsIndex = selectedTaskNodes.indexOf(taskNode)
+      const shouldSelect = typeof checked === 'boolean' ? checked : existsIndex === -1
+      if (shouldSelect) {
+        if (existsIndex === -1) {
+          if (this.isRejectNodeDisabled(row)) {
+            return
+          }
+          selectedTaskNodes.push(taskNode)
+        }
+      } else if (existsIndex > -1) {
+        selectedTaskNodes.splice(existsIndex, 1)
+      }
+      this.syncSelection(selectedTaskNodes)
+    },
+    isRejectNodeGroupCollapsed(groupId) {
+      return this.rejectNodeCollapsedGroupKeys.includes(groupId)
+    },
+    toggleRejectNodeGroup(row) {
+      if (!row || !row.groupId) {
+        return
+      }
+      const nextKeys = this.rejectNodeCollapsedGroupKeys.slice()
+      const collapsedIndex = nextKeys.indexOf(row.groupId)
+      if (collapsedIndex === -1) {
+        nextKeys.push(row.groupId)
+      } else {
+        nextKeys.splice(collapsedIndex, 1)
+      }
+      this.rejectNodeCollapsedGroupKeys = nextKeys
+    },
+    buildRejectNodeTableRows() {
+      const nodeNameMap = new Map()
+      const groupedNodes = this.sortRejectNodesForTable(this.mergeRejectNodesByTaskNode(this.nodes))
+      groupedNodes.forEach(node => {
+        if (node && node.taskNode) {
+          nodeNameMap.set(String(node.taskNode), node.taskName || node.name || node.taskNode)
+        }
+      })
+
+      const rows = []
+      const groupSet = new Set()
+      const nodeRowMap = new Map()
+      groupedNodes.forEach((node, nodeIndex) => {
+        const normalizedNode = this.normalizeRejectNode(node, nodeIndex, nodeNameMap)
+        const nodeKey = String(normalizedNode.taskNode || `node-${nodeIndex}`)
+        let nodeRow = nodeRowMap.get(nodeKey) || null
+        normalizedNode.pathEntries.forEach(pathEntry => {
+          const gatewayPath = Array.isArray(pathEntry.gatewayPath) ? pathEntry.gatewayPath : []
+          const ancestorGroupIds = []
+          let parentGroupId = ''
+          gatewayPath.forEach((gateway, gatewayIndex) => {
+            const groupId = String(gateway.groupId || `${nodeIndex}-${pathEntry.pathKey}-${gatewayIndex}`)
+            if (!groupSet.has(groupId)) {
+              groupSet.add(groupId)
+              rows.push({
+                type: 'group',
+                rowKey: `group:${groupId}`,
+                groupId,
+                groupName: gateway.groupName || gateway.groupId || groupId,
+                groupLevel: gatewayIndex + 1,
+                gatewayLabel: this.formatGatewayPathLabel(gatewayPath),
+                pathLabel: pathEntry.pathLabel,
+                parentGroupId,
+                ancestorGroupIds: ancestorGroupIds.slice()
+              })
+            }
+            ancestorGroupIds.push(groupId)
+            parentGroupId = groupId
+          })
+
+          if (!nodeRow) {
+            nodeRow = {
+              ...normalizedNode,
+              type: 'node',
+              rowKey: nodeKey,
+              pathKey: pathEntry.pathKey,
+              pathLabel: pathEntry.pathLabel,
+              gatewayLabel: pathEntry.gatewayLabel,
+              ancestorGroupIds: ancestorGroupIds.slice(),
+              depth: gatewayPath.length,
+              displayIndex: 0,
+              pathOrder: pathEntry.pathOrder,
+              pathKeys: [pathEntry.pathKey],
+              pathLabels: pathEntry.pathLabel ? [pathEntry.pathLabel] : [],
+              gatewayLabels: pathEntry.gatewayLabel ? [pathEntry.gatewayLabel] : []
+            }
+          } else {
+            if (!Array.isArray(nodeRow.pathKeys)) {
+              nodeRow.pathKeys = []
+            }
+            if (pathEntry.pathKey && !nodeRow.pathKeys.includes(pathEntry.pathKey)) {
+              nodeRow.pathKeys.push(pathEntry.pathKey)
+            }
+            if (!Array.isArray(nodeRow.pathLabels)) {
+              nodeRow.pathLabels = []
+            }
+            if (pathEntry.pathLabel && !nodeRow.pathLabels.includes(pathEntry.pathLabel)) {
+              nodeRow.pathLabels.push(pathEntry.pathLabel)
+            }
+            if (!Array.isArray(nodeRow.gatewayLabels)) {
+              nodeRow.gatewayLabels = []
+            }
+            if (pathEntry.gatewayLabel && !nodeRow.gatewayLabels.includes(pathEntry.gatewayLabel)) {
+              nodeRow.gatewayLabels.push(pathEntry.gatewayLabel)
+            }
+            nodeRow.ancestorGroupIds = Array.from(new Set([...(nodeRow.ancestorGroupIds || []), ...ancestorGroupIds]))
+            nodeRow.depth = Math.max(nodeRow.depth || 0, gatewayPath.length)
+            nodeRow.pathOrder = Math.min(nodeRow.pathOrder ?? pathEntry.pathOrder, pathEntry.pathOrder)
+          }
+        })
+        if (nodeRow && !nodeRowMap.has(nodeKey)) {
+          nodeRowMap.set(nodeKey, nodeRow)
+          rows.push(nodeRow)
+        }
+      })
+
+      const visibleRows = []
+      rows.forEach(row => {
+        const hidden = Array.isArray(row.ancestorGroupIds) && row.ancestorGroupIds.some(groupId => this.isRejectNodeGroupCollapsed(groupId))
+        if (hidden) {
+          return
+        }
+        visibleRows.push(row)
+      })
+
+      return visibleRows
+    },
+    sortRejectNodesForTable(nodes) {
+      const list = Array.isArray(nodes) ? nodes.slice() : []
+      const bucketMap = new Map()
+      const bucketOrder = []
+
+      list.forEach((node, index) => {
+        const normalizedNode = this.normalizeRejectNode(node, index, new Map())
+        const primaryGatewayPath = this.getRejectNodePrimaryGatewayPath(normalizedNode)
+        const gatewayKey = primaryGatewayPath.length > 0
+          ? this.getRejectNodeGatewaySortKey(primaryGatewayPath)
+          : '__reject_node_no_gateway__'
+        let bucket = bucketMap.get(gatewayKey)
+        if (!bucket) {
+          bucket = {
+            gatewayKey,
+            hasGateway: primaryGatewayPath.length > 0,
+            firstIndex: index,
+            nodes: []
+          }
+          bucketMap.set(gatewayKey, bucket)
+          bucketOrder.push(bucket)
+        }
+        bucket.nodes.push(node)
+      })
+
+      bucketOrder.sort((left, right) => {
+        if (left.hasGateway !== right.hasGateway) {
+          return left.hasGateway ? 1 : -1
+        }
+        return left.firstIndex - right.firstIndex
+      })
+
+      const sortedNodes = []
+      bucketOrder.forEach(bucket => {
+        bucket.nodes.forEach(node => {
+          sortedNodes.push(node)
+        })
+      })
+      return sortedNodes
+    },
+    mergeRejectNodesByTaskNode(nodes) {
+      const groupedMap = new Map()
+      const sourceNodes = Array.isArray(nodes) ? nodes : []
+      sourceNodes.forEach((node, index) => {
+        if (!node) {
+          return
+        }
+        const taskNodeKey = node.taskNode ? String(node.taskNode) : `__index__${index}`
+        const existing = groupedMap.get(taskNodeKey)
+        if (!existing) {
+          groupedMap.set(taskNodeKey, {
+            ...node,
+            rejectPaths: Array.isArray(node.rejectPaths) ? node.rejectPaths.slice() : [],
+            startGatewayPaths: Array.isArray(node.startGatewayPaths) ? node.startGatewayPaths.slice() : []
+          })
+          return
+        }
+        if (!Array.isArray(existing.rejectPaths)) {
+          existing.rejectPaths = []
+        }
+        if (!Array.isArray(existing.startGatewayPaths)) {
+          existing.startGatewayPaths = []
+        }
+        ;(Array.isArray(node.rejectPaths) ? node.rejectPaths : []).forEach((path, pathIndex) => {
+          const pathKey = JSON.stringify(path || [])
+          const exists = existing.rejectPaths.some(item => JSON.stringify(item || []) === pathKey)
+          if (!exists) {
+            existing.rejectPaths.push(Array.isArray(path) ? path.slice() : path)
+            const gatewayPath = Array.isArray(node.startGatewayPaths) ? node.startGatewayPaths[pathIndex] : null
+            if (gatewayPath) {
+              const gatewayKey = JSON.stringify(gatewayPath || [])
+              const gatewayExists = existing.startGatewayPaths.some(item => JSON.stringify(item || []) === gatewayKey)
+              if (!gatewayExists) {
+                existing.startGatewayPaths.push(Array.isArray(gatewayPath) ? gatewayPath.slice() : gatewayPath)
+              }
+            }
+          }
+        })
+        Object.keys(node).forEach(key => {
+          if (key === 'rejectPaths' || key === 'startGatewayPaths') {
+            return
+          }
+          if (existing[key] === undefined || existing[key] === null || existing[key] === '') {
+            existing[key] = node[key]
+          }
+        })
+      })
+      return Array.from(groupedMap.values())
+    },
+    isRejectNodeDisabled(row) {
+      if (!row || row.type !== 'node') {
+        return false
+      }
+      if (this.isRejectNodeSelected(row)) {
+        return false
+      }
+      const rowPathEntries = Array.isArray(row.pathEntries) && row.pathEntries.length > 0
+        ? row.pathEntries
+        : this.normalizeRejectNode(row, 0, new Map()).pathEntries
+      if (rowPathEntries.length === 0 || this.selectedRejectNodePathEntries.length === 0) {
+        return false
+      }
+      return rowPathEntries.some(rowPathEntry => {
+        return this.selectedRejectNodePathEntries.some(selectedPathEntry => {
+          return this.isRejectPathRelated(rowPathEntry.pathIds, selectedPathEntry.pathIds)
+        })
+      })
+    },
+    spanMethod({ row, columnIndex }) {
+      if (row && row.type === 'group') {
+        return columnIndex === 0 ? [1, this.tableColumns.length] : [0, 0]
+      }
+      return [1, 1]
+    },
+    rowClassName(row) {
+      if (!row) {
+        return ''
+      }
+      if (row.type === 'group') {
+        return 'reject-node-prototype__group-row'
+      }
+      const selected = this.isRejectNodeSelected(row)
+      const disabled = !selected && this.isRejectNodeDisabled(row)
+      return [
+        'reject-node-prototype__node-row',
+        selected && 'is-selected',
+        disabled && 'is-disabled'
+      ].filter(Boolean).join(' ')
+    },
+    getRejectNodeStatus(row) {
+      if (String(row.taskNode) === String(this.currentTaskNode)) {
+        return { label: '当前节点', color: 'orange' }
+      }
+      if (!row.auditResult) {
+        return { label: `未${row.handleName ? row.handleName : '审批'}`, color: 'orange' }
+      }
+      const statusMap = {
+        '30': { label: `${row.handleName ? row.handleName : '审批'}通过`, color: 'green' },
+        '10': { label: '首节点自动跳过', color: 'green' },
+        '11': { label: '与上一环节办理人相同自动跳过', color: 'green' },
+        '12': { label: '与发起人相同自动跳过', color: 'green' },
+        '13': { label: '办理人为空自动跳过', color: 'green' },
+        '14': { label: '符合流程变量条件自动跳过', color: 'green' },
+        '40': { label: `${row.rejectName ? row.rejectName : '驳回'}到上一节点`, color: 'volcano' },
+        '50': { label: `${row.rejectName ? row.rejectName : '驳回'}到原点`, color: 'red' },
+        '51': { label: '流程终止', color: 'purple' },
+        '60': { label: '撤回', color: 'blue' },
+        '61': { label: '交回委派任务', color: 'green' },
+        '62': { label: '委派任务已撤回', color: 'blue' },
+        '63': { label: '委派任务', color: 'orange' },
+        '80': { label: '跳转到指定节点', color: 'cyan' },
+        '82': { label: '指定他人处理', color: 'cyan' },
+        '83': { label: '会签减签', color: 'blue' },
+        '90': { label: `${row.rejectName ? row.rejectName : '驳回'}到指定节点`, color: 'magenta' },
+        '92': { label: `${row.rejectName ? row.rejectName : '驳回'}到指定节点`, color: 'magenta' },
+        '31': { label: '会签表决通过', color: 'green' }
+      }
+      return statusMap[row.auditResult] || { label: row.auditResult, color: 'default' }
+    }
+  }
+}
+</script>
+
+<style lang="less" scoped>
+.reject-node-prototype {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.reject-node-prototype /deep/ .ivu-table {
+  font-size: 14px;
+  color: #333333;
+}
+
+.reject-node-prototype /deep/ .ivu-table th,
+.reject-node-prototype /deep/ .ivu-table td {
+  box-sizing: border-box;
+  text-align: center;
+  vertical-align: middle;
+}
+
+.reject-node-prototype /deep/ .ivu-table th {
+  height: 40px;
+  background: #f5f7fa;
+  font-weight: 700;
+  color: #666666;
+}
+
+.reject-node-prototype /deep/ .ivu-table td {
+  height: 40px;
+  padding: 6px 10px;
+  background: #ffffff;
+}
+
+.reject-node-prototype /deep/ .ivu-table-cell {
+  width: 100%;
+}
+
+.reject-node-prototype /deep/ .reject-node-prototype__group-row td {
+  height: 32px;
+  padding: 0 12px;
+  text-align: left;
+}
+
+.reject-node-prototype /deep/ .ivu-table-cell .reject-node-prototype__group-toggle {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  color: #333333;
+  font-size: 14px;
+  line-height: 1;
+  height: auto;
+  cursor: pointer;
+}
+
+.reject-node-prototype /deep/ .ivu-table-cell .reject-node-prototype__group-arrow {
+  width: 12px;
+  color: #808695;
+  text-align: center;
+}
+
+.reject-node-prototype /deep/ .ivu-table-cell .reject-node-prototype__group-label {
+  font-weight: 600;
+}
+
+.reject-node-prototype /deep/ .ivu-table-cell .reject-node-prototype__group-desc {
+  margin-left: 16px;
+  color: #808695;
+  font-size: 12px;
+  white-space: normal;
+}
+
+.reject-node-prototype /deep/ .ivu-table-cell .reject-node-prototype__node-name {
+  display: inline-block;
+  max-width: 100%;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.reject-node-prototype /deep/ .ivu-table-cell .reject-node-prototype__name-cell {
+  display: flex;
+  align-items: center;
+  width: 100%;
+  text-align: left;
+}
+
+.reject-node-prototype /deep/ .ivu-table-cell .reject-node-prototype__node-name.is-current {
+  color: #2d8cf0;
+  font-weight: 600;
+}
+
+.reject-node-prototype /deep/ .ivu-table-cell .reject-node-prototype__group-cell {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 6px;
+  min-height: 28px;
+  text-align: left;
+}
+
+.reject-node-prototype /deep/ .reject-node-prototype__node-row {
+  cursor: pointer;
+}
+
+.reject-node-prototype /deep/ .reject-node-prototype__node-row.is-disabled {
+  cursor: not-allowed;
+}
+
+.reject-node-prototype /deep/ .reject-node-prototype__group-row {
+  cursor: default;
+}
+
+.reject-node-prototype__takeover-form {
+  margin-top: 4px;
+}
+
+.reject-node-prototype__summary {
+  min-height: 20px;
+  color: #515a6e;
+  font-size: 12px;
+}
+
+.reject-node-prototype /deep/ .reject-node-prototype__node-row.is-selected td {
+  background: #ecf5ff;
+}
+
+.reject-node-prototype /deep/ .reject-node-prototype__node-row.is-disabled td {
+  color: #c5c8ce;
+}
+
+.reject-node-prototype /deep/ .reject-node-prototype__node-row.is-disabled:hover td {
+  background: transparent;
+}
+
+.reject-node-prototype /deep/ .reject-node-prototype__node-row.is-disabled .reject-node-prototype__node-name {
+  color: #c5c8ce;
+}
+</style>