优化旧码多明细选择提示

src/api/mock.ts

@@ -242,11 +242,16 @@ export const mockApi = {
       commodityDescription: '面向到店客人的酒店权益商品，需由员工确认后核销。',
       commodityPackageConfig: [
         {
+          orderWriteOffItemId: `WOI${order.id}-1`,
           packageName: order.commodityName,
           packageContent: `${order.commodityName} x ${order.commodityAmount}`,
           name: order.commodityName,
           count: totalCount,
           unit: '份',
+          writeOffStatus: writeOffCount >= totalCount ? 'WRITTEN_OFF' : 'NOT_WRITE_OFF',
+          legacySnapshot: false,
+          writeOffSupported: true,
+          snapshotOperationSupported: true,
           packageStatus: writeOffCount >= totalCount ? 1 : 0,
           writeOffCount
         }
@@ -278,7 +283,7 @@ export const mockApi = {
     return {
       success: true,
       orderId: payload.orderId,
-      packageName: payload.packageName,
+      orderWriteOffItemId: payload.orderWriteOffItemId,
       message: '核销成功',
       operatedAt: formatDateTime(new Date())
     }

src/api/orders.ts

@@ -36,7 +36,7 @@ export const writeOffOrder = async (payload: WriteOffPayload): Promise<WriteOffR
   return {
     success: true,
     orderId: payload.orderId,
-    packageName: payload.packageName,
+    orderWriteOffItemId: payload.orderWriteOffItemId,
     message: '核销成功',
     operatedAt: new Date().toISOString()
   }

src/types/order.ts

@@ -2,7 +2,7 @@ import type { PageQuery } from './api'
 
 export type OrderStatus = '0' | '1' | '2' | '3' | '4' | '5' | '6'
 export type PayStatus = '0' | '1'
-export type CommodityTypeCode = '0' | '1' | '2'
+export type CommodityTypeCode = '0' | '1' | '2' | '3'
 
 export interface CommodityOrder {
   id: string
@@ -52,6 +52,7 @@ export interface CommodityService {
 }
 
 export interface CommodityPackageConfig {
+  orderWriteOffItemId?: string
   packageName?: string
   packageContent?: string
   packageDesc?: string
@@ -60,6 +61,10 @@ export interface CommodityPackageConfig {
   count?: number
   color?: string
   unit?: string
+  writeOffStatus?: string | number
+  legacySnapshot?: boolean
+  writeOffSupported?: boolean
+  snapshotOperationSupported?: boolean
   packageStatus?: number
   writeOffCount?: number
 }
@@ -121,12 +126,14 @@ export interface UserOrderDetail {
 
 export interface WriteOffPayload {
   orderId: string
-  packageName?: string
+  orderWriteOffItemId: string
+  writeOffRequestNo: string
 }
 
 export interface WriteOffResult {
   success: boolean
   orderId: string
+  orderWriteOffItemId?: string
   packageName?: string
   message: string
   operatedAt: string

src/utils/__tests__/writeOffCode.test.ts

@@ -0,0 +1,22 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { parseWriteOffCode } from '../writeOffCode.ts'
+
+test('parses v2 JSON write off code with item id', () => {
+  assert.deepEqual(
+    parseWriteOffCode('{"v":2,"orderId":"2067459232180035585","orderWriteOffItemId":"item-2","packageName":"全价门票"}'),
+    {
+      orderId: '2067459232180035585',
+      orderWriteOffItemId: 'item-2',
+      packageName: '全价门票',
+      version: 2
+    }
+  )
+})
+
+test('parses legacy orderId and packageName write off code', () => {
+  assert.deepEqual(parseWriteOffCode('order-1&%E5%A5%97%E9%A4%90A'), {
+    orderId: 'order-1',
+    packageName: '套餐A'
+  })
+})

src/utils/__tests__/writeOffItem.test.ts

@@ -0,0 +1,121 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import {
+  getWriteOffItemAvailability,
+  getWriteOffItemQuantity,
+  getWriteOffStatusText,
+  resolveWriteOffItemSelection,
+  shouldShowManualSelectionHint
+} from '../writeOffItem.ts'
+
+const writeOffItemModule = await import('../writeOffItem.ts')
+
+const items = [
+  {
+    orderWriteOffItemId: 'item-1',
+    name: '双人套餐',
+    count: 2,
+    writeOffCount: 0,
+    writeOffSupported: true,
+    snapshotOperationSupported: true
+  },
+  {
+    orderWriteOffItemId: 'item-2',
+    name: '双人套餐',
+    count: 2,
+    writeOffCount: 1,
+    writeOffSupported: true,
+    snapshotOperationSupported: true
+  }
+]
+
+test('calculates total, written off and remaining quantity from item fields', () => {
+  assert.deepEqual(getWriteOffItemQuantity(items[1]), {
+    total: 2,
+    writtenOff: 1,
+    writable: 1,
+    unit: ''
+  })
+})
+
+test('marks legacy or unsupported or completed item unavailable', () => {
+  assert.equal(getWriteOffItemAvailability({ ...items[0], legacySnapshot: true }).available, false)
+  assert.equal(getWriteOffItemAvailability({ ...items[0], writeOffSupported: false }).available, false)
+  assert.equal(getWriteOffItemAvailability({ ...items[0], snapshotOperationSupported: false }).available, false)
+  assert.equal(getWriteOffItemAvailability({ ...items[0], writeOffCount: 2 }).available, false)
+})
+
+test('locks scanned v2 code to the specified write off item id', () => {
+  const selection = resolveWriteOffItemSelection(items, {
+    source: 'scan',
+    orderWriteOffItemId: 'item-2',
+    packageName: '双人套餐'
+  })
+
+  assert.equal(selection.locked, true)
+  assert.deepEqual(selection.options.map((item) => item.orderWriteOffItemId), ['item-2'])
+  assert.equal(selection.selectedItemId, 'item-2')
+})
+
+test('does not auto select when legacy package name matches multiple available items', () => {
+  const selection = resolveWriteOffItemSelection(items, {
+    source: 'scan',
+    packageName: '双人套餐'
+  })
+
+  assert.equal(selection.mismatch, false)
+  assert.equal(selection.requiresManualSelection, true)
+  assert.equal(selection.selectedItemId, '')
+  assert.deepEqual(selection.options.map((item) => item.orderWriteOffItemId), ['item-1', 'item-2'])
+})
+
+test('hides manual selection hint after an item is selected', () => {
+  const selection = resolveWriteOffItemSelection(items, {
+    source: 'scan',
+    packageName: '双人套餐'
+  })
+
+  assert.equal(shouldShowManualSelectionHint(selection, ''), true)
+  assert.equal(shouldShowManualSelectionHint(selection, 'item-1'), false)
+})
+
+test('does not export legacy package name finder', () => {
+  assert.equal('findWriteOffItem' in writeOffItemModule, false)
+})
+
+test('auto selects the only available item matched by legacy package name', () => {
+  const selection = resolveWriteOffItemSelection(
+    [
+      { ...items[0], writeOffCount: 2 },
+      items[1]
+    ],
+    {
+      source: 'scan',
+      packageName: '双人套餐'
+    }
+  )
+
+  assert.equal(selection.selectedItemId, 'item-2')
+  assert.equal(selection.requiresManualSelection, false)
+})
+
+test('default selection skips unavailable items', () => {
+  const selection = resolveWriteOffItemSelection([
+    { ...items[0], writeOffCount: 2 },
+    items[1]
+  ])
+
+  assert.equal(selection.selectedItemId, 'item-2')
+})
+
+test('infers partial write off status from quantity when status is 0', () => {
+  assert.equal(getWriteOffStatusText({ ...items[0], writeOffStatus: 0, writeOffCount: 0 }), '待核销')
+  assert.equal(getWriteOffStatusText({ ...items[0], writeOffStatus: 0, writeOffCount: 1 }), '部分核销')
+  assert.equal(getWriteOffStatusText({ ...items[0], writeOffStatus: 0, writeOffCount: 2 }), '已核销')
+  assert.equal(getWriteOffStatusText({ ...items[0], writeOffStatus: 1, writeOffCount: 0 }), '已核销')
+})
+
+test('does not override explicit non-zero write off status with quantity inference', () => {
+  assert.equal(getWriteOffStatusText({ ...items[0], writeOffStatus: 2, writeOffCount: 0 }), '部分核销')
+  assert.equal(getWriteOffStatusText({ ...items[0], writeOffStatus: 'PART_WRITE_OFF', writeOffCount: 0 }), '部分核销')
+})

src/utils/__tests__/writeOffRequestNo.test.ts

@@ -0,0 +1,29 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { getReusableWriteOffRequestNo, type WriteOffRequestNoState } from '../writeOffRequestNo.ts'
+
+test('reuses request number for the same write off target', () => {
+  const state: WriteOffRequestNoState = { targetKey: '', requestNo: '' }
+  let sequence = 0
+  const createRequestNo = () => `request-${++sequence}`
+
+  const first = getReusableWriteOffRequestNo(state, 'order-1:item-1', createRequestNo)
+  const retry = getReusableWriteOffRequestNo(state, 'order-1:item-1', createRequestNo)
+
+  assert.equal(first, 'request-1')
+  assert.equal(retry, 'request-1')
+  assert.equal(sequence, 1)
+})
+
+test('creates a new request number when the write off target changes', () => {
+  const state: WriteOffRequestNoState = { targetKey: '', requestNo: '' }
+  let sequence = 0
+  const createRequestNo = () => `request-${++sequence}`
+
+  const first = getReusableWriteOffRequestNo(state, 'order-1:item-1', createRequestNo)
+  const second = getReusableWriteOffRequestNo(state, 'order-1:item-2', createRequestNo)
+
+  assert.equal(first, 'request-1')
+  assert.equal(second, 'request-2')
+  assert.equal(sequence, 2)
+})

src/utils/constants.ts

@@ -29,7 +29,8 @@ export const payStatusText: Record<PayStatus, string> = {
 export const commodityTypeText: Record<CommodityTypeCode, string> = {
   '0': '酒店',
   '1': '门票',
-  '2': '餐饮'
+  '2': '餐饮',
+  '3': '套餐'
 }
 
 export const eventStatusText: Record<EventStatus, string> = {

src/utils/writeOffCode.ts

@@ -1,6 +1,8 @@
 export interface WriteOffCodePayload {
   orderId: string
+  orderWriteOffItemId?: string
   packageName?: string
+  version?: number
 }
 
 const safeDecode = (value: string) => {
@@ -17,6 +19,30 @@ export const parseWriteOffCode = (rawValue: string): WriteOffCodePayload => {
     throw new Error('未识别到核销码')
   }
 
+  if (raw.startsWith('{')) {
+    try {
+      const payload = JSON.parse(raw) as {
+        v?: number
+        orderId?: string
+        orderWriteOffItemId?: string
+        packageName?: string
+      }
+      const orderId = String(payload.orderId || '').trim()
+      if (!orderId) {
+        throw new Error('核销码缺少订单号')
+      }
+      return {
+        orderId,
+        orderWriteOffItemId: payload.orderWriteOffItemId ? String(payload.orderWriteOffItemId).trim() : undefined,
+        packageName: payload.packageName ? String(payload.packageName).trim() : undefined,
+        version: payload.v
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message === '核销码缺少订单号') throw error
+      throw new Error('核销码格式不正确')
+    }
+  }
+
   const splitIndex = raw.indexOf('&')
   const orderId = safeDecode(splitIndex >= 0 ? raw.slice(0, splitIndex) : raw).trim()
   const packageName = splitIndex >= 0 ? safeDecode(raw.slice(splitIndex + 1)).trim() : ''

src/utils/writeOffItem.ts

@@ -0,0 +1,164 @@
+import type { CommodityPackageConfig } from '@/types/order'
+
+export interface WriteOffItemQuantity {
+  total: number
+  writtenOff: number
+  writable: number
+  unit: string
+}
+
+export interface WriteOffItemAvailability {
+  available: boolean
+  reason: string
+}
+
+export interface WriteOffItemSelectionInput {
+  source?: string
+  orderWriteOffItemId?: string
+  packageName?: string
+  fallbackName?: string
+}
+
+export interface WriteOffItemSelection {
+  options: CommodityPackageConfig[]
+  selectedItemId: string
+  locked: boolean
+  mismatch: boolean
+  requiresManualSelection: boolean
+}
+
+const statusTextMap: Record<string, string> = {
+  '0': '待核销',
+  '1': '已核销',
+  '2': '部分核销',
+  NOT_WRITE_OFF: '待核销',
+  WAIT_WRITE_OFF: '待核销',
+  PART_WRITE_OFF: '部分核销',
+  PARTIAL_WRITE_OFF: '部分核销',
+  WRITE_OFF: '已核销',
+  WRITTEN_OFF: '已核销',
+  FINISHED: '已核销'
+}
+
+export const toNumber = (value: unknown) => {
+  const number = Number(value)
+  return Number.isFinite(number) ? number : undefined
+}
+
+export const getWriteOffItemId = (item?: CommodityPackageConfig) => {
+  return String(item?.orderWriteOffItemId || '').trim()
+}
+
+export const getWriteOffItemName = (item?: CommodityPackageConfig, fallbackName = '') => {
+  return (item?.name || item?.packageName || fallbackName || '').trim()
+}
+
+export const getWriteOffItemContent = (item?: CommodityPackageConfig) => {
+  return item?.packageContent || item?.packageDesc || item?.content || ''
+}
+
+export const getWriteOffItemQuantity = (item?: CommodityPackageConfig): WriteOffItemQuantity => {
+  const total = toNumber(item?.count) ?? 0
+  const writtenOff = Math.min(toNumber(item?.writeOffCount) ?? 0, total)
+  return {
+    total,
+    writtenOff,
+    writable: Math.max(total - writtenOff, 0),
+    unit: item?.unit || ''
+  }
+}
+
+export const getWriteOffItemAvailability = (item?: CommodityPackageConfig): WriteOffItemAvailability => {
+  if (!item) return { available: false, reason: '缺少可核销明细' }
+  if (!getWriteOffItemId(item)) return { available: false, reason: '缺少核销明细ID' }
+  if (item.legacySnapshot) return { available: false, reason: '历史未迁移明细不可核销' }
+  if (item.writeOffSupported === false) return { available: false, reason: '当前明细不支持核销' }
+  if (item.snapshotOperationSupported === false) return { available: false, reason: '当前明细不支持快照核销' }
+  if (getWriteOffItemQuantity(item).writable <= 0) return { available: false, reason: '当前明细已核销完' }
+  return { available: true, reason: '' }
+}
+
+export const getFirstAvailableWriteOffItem = (items: CommodityPackageConfig[]) => {
+  return items.find((item) => getWriteOffItemAvailability(item).available)
+}
+
+const matchesWriteOffItemName = (item: CommodityPackageConfig, packageName: string, fallbackName = '') => {
+  return getWriteOffItemName(item, fallbackName) === packageName || item.packageName === packageName
+}
+
+export const resolveWriteOffItemSelection = (
+  items: CommodityPackageConfig[],
+  input: WriteOffItemSelectionInput = {}
+): WriteOffItemSelection => {
+  const source = String(input.source || '')
+  const itemId = String(input.orderWriteOffItemId || '').trim()
+  const packageName = String(input.packageName || '').trim()
+  const isScan = source === 'scan'
+  const locked = isScan && Boolean(itemId)
+
+  let options = items
+  if (locked) {
+    options = items.filter((item) => getWriteOffItemId(item) === itemId)
+  } else if (isScan && packageName) {
+    options = items.filter((item) => matchesWriteOffItemName(item, packageName, input.fallbackName))
+  }
+
+  const mismatch = isScan && Boolean(itemId || packageName) && options.length === 0
+  const availableOptions = options.filter((item) => getWriteOffItemAvailability(item).available)
+
+  if (locked) {
+    return {
+      options,
+      selectedItemId: getWriteOffItemId(options[0]),
+      locked,
+      mismatch,
+      requiresManualSelection: false
+    }
+  }
+
+  if (isScan && packageName && availableOptions.length > 1) {
+    return {
+      options,
+      selectedItemId: '',
+      locked,
+      mismatch,
+      requiresManualSelection: true
+    }
+  }
+
+  const matchedById = itemId ? options.find((item) => getWriteOffItemId(item) === itemId) : undefined
+  const selectedItem = (
+    matchedById && getWriteOffItemAvailability(matchedById).available
+      ? matchedById
+      : availableOptions[0] || matchedById || options[0]
+  )
+
+  return {
+    options,
+    selectedItemId: getWriteOffItemId(selectedItem),
+    locked,
+    mismatch,
+    requiresManualSelection: false
+  }
+}
+
+export const shouldShowManualSelectionHint = (selection: WriteOffItemSelection, selectedItemId: string) => {
+  return selection.requiresManualSelection && !String(selectedItemId || '').trim()
+}
+
+export const getWriteOffStatusText = (item?: CommodityPackageConfig) => {
+  const status = item?.writeOffStatus ?? item?.packageStatus
+  const key = String(status)
+  const writtenOff = toNumber(item?.writeOffCount)
+  const total = toNumber(item?.count)
+  if (key === '1') return '已核销'
+  if ((status === undefined || status === null || status === '' || key === '0') && (writtenOff !== undefined || total !== undefined)) {
+    const writtenOffCount = Math.max(writtenOff ?? 0, 0)
+    const totalCount = Math.max(total ?? 0, 0)
+    if (writtenOffCount <= 0) return '待核销'
+    if (totalCount > 0 && writtenOffCount >= totalCount) return '已核销'
+    return '部分核销'
+  }
+  if (status === undefined || status === null || status === '') return ''
+  return statusTextMap[key] || key
+}

src/utils/writeOffRequestNo.ts

@@ -0,0 +1,21 @@
+export interface WriteOffRequestNoState {
+  targetKey: string
+  requestNo: string
+}
+
+export const createWriteOffRequestNo = () => {
+  if (globalThis.crypto?.randomUUID) return globalThis.crypto.randomUUID()
+  return `h5-${Date.now()}-${Math.random().toString(16).slice(2)}`
+}
+
+export const getReusableWriteOffRequestNo = (
+  state: WriteOffRequestNoState,
+  targetKey: string,
+  createRequestNo = createWriteOffRequestNo
+) => {
+  if (!state.requestNo || state.targetKey !== targetKey) {
+    state.targetKey = targetKey
+    state.requestNo = createRequestNo()
+  }
+  return state.requestNo
+}

src/views/orders/OrderDetailView.vue

@@ -7,6 +7,15 @@ import PageNav from '@/components/PageNav.vue'
 import StatusTag from '@/components/StatusTag.vue'
 import type { UserOrderDetail } from '@/types/order'
 import { canWriteOff, commodityTypeText, payStatusText } from '@/utils/constants'
+import {
+  getFirstAvailableWriteOffItem,
+  getWriteOffItemAvailability,
+  getWriteOffItemContent,
+  getWriteOffItemId,
+  getWriteOffItemName,
+  getWriteOffItemQuantity,
+  getWriteOffStatusText
+} from '@/utils/writeOffItem'
 
 const route = useRoute()
 const router = useRouter()
@@ -14,10 +23,8 @@ const detail = ref<UserOrderDetail | null>(null)
 const loading = ref(false)
 
 const orderId = computed(() => String(route.params.id || ''))
-const packageName = computed(() => {
-  const first = detail.value?.commodityPackageConfig?.[0]
-  return first?.packageName || first?.name || detail.value?.commodityName || ''
-})
+const firstWritableItem = computed(() => getFirstAvailableWriteOffItem(detail.value?.commodityPackageConfig || []))
+const canGoWriteOff = computed(() => Boolean(detail.value && canWriteOff(detail.value.orderStatus) && firstWritableItem.value))
 
 const loadDetail = async () => {
   loading.value = true
@@ -29,11 +36,13 @@ const loadDetail = async () => {
 }
 
 const goWriteOff = () => {
+  if (!firstWritableItem.value) return
   router.push({
     path: '/verify/confirm',
     query: {
       orderId: orderId.value,
-      packageName: packageName.value
+      orderWriteOffItemId: getWriteOffItemId(firstWritableItem.value),
+      packageName: getWriteOffItemName(firstWritableItem.value, detail.value?.commodityName)
     }
   })
 }
@@ -103,11 +112,24 @@ onMounted(loadDetail)
 
       <section class="panel detail-panel">
         <h2 class="section-title">套餐内容</h2>
-        <div v-for="item in detail.commodityPackageConfig" :key="item.packageName || item.name" class="package-row">
+        <div
+          v-for="(item, index) in detail.commodityPackageConfig"
+          :key="getWriteOffItemId(item) || `${getWriteOffItemName(item, detail.commodityName)}-${index}`"
+          class="package-row"
+        >
           <ReceiptText :size="17" />
           <div>
-            <strong>{{ item.packageName || item.name || detail.commodityName }}</strong>
-            <p>{{ item.packageContent || item.packageDesc || item.content }}</p>
+            <strong>{{ getWriteOffItemName(item, detail.commodityName) }}</strong>
+            <p v-if="getWriteOffItemContent(item)">{{ getWriteOffItemContent(item) }}</p>
+            <p>
+              <span v-if="getWriteOffStatusText(item)">{{ getWriteOffStatusText(item) }} · </span>
+              已核销 {{ getWriteOffItemQuantity(item).writtenOff }}{{ getWriteOffItemQuantity(item).unit }} /
+              剩余 {{ getWriteOffItemQuantity(item).writable }}{{ getWriteOffItemQuantity(item).unit }} /
+              总数 {{ getWriteOffItemQuantity(item).total }}{{ getWriteOffItemQuantity(item).unit }}
+            </p>
+            <p v-if="!getWriteOffItemAvailability(item).available" class="package-row__warning">
+              {{ getWriteOffItemAvailability(item).reason }}
+            </p>
           </div>
         </div>
         <p v-if="detail.commodityTip" class="tip-text">{{ detail.commodityTip }}</p>
@@ -133,9 +155,9 @@ onMounted(loadDetail)
 
   <footer v-if="detail && canWriteOff(detail.orderStatus)" class="fixed-action">
     <div class="fixed-action__inner">
-      <van-button block type="primary" @click="goWriteOff">
+      <van-button block type="primary" :disabled="!canGoWriteOff" @click="goWriteOff">
         <template #icon><CheckCircle2 :size="18" /></template>
-        立即核销
+        {{ canGoWriteOff ? '立即核销' : '暂无可核销明细' }}
       </van-button>
     </div>
   </footer>
@@ -242,6 +264,10 @@ onMounted(loadDetail)
   line-height: 1.5;
 }
 
+.package-row__warning {
+  color: var(--rose) !important;
+}
+
 .empty-line {
   padding: 12px;
   border-radius: var(--radius);

src/views/verify/VerifyConfirmView.vue

@@ -8,25 +8,34 @@ import PageNav from '@/components/PageNav.vue'
 import StatusTag from '@/components/StatusTag.vue'
 import type { CommodityPackageConfig, UserOrderDetail } from '@/types/order'
 import { canWriteOff } from '@/utils/constants'
+import {
+  getWriteOffItemAvailability,
+  getWriteOffItemContent,
+  getWriteOffItemId,
+  getWriteOffItemName,
+  getWriteOffItemQuantity,
+  getWriteOffStatusText,
+  resolveWriteOffItemSelection,
+  shouldShowManualSelectionHint,
+  toNumber
+} from '@/utils/writeOffItem'
+import {
+  getReusableWriteOffRequestNo,
+  type WriteOffRequestNoState
+} from '@/utils/writeOffRequestNo'
 
 const route = useRoute()
 const router = useRouter()
 const detail = ref<UserOrderDetail | null>(null)
-const packageName = ref('')
+const selectedItemId = ref('')
+const writeOffRequestNoState = ref<WriteOffRequestNoState>({ targetKey: '', requestNo: '' })
 const loading = ref(false)
 const submitting = ref(false)
 
 const orderId = computed(() => String(route.query.orderId || ''))
 const routePackageName = computed(() => String(route.query.packageName || '').trim())
-const isScanPackageLocked = computed(() => String(route.query.source || '') === 'scan' && Boolean(routePackageName.value))
-
-const toNumber = (value: unknown) => {
-  const number = Number(value)
-  return Number.isFinite(number) ? number : undefined
-}
-
-const getPackageName = (item?: CommodityPackageConfig) =>
-  (item?.packageName || item?.name || detail.value?.commodityName || '').trim()
+const routeWriteOffItemId = computed(() => String(route.query.orderWriteOffItemId || '').trim())
+const isScanSource = computed(() => String(route.query.source || '') === 'scan')
 
 const packageConfigs = computed<CommodityPackageConfig[]>(() => {
   if (!detail.value) return []
@@ -40,56 +49,61 @@ const packageConfigs = computed<CommodityPackageConfig[]>(() => {
   ]
 })
 
-const packageOptions = computed(() => {
-  if (!isScanPackageLocked.value) return packageConfigs.value
-  return packageConfigs.value.filter((item) => getPackageName(item) === routePackageName.value)
+const itemSelection = computed(() => {
+  return resolveWriteOffItemSelection(packageConfigs.value, {
+    source: String(route.query.source || ''),
+    orderWriteOffItemId: routeWriteOffItemId.value,
+    packageName: routePackageName.value,
+    fallbackName: detail.value?.commodityName
+  })
 })
 
-const packageMismatch = computed(() => isScanPackageLocked.value && packageOptions.value.length === 0)
+const packageOptions = computed(() => itemSelection.value.options)
+const isScanItemLocked = computed(() => itemSelection.value.locked)
+const packageMismatch = computed(() => itemSelection.value.mismatch)
+const showManualSelectionHint = computed(() => shouldShowManualSelectionHint(itemSelection.value, selectedItemId.value))
 
 const selectedPackage = computed(() => {
-  return packageOptions.value.find((item) => getPackageName(item) === packageName.value) || packageOptions.value[0]
+  return packageOptions.value.find((item) => getWriteOffItemId(item) === selectedItemId.value)
 })
 
-const writtenOffByRecord = computed(() => {
-  if (!detail.value) return 0
-  const selectedName = getPackageName(selectedPackage.value)
-  return (detail.value.writeOffRecordList || []).filter((record) => {
-    if (!selectedName) return true
-    return !record.packageName || record.packageName === selectedName
-  }).length
-})
+const quantityInfo = computed(() => getWriteOffItemQuantity(selectedPackage.value))
 
-const quantityInfo = computed(() => {
-  const total = toNumber(selectedPackage.value?.count) ?? toNumber(detail.value?.commodityAmount) ?? 0
-  const packageWriteOffCount = toNumber(selectedPackage.value?.writeOffCount)
-  const writtenOff =
-    packageWriteOffCount ??
-    (selectedPackage.value?.packageStatus === 1 && total > 0 ? total : writtenOffByRecord.value)
-
-  return {
-    total,
-    writtenOff,
-    writable: Math.max(total - writtenOff, 0),
-    unit: selectedPackage.value?.unit || ''
-  }
-})
+const selectedItemAvailability = computed(() => getWriteOffItemAvailability(selectedPackage.value))
+const selectedPackageName = computed(() => getWriteOffItemName(selectedPackage.value, detail.value?.commodityName))
 
 const canSubmit = computed(() => {
   return Boolean(
     detail.value &&
       canWriteOff(detail.value.orderStatus) &&
-      packageName.value &&
+      selectedItemId.value &&
       !packageMismatch.value &&
-      quantityInfo.value.writable > 0
+      selectedItemAvailability.value.available
   )
 })
 
 const formatCount = (value: number) => `${value}${quantityInfo.value.unit || ''}`
+const getErrorMessage = (error: unknown) => (error instanceof Error ? error.message : '核销失败')
+
+const hasShownToast = (error: unknown) => {
+  return Boolean(error && typeof error === 'object' && (error as { toastShown?: boolean }).toastShown)
+}
+
+const getItemLabel = (item: CommodityPackageConfig) => {
+  const quantity = getWriteOffItemQuantity(item)
+  const statusText = getWriteOffStatusText(item)
+  const parts = [`已核销 ${quantity.writtenOff}${quantity.unit}`, `剩余 ${quantity.writable}${quantity.unit}`]
+  if (statusText) parts.unshift(statusText)
+  return parts.join(' · ')
+}
+
+const canSelectItem = (item: CommodityPackageConfig) => {
+  return !isScanItemLocked.value && getWriteOffItemAvailability(item).available
+}
 
 const selectPackage = (item: CommodityPackageConfig) => {
-  if (isScanPackageLocked.value) return
-  packageName.value = getPackageName(item)
+  if (!canSelectItem(item)) return
+  selectedItemId.value = getWriteOffItemId(item)
 }
 
 const loadDetail = async () => {
@@ -101,13 +115,7 @@ const loadDetail = async () => {
   loading.value = true
   try {
     detail.value = await fetchOrderDetail(orderId.value)
-    const matchedPackage = routePackageName.value
-      ? packageConfigs.value.find((item) => getPackageName(item) === routePackageName.value)
-      : undefined
-    packageName.value =
-      routePackageName.value && (matchedPackage || isScanPackageLocked.value)
-        ? routePackageName.value
-        : getPackageName(packageConfigs.value[0])
+    selectedItemId.value = itemSelection.value.selectedItemId
   } finally {
     loading.value = false
   }
@@ -120,47 +128,52 @@ const submit = async () => {
     return
   }
   if (packageMismatch.value) {
-    showToast('扫码套餐不属于当前订单')
+    showToast(routeWriteOffItemId.value ? '扫码明细不属于当前订单' : '扫码套餐不属于当前订单')
     return
   }
-  if (!packageName.value) {
-    showToast('请选择核销套餐')
+  if (!selectedItemId.value || !selectedPackage.value) {
+    showToast('请选择核销明细')
     return
   }
-  if (quantityInfo.value.writable <= 0) {
-    showToast('当前套餐商品已核销完')
+  if (!selectedItemAvailability.value.available) {
+    showToast(selectedItemAvailability.value.reason)
+    return
+  }
+  try {
+    await showConfirmDialog({
+      title: '确认核销',
+      message: `订单 ${detail.value.orderId} 将核销「${selectedPackageName.value}」，核销后不可撤回。`
+    })
+  } catch {
     return
   }
-  await showConfirmDialog({
-    title: '确认核销',
-    message: `订单 ${detail.value.orderId} 将核销「${packageName.value}」，核销后不可撤回。`
-  })
   submitting.value = true
+  const requestNo = getReusableWriteOffRequestNo(
+    writeOffRequestNoState.value,
+    `${detail.value.orderId}:${selectedItemId.value}`
+  )
   try {
     const result = await writeOffOrder({
       orderId: detail.value.orderId,
-      packageName: packageName.value
+      orderWriteOffItemId: selectedItemId.value,
+      writeOffRequestNo: requestNo
     })
     router.replace({
       path: '/verify/result',
       query: {
         success: String(result.success),
         orderId: result.orderId,
-        packageName: result.packageName,
+        orderWriteOffItemId: result.orderWriteOffItemId || selectedItemId.value,
+        packageName: selectedPackageName.value,
         message: result.message,
         operatedAt: result.operatedAt
       }
     })
   } catch (error) {
-    router.replace({
-      path: '/verify/result',
-      query: {
-        success: 'false',
-        orderId: detail.value.orderId,
-        packageName: packageName.value,
-        message: error instanceof Error ? error.message : '核销失败'
-      }
-    })
+    const message = getErrorMessage(error)
+    if (!hasShownToast(error)) {
+      showToast(message)
+    }
   } finally {
     submitting.value = false
   }
@@ -190,25 +203,41 @@ onMounted(loadDetail)
 
       <section class="panel detail-panel">
         <h2 class="section-title">核销内容</h2>
-        <van-radio-group v-model="packageName">
+        <van-radio-group v-model="selectedItemId">
           <van-cell-group class="package-group">
-            <van-cell v-if="packageMismatch" title="扫码套餐不属于当前订单" label="请返回重新扫码或联系管理员核对订单二维码" />
             <van-cell
-              v-for="item in packageOptions"
-              :key="getPackageName(item)"
-              :clickable="!isScanPackageLocked"
+              v-if="packageMismatch"
+              :title="routeWriteOffItemId ? '扫码明细不属于当前订单' : '扫码套餐不属于当前订单'"
+              label="请返回重新扫码或联系管理员核对订单二维码"
+            />
+            <van-cell
+              v-for="(item, index) in packageOptions"
+              :key="getWriteOffItemId(item) || `${getWriteOffItemName(item, detail.commodityName)}-${index}`"
+              :clickable="canSelectItem(item)"
               @click="selectPackage(item)"
             >
               <template #title>
                 <div class="package-title">
                   <ReceiptText :size="17" />
-                  <span>{{ getPackageName(item) }}</span>
-                  <van-tag v-if="isScanPackageLocked" type="success" plain>扫码指定</van-tag>
+                  <span>{{ getWriteOffItemName(item, detail.commodityName) }}</span>
+                  <van-tag v-if="isScanItemLocked" type="success" plain>扫码指定</van-tag>
+                  <van-tag v-else-if="isScanSource && routePackageName" type="primary" plain>扫码匹配</van-tag>
+                </div>
+              </template>
+              <template #label>
+                <div class="package-label">
+                  <span v-if="getWriteOffItemContent(item)">{{ getWriteOffItemContent(item) }}</span>
+                  <span>{{ getItemLabel(item) }}</span>
+                  <span v-if="!getWriteOffItemAvailability(item).available" class="package-label__warning">
+                    {{ getWriteOffItemAvailability(item).reason }}
+                  </span>
                 </div>
               </template>
-              <template #label>{{ item.packageContent || item.packageDesc || item.content }}</template>
               <template #right-icon>
-                <van-radio :name="getPackageName(item)" :disabled="isScanPackageLocked" />
+                <van-radio
+                  :name="getWriteOffItemId(item)"
+                  :disabled="isScanItemLocked || !getWriteOffItemAvailability(item).available"
+                />
               </template>
             </van-cell>
           </van-cell-group>
@@ -243,6 +272,14 @@ onMounted(loadDetail)
         <BadgeCheck :size="20" />
         <span>该订单当前不可核销，请返回订单详情核对状态。</span>
       </section>
+      <section v-else-if="showManualSelectionHint" class="panel warning-panel">
+        <BadgeCheck :size="20" />
+        <span>扫码套餐匹配到多个可核销明细，请选择后再核销。</span>
+      </section>
+      <section v-else-if="selectedPackage && !selectedItemAvailability.available" class="panel warning-panel">
+        <BadgeCheck :size="20" />
+        <span>{{ selectedItemAvailability.reason }}</span>
+      </section>
     </template>
   </section>
 
@@ -309,6 +346,15 @@ onMounted(loadDetail)
   line-height: 1.5;
 }
 
+.package-label {
+  display: grid;
+  gap: 3px;
+}
+
+.package-label__warning {
+  color: var(--rose);
+}
+
 .warning-panel {
   display: flex;
   gap: 8px;

src/views/verify/VerifyView.vue

@@ -57,6 +57,7 @@ const goConfirm = (payload: WriteOffCodePayload) => {
     query: {
       orderId: payload.orderId,
       source: 'scan',
+      ...(payload.orderWriteOffItemId ? { orderWriteOffItemId: payload.orderWriteOffItemId } : {}),
       ...(payload.packageName ? { packageName: payload.packageName } : {})
     }
   })