彻底重构-4

2026-04-09 15:51:24 +08:00
parent 60054adcc4
commit 4c395103a9
28 changed files with 1917 additions and 404 deletions
@@ -8,15 +8,28 @@ import {
  saveAgisoShopConfigMap,
 } from '../platforms/agiso/shop-config-service.js'
 import { getClaimTokenById, updateClaimToken } from '../../repositories/claim-token-repo.js'
-import { createCdks, getCdkById, invalidateCdk, listCdks, releaseReservedCdk } from '../../repositories/cdk-repo.js'
+import {
+  createInventoryItems,
+  getInventoryItemById,
+  invalidateInventoryItem,
+  listInventoryItems,
+  markInventoryItemDelivered,
+  releaseReservedInventoryItem,
+} from '../../repositories/inventory-repo.js'
 import { listOrderItemsByOrderId } from '../../repositories/order-item-repo.js'
 import { getOrderById, listOrders } from '../../repositories/order-repo.js'
 import { getTaskById, listTasks, listTasksByOrderId, updateTask } from '../../repositories/task-repo.js'
+import {
+  getTaskInventoryBindingById,
+  listTaskInventoryBindingsByTaskId,
+  listTaskInventoryBindingSummariesByTaskIds,
+} from '../../repositories/task-inventory-binding-repo.js'
+import { createTaskEvent, listTaskEventsByTaskId } from '../../repositories/task-event-repo.js'
 import { getWebhookEventById, listWebhookEvents, listWebhookEventsByOrderId } from '../../repositories/webhook-event-repo.js'
 import { createHttpError } from '../../utils/http.js'
 import { formatFenToAmount, normalizeFen, parseAmountToFen } from '../../utils/money.js'
 import { nowIso } from '../../utils/time.js'
-import { reserveCdkForTask } from '../order/cdk-service.js'
+import { reserveInventoryForTask } from '../order/inventory-service.js'
 import { replayAgisoTradeWebhookEvent } from '../order/webhook-service.js'
 import { normalizeDateQuery, normalizePage, normalizePageSize, safeParseJson } from './admin-query-utils.js'

@@ -102,6 +115,7 @@ export async function getAdminOrderDetail(orderId) {
    listTasksByOrderId(order.id),
    listWebhookEventsByOrderId(order.id),
  ])
+  const taskBindingSummaryMap = await getTaskBindingSummaryMap(tasks.map((task) => task.id))
  const itemSummary = summarizeOrderItems(items)

  return {
@@ -125,7 +139,7 @@ export async function getAdminOrderDetail(orderId) {
      updatedAt: order.updated_at,
      itemSummary,
      rawPayload: safeParseJson(order.raw_payload_json),
-      bindingSummary: buildOrderBindingSummary(tasks),
+      bindingSummary: buildOrderBindingSummary(tasks, taskBindingSummaryMap),
    },
    items: items.map((item) => ({
      orderItemId: item.id,
@@ -136,7 +150,7 @@ export async function getAdminOrderDetail(orderId) {
      deliveryMode: resolveOrderItemDeliveryMode(tasks, item.id),
      spec: safeParseJson(item.spec_json),
    })),
-    tasks: tasks.map(mapAdminTaskSummary),
+    tasks: tasks.map((task) => mapAdminTaskSummary(task, getTaskBindingSummary(taskBindingSummaryMap, task.id))),
    webhookEvents: webhookEvents.map((event) => ({
      eventId: event.id,
      provider: event.provider || 'agiso',
@@ -167,9 +181,10 @@ export async function getAdminTasks(query = {}) {
    dateFrom: normalizeDateQuery(query.dateFrom),
    dateTo: normalizeDateQuery(query.dateTo, true),
  })
+  const taskBindingSummaryMap = await getTaskBindingSummaryMap(items.map((item) => item.id))

  return {
-    items: items.map(mapAdminTaskListItem),
+    items: items.map((item) => mapAdminTaskListItem(item, getTaskBindingSummary(taskBindingSummaryMap, item.id))),
    pagination: { page, pageSize, total },
  }
 }
@@ -184,22 +199,27 @@ export async function getAdminTaskDetail(taskId) {
    })
  }

-  const [order, claimToken, cdk] = await Promise.all([
+  const [order, claimToken, inventoryItem, taskEvents, inventoryBindings] = await Promise.all([
    getOrderById(task.order_id),
    getTaskPrimaryClaimTokenId(task) ? getClaimTokenById(getTaskPrimaryClaimTokenId(task)) : Promise.resolve(null),
-    getTaskPrimaryInventoryItemId(task) ? getCdkById(getTaskPrimaryInventoryItemId(task)) : Promise.resolve(null),
+    getTaskPrimaryInventoryItemId(task) ? getInventoryItemById(getTaskPrimaryInventoryItemId(task)) : Promise.resolve(null),
+    listTaskEventsByTaskId(task.id),
+    listTaskInventoryBindingsByTaskId(task.id),
  ])
  const orderItems = order ? await listOrderItemsByOrderId(order.id) : []
  const orderItem = orderItems.find((item) => item.id === task.order_item_id) || null
+  const taskContext = parseTaskContext(task)
+  const taskBindingSummary = createTaskBindingSummaryFromBindings(inventoryBindings)
+  const mappedInventoryBindings = inventoryBindings.map((binding) => mapAdminTaskInventoryBinding(binding, task))

  return {
    task: mapAdminTaskListItem({
      ...task,
      sku_code: orderItem?.sku_code || '',
      sku_name: orderItem?.sku_name || '',
-      cdk_code: cdk?.cdk_code || '',
+      inventory_display_value: inventoryItem?.display_value || '',
      claim_token: claimToken?.token || '',
-    }),
+    }, taskBindingSummary),
    order: order
      ? {
        orderId: order.id,
@@ -222,29 +242,34 @@ export async function getAdminTaskDetail(taskId) {
      : null,
    claimToken: claimToken
      ? {
-        claimTokenId: claimToken.id,
+        primaryClaimTokenId: claimToken.id,
        token: claimToken.token,
        status: claimToken.status,
        expiredAt: claimToken.expired_at,
      }
      : null,
-    cdk: cdk
+    inventory: inventoryItem
      ? {
-        cdkId: cdk.id,
-        skuCode: cdk.sku_code,
-        batchNo: cdk.batch_no,
-        cdkCode: cdk.cdk_code,
-        status: cdk.status,
+        inventoryItemId: inventoryItem.id,
+        skuCode: inventoryItem.sku_code,
+        batchNo: inventoryItem.batch_no,
+        credentialType: inventoryItem.credential_type || 'tencent_code',
+        displayValue: inventoryItem.display_value,
+        status: inventoryItem.status,
      }
      : null,
+    inventoryBindings: mappedInventoryBindings,
    artifacts: safeParseJson(task.artifacts_json),
    screenshotUrl: task.screenshot_path ? `/api/v1/admin/tasks/${task.id}/screenshot` : '',
+    manualDispatch: mapManualDispatchContext(taskContext.manualDispatch),
+    events: taskEvents.map(mapAdminTaskEvent),
    operations: {
-      canRetry: ['retry_pending', 'manual_review', 'waiting_inventory'].includes(task.task_status),
-      canReleaseCdk: Boolean(getTaskPrimaryInventoryItemId(task) && ['link_generated', 'retry_pending', 'manual_review', 'waiting_inventory', 'closed'].includes(task.task_status)),
-      canRegenerateClaimLink: ['link_generated', 'claimed', 'role_confirmed', 'retry_pending', 'manual_review'].includes(task.task_status),
+      canRetry: !isManualDispatchTask(task) && ['retry_pending', 'manual_review', 'waiting_inventory'].includes(task.task_status),
+      canReleaseInventory: mappedInventoryBindings.some((binding) => binding.canRelease),
+      canRegenerateClaimLink: !isManualDispatchTask(task) && ['link_generated', 'claimed', 'role_confirmed', 'retry_pending', 'manual_review'].includes(task.task_status),
      canClose: !['redeemed', 'closed'].includes(task.task_status),
      canMarkManualReview: !['redeemed', 'closed', 'manual_review'].includes(task.task_status),
+      canCompleteManualDispatch: isManualDispatchTask(task) && !['redeemed', 'closed'].includes(task.task_status),
    },
  }
 }
@@ -262,10 +287,10 @@ export async function getAdminTaskScreenshotPath(taskId) {
  return task.screenshot_path
 }

-export async function getAdminCdks(query = {}) {
+export async function getAdminInventoryItems(query = {}) {
  const page = normalizePage(query.page)
  const pageSize = normalizePageSize(query.pageSize)
-  const { items, total } = await listCdks({
+  const { items, total } = await listInventoryItems({
    page,
    pageSize,
    skuCode: String(query.skuCode || '').trim(),
@@ -274,29 +299,29 @@ export async function getAdminCdks(query = {}) {
  })

  return {
-    items: await Promise.all(items.map((item) => mapAdminCdkListItem(item))),
+    items: await Promise.all(items.map((item) => mapAdminInventoryListItem(item))),
    pagination: { page, pageSize, total },
  }
 }

-export async function createAdminCdk(payload = {}) {
+export async function createAdminInventoryItem(payload = {}) {
  const skuCode = String(payload.skuCode || '').trim()
-  const cdkCode = String(payload.cdkCode || '').trim()
+  const displayValue = String(payload.displayValue || '').trim()
  const batchNo = String(payload.batchNo || '').trim()
  const credentialType = String(payload.credentialType || 'tencent_code').trim() || 'tencent_code'

-  if (!skuCode || !cdkCode) {
-    throw createHttpError('缺少 skuCode 或 cdkCode', {
+  if (!skuCode || !displayValue) {
+    throw createHttpError('缺少 skuCode 或 displayValue', {
      statusCode: 400,
-      errorCode: 'admin_cdk_create_invalid',
+      errorCode: 'admin_inventory_create_invalid',
    })
  }

  const now = nowIso()
-  const created = await createCdks([
+  const created = await createInventoryItems([
    {
      skuCode,
-      cdkCode,
+      displayValue,
      batchNo,
      credentialType,
      createdAt: now,
@@ -305,31 +330,31 @@ export async function createAdminCdk(payload = {}) {
  ])

  if (created === 0) {
-    throw createHttpError('CDK 已存在，不能重复新增', {
+    throw createHttpError('库存凭据已存在，不能重复新增', {
      statusCode: 409,
-      errorCode: 'admin_cdk_duplicate',
+      errorCode: 'admin_inventory_duplicate',
    })
  }

-  const { items } = await listCdks({
+  const { items } = await listInventoryItems({
    page: 1,
    pageSize: 1,
    skuCode,
  })
-  const createdItem = items.find((item) => item.cdk_code === cdkCode) || null
+  const createdItem = items.find((item) => item.display_value === displayValue) || null

  return {
-    cdk: createdItem ? await mapAdminCdkListItem(createdItem) : null,
+    inventoryItem: createdItem ? await mapAdminInventoryListItem(createdItem) : null,
  }
 }

-export async function importAdminCdks(payload = {}) {
-  const rows = normalizeCdkImportRows(payload)
+export async function importAdminInventoryItems(payload = {}) {
+  const rows = normalizeInventoryImportRows(payload)

  if (rows.length === 0) {
-    throw createHttpError('没有可导入的 CDK 数据', {
+    throw createHttpError('没有可导入的库存凭据数据', {
      statusCode: 400,
-      errorCode: 'admin_cdk_import_empty',
+      errorCode: 'admin_inventory_import_empty',
    })
  }

@@ -337,13 +362,13 @@ export async function importAdminCdks(payload = {}) {
  const normalizedRows = rows.map((row) => ({
    skuCode: row.skuCode,
    batchNo: row.batchNo,
-    cdkCode: row.cdkCode,
+    displayValue: row.displayValue,
    credentialType: row.credentialType,
    createdAt: now,
    updatedAt: now,
  }))

-  const created = await createCdks(normalizedRows)
+  const created = await createInventoryItems(normalizedRows)

  return {
    total: normalizedRows.length,
@@ -352,38 +377,38 @@ export async function importAdminCdks(payload = {}) {
  }
 }

-export async function releaseAdminInventoryCdk(cdkId) {
-  const cdk = await getRequiredCdk(cdkId)
+export async function releaseAdminInventoryItem(inventoryItemId) {
+  const inventoryItem = await getRequiredInventoryItem(inventoryItemId)

-  if (cdk.status !== 'reserved') {
-    throw createHttpError('当前 CDK 不是预占状态，不能释放', {
+  if (inventoryItem.status !== 'reserved') {
+    throw createHttpError('当前库存项不是预占状态，不能释放', {
      statusCode: 409,
-      errorCode: 'admin_cdk_release_not_allowed',
+      errorCode: 'admin_inventory_release_not_allowed',
    })
  }

-  const updated = await releaseReservedCdk(cdk.id, nowIso())
+  const updated = await releaseReservedInventoryItem(inventoryItem.id, nowIso())

  return {
-    cdk: await mapAdminCdkListItem(updated),
+    inventoryItem: await mapAdminInventoryListItem(updated),
  }
 }

-export async function invalidateAdminCdk(cdkId, payload = {}) {
-  const cdk = await getRequiredCdk(cdkId)
+export async function invalidateAdminInventoryItem(inventoryItemId, payload = {}) {
+  const inventoryItem = await getRequiredInventoryItem(inventoryItemId)

-  if (cdk.status !== 'available') {
-    throw createHttpError('只有可用 CDK 才能作废，请先释放预占', {
+  if (inventoryItem.status !== 'available') {
+    throw createHttpError('只有可用库存项才能作废，请先释放预占', {
      statusCode: 409,
-      errorCode: 'admin_cdk_invalidate_not_allowed',
+      errorCode: 'admin_inventory_invalidate_not_allowed',
    })
  }

  const reason = String(payload.reason || '').trim() || '后台手动作废'
-  const updated = await invalidateCdk(cdk.id, reason, nowIso())
+  const updated = await invalidateInventoryItem(inventoryItem.id, reason, nowIso())

  return {
-    cdk: await mapAdminCdkListItem(updated),
+    inventoryItem: await mapAdminInventoryListItem(updated),
  }
 }

@@ -560,6 +585,13 @@ export async function retryAdminTask(taskId) {
  const task = await getRequiredTask(taskId)
  const now = nowIso()

+  if (isManualDispatchTask(task)) {
+    throw createHttpError('人工履约任务不能走自动重试，请在详情页直接回写人工履约结果', {
+      statusCode: 409,
+      errorCode: 'admin_task_manual_dispatch_retry_not_allowed',
+    })
+  }
+
  if (!['retry_pending', 'manual_review', 'waiting_inventory'].includes(task.task_status)) {
    throw createHttpError('当前任务状态不允许重试', {
      statusCode: 409,
@@ -580,7 +612,7 @@ export async function retryAdminTask(taskId) {
  let token = ''

  if (!reservedInventoryItemId) {
-    const reserved = await reserveCdkForTask({
+    const reserved = await reserveInventoryForTask({
      skuCode: orderItem?.sku_code || '',
      taskId: task.id,
      credentialType: primaryRequirement?.credentialType || 'tencent_code',
@@ -589,7 +621,7 @@ export async function retryAdminTask(taskId) {

    if (!reserved) {
      nextStatus = 'waiting_inventory'
-      lastError = '库存不足，等待可用 CDK'
+      lastError = '库存不足，等待可用库存凭据'
    } else {
      reservedInventoryItemId = reserved.id
    }
@@ -624,29 +656,29 @@ export async function retryAdminTask(taskId) {
  return payload
 }

-export async function releaseAdminTaskCdk(taskId) {
+export async function releaseAdminTaskInventory(taskId) {
  const task = await getRequiredTask(taskId)
  const primaryInventoryItemId = getTaskPrimaryInventoryItemId(task)

  if (!primaryInventoryItemId) {
-    throw createHttpError('当前任务没有预占 CDK', {
+    throw createHttpError('当前任务没有预占库存项', {
      statusCode: 409,
-      errorCode: 'admin_task_no_reserved_cdk',
+      errorCode: 'admin_task_no_reserved_inventory',
    })
  }

  if (task.task_status === 'redeemed') {
-    throw createHttpError('已兑换任务不能释放 CDK', {
+    throw createHttpError('已兑换任务不能释放库存项', {
      statusCode: 409,
      errorCode: 'admin_task_release_not_allowed',
    })
  }

-  await releaseReservedCdk(primaryInventoryItemId, nowIso())
+  await releaseReservedInventoryItem(primaryInventoryItemId, nowIso())
  const updatedTask = await updateTask(task.id, {
    task_status: 'waiting_inventory',
    inventory_status: 'pending',
-    last_error: '已手动释放预占 CDK',
+    last_error: '已手动释放预占库存项',
    updated_at: nowIso(),
  })

@@ -655,10 +687,84 @@ export async function releaseAdminTaskCdk(taskId) {
  }
 }

+export async function releaseAdminTaskInventoryBinding(taskId, bindingId) {
+  const task = await getRequiredTask(taskId)
+  const binding = await getTaskInventoryBindingById(Number(bindingId))
+
+  if (!binding || Number(binding.task_id) !== Number(task.id)) {
+    throw createHttpError('任务库存绑定不存在', {
+      statusCode: 404,
+      errorCode: 'admin_task_inventory_binding_not_found',
+    })
+  }
+
+  if (String(binding.binding_status || '').trim() !== 'reserved') {
+    throw createHttpError('当前库存绑定不是预占状态，不能释放', {
+      statusCode: 409,
+      errorCode: 'admin_task_inventory_binding_release_not_allowed',
+    })
+  }
+
+  if (task.task_status === 'redeemed') {
+    throw createHttpError('已兑换任务不能释放库存绑定', {
+      statusCode: 409,
+      errorCode: 'admin_task_release_not_allowed',
+    })
+  }
+
+  const now = nowIso()
+  await releaseReservedInventoryItem(binding.inventory_item_id, now)
+
+  const remainingBindings = await listTaskInventoryBindingsByTaskId(task.id)
+  const activeBindings = remainingBindings.filter((item) => ['reserved', 'consumed'].includes(String(item.binding_status || '').trim()))
+  const hasReservedBindings = activeBindings.some((item) => String(item.binding_status || '').trim() === 'reserved')
+  const hasConsumedBindings = activeBindings.some((item) => String(item.binding_status || '').trim() === 'consumed')
+  const nextInventoryStatus = hasReservedBindings ? 'reserved' : (hasConsumedBindings ? 'consumed' : 'pending')
+  const nextTaskStatus = !activeBindings.length && !['closed', 'expired'].includes(String(task.task_status || '').trim())
+    ? 'waiting_inventory'
+    : task.task_status
+
+  if (!hasReservedBindings) {
+    const primaryClaimTokenId = getTaskPrimaryClaimTokenId(task)
+    if (primaryClaimTokenId) {
+      await updateClaimToken(primaryClaimTokenId, {
+        status: 'revoked',
+        updated_at: now,
+      })
+    }
+  }
+
+  const updatedTask = await updateTask(task.id, {
+    task_status: nextTaskStatus,
+    inventory_status: nextInventoryStatus,
+    last_error: !activeBindings.length ? '已手动释放预占库存绑定' : (task.last_error || ''),
+    updated_at: now,
+  })
+
+  await createTaskEvent(task.id, 'inventory_binding_released', {
+    bindingId: Number(binding.id),
+    inventoryItemId: Number(binding.inventory_item_id),
+    roleKey: String(binding.role_key || '').trim(),
+  }, now)
+
+  return {
+    task: mapTaskActionPayload(updatedTask),
+    bindingId: Number(binding.id),
+    inventoryItemId: Number(binding.inventory_item_id),
+  }
+}
+
 export async function regenerateAdminTaskClaimLink(taskId) {
  const task = await getRequiredTask(taskId)
  const primaryClaimTokenId = getTaskPrimaryClaimTokenId(task)

+  if (isManualDispatchTask(task)) {
+    throw createHttpError('人工履约任务不需要领取链接，请直接回写人工履约结果', {
+      statusCode: 409,
+      errorCode: 'admin_task_manual_dispatch_claim_not_allowed',
+    })
+  }
+
  if (['redeemed', 'closed'].includes(task.task_status)) {
    throw createHttpError('当前任务状态不允许重新生成领取链接', {
      statusCode: 409,
@@ -715,6 +821,7 @@ export async function markAdminTaskManualReview(taskId) {
  const task = await getRequiredTask(taskId)
  const updatedTask = await updateTask(task.id, {
    task_status: 'manual_review',
+    delivery_status: task.delivery_status || 'pending',
    last_error: task.last_error || '已转人工处理',
    updated_at: nowIso(),
  })
@@ -724,7 +831,88 @@ export async function markAdminTaskManualReview(taskId) {
  }
 }

-function mapAdminTaskSummary(task) {
+export async function completeAdminTaskManualDispatch(taskId, payload = {}, session = null) {
+  const task = await getRequiredTask(taskId)
+
+  if (!isManualDispatchTask(task)) {
+    throw createHttpError('当前任务不是人工履约任务', {
+      statusCode: 409,
+      errorCode: 'admin_task_not_manual_dispatch',
+    })
+  }
+
+  if (['redeemed', 'closed'].includes(task.task_status)) {
+    throw createHttpError('当前任务已经完结，不能重复回写人工履约结果', {
+      statusCode: 409,
+      errorCode: 'admin_task_manual_dispatch_already_completed',
+    })
+  }
+
+  const now = nowIso()
+  const outcome = normalizeManualDispatchOutcome(payload.outcome)
+  const resultMessage = String(payload.resultMessage || '').trim()
+  const deliveryReference = String(payload.deliveryReference || '').trim()
+  const deliveredCredential = String(payload.deliveredCredential || '').trim()
+  const context = parseTaskContext(task)
+  const inventoryItemId = getTaskPrimaryInventoryItemId(task)
+  const resultCode = outcome === 'failed' ? 'manual_dispatch_failed' : 'manual_dispatch_delivered'
+  const fallbackMessage = outcome === 'failed' ? '人工履约失败' : '人工履约已完成'
+  const nextTaskStatus = outcome === 'failed' ? 'closed' : 'redeemed'
+  const nextDeliveryStatus = outcome === 'failed' ? 'failed' : 'delivered'
+  const nextInventoryStatus = outcome === 'delivered' && inventoryItemId
+    ? 'consumed'
+    : task.inventory_status || 'not_required'
+  const manualDispatch = {
+    outcome,
+    deliveryReference,
+    deliveredCredential,
+    resultMessage: resultMessage || fallbackMessage,
+    completedAt: now,
+    completedBy: session
+      ? {
+        userId: Number(session.userId || 0),
+        username: String(session.username || ''),
+        role: String(session.role || ''),
+      }
+      : null,
+  }
+
+  if (outcome === 'delivered' && inventoryItemId) {
+    await markInventoryItemDelivered(inventoryItemId, now)
+  }
+
+  const updatedTask = await updateTask(task.id, {
+    task_status: nextTaskStatus,
+    inventory_status: nextInventoryStatus,
+    delivery_status: nextDeliveryStatus,
+    result_code: resultCode,
+    result_message: resultMessage || fallbackMessage,
+    user_action_status: 'not_required',
+    last_error: outcome === 'failed' ? (resultMessage || fallbackMessage) : '',
+    redeemed_at: outcome === 'delivered' ? now : task.redeemed_at || null,
+    context_json: JSON.stringify({
+      ...context,
+      manualDispatch,
+    }),
+    updated_at: now,
+  })
+
+  await createTaskEvent(task.id, 'manual_dispatch_completed', {
+    outcome,
+    resultCode,
+    resultMessage: resultMessage || fallbackMessage,
+    deliveryReference,
+    deliveredCredentialMasked: maskCode(deliveredCredential),
+    completedBy: manualDispatch.completedBy,
+  }, now)
+
+  return {
+    outcome,
+    task: mapTaskActionPayload(updatedTask),
+  }
+}
+
+function mapAdminTaskSummary(task, bindingSummary = createEmptyTaskBindingSummary()) {
  const binding = buildTaskBindingState(task)

  return {
@@ -740,6 +928,7 @@ function mapAdminTaskSummary(task) {
    redeemedAt: task.redeemed_at,
    lastError: task.last_error,
    retryCount: getTaskRetryCount(task),
+    bindingSummary,
    createdAt: task.created_at,
    updatedAt: task.updated_at,
  }
@@ -883,17 +1072,17 @@ async function mapAdminWebhookEvent(item, { includeRaw = false } = {}) {
  }
 }

-async function mapAdminCdkListItem(item) {
+async function mapAdminInventoryListItem(item) {
  const task = item.reserved_by_task_id ? await getTaskById(item.reserved_by_task_id) : null
  const order = task?.order_id ? await getOrderById(task.order_id) : null
  const binding = buildTaskBindingState(task)

  return {
-    cdkId: item.id,
+    inventoryItemId: item.id,
    skuCode: item.sku_code,
    batchNo: item.batch_no,
-    cdkCode: item.cdk_code,
    credentialType: item.credential_type || 'tencent_code',
+    displayValue: item.display_value,
    status: item.status,
    reservedByTaskId: item.reserved_by_task_id,
    reservedByTaskNo: task?.task_no || '',
@@ -909,15 +1098,17 @@ async function mapAdminCdkListItem(item) {

 function mapTaskActionPayload(task) {
  const inventoryItemId = getTaskPrimaryInventoryItemId(task)
-  const claimTokenId = getTaskPrimaryClaimTokenId(task)
+  const primaryClaimTokenId = getTaskPrimaryClaimTokenId(task)

  return {
    taskId: task.id,
    taskNo: task.task_no,
    status: task.task_status,
+    deliveryStatus: task.delivery_status,
+    resultCode: task.result_code,
+    resultMessage: task.result_message,
    inventoryItemId,
-    claimTokenId,
-    reservedCdkId: inventoryItemId,
+    primaryClaimTokenId,
    lastError: task.last_error,
    updatedAt: task.updated_at,
  }
@@ -936,20 +1127,20 @@ async function getRequiredTask(taskId) {
  return task
 }

-async function getRequiredCdk(cdkId) {
-  const cdk = await getCdkById(Number(cdkId))
+async function getRequiredInventoryItem(inventoryItemId) {
+  const inventoryItem = await getInventoryItemById(Number(inventoryItemId))

-  if (!cdk) {
-    throw createHttpError('CDK 不存在', {
+  if (!inventoryItem) {
+    throw createHttpError('库存项不存在', {
      statusCode: 404,
-      errorCode: 'admin_cdk_not_found',
+      errorCode: 'admin_inventory_not_found',
    })
  }

-  return cdk
+  return inventoryItem
 }

-function mapAdminTaskListItem(task) {
+function mapAdminTaskListItem(task, bindingSummary = createEmptyTaskBindingSummary()) {
  const binding = buildTaskBindingState(task)

  return {
@@ -959,6 +1150,10 @@ function mapAdminTaskListItem(task) {
    skuCode: task.sku_code || '',
    skuName: task.sku_name || '',
    status: task.task_status,
+    executorKey: task.executor_key || '',
+    deliveryStatus: task.delivery_status || '',
+    resultCode: task.result_code || '',
+    resultMessage: task.result_message || '',
    systemBindingStatus: binding.systemBindingStatus,
    userBindingStatus: binding.userBindingStatus,
    loginType: task.login_type,
@@ -969,21 +1164,120 @@ function mapAdminTaskListItem(task) {
    roleConfirmedAt: task.role_confirmed_at,
    redeemedAt: task.redeemed_at,
    retryCount: getTaskRetryCount(task),
+    bindingSummary,
    lastError: task.last_error,
    createdAt: task.created_at,
    updatedAt: task.updated_at,
-    reservedCdkCodeMasked: maskCode(task.primary_inventory_display_value),
+    inventoryDisplayMasked: maskCode(task.primary_inventory_display_value),
+    inventoryCredentialType: String(task.primary_inventory_credential_type || '').trim(),
    claimToken: task.primary_claim_token || task.claim_token || '',
    screenshotPath: task.screenshot_path || '',
  }
 }

+function mapAdminTaskEvent(event) {
+  const payload = safeParseJson(event.payload_json)
+
+  return {
+    eventId: event.id,
+    eventType: String(event.event_type || '').trim(),
+    payload: normalizeRecord(payload),
+    createdAt: event.created_at,
+  }
+}
+
+function createEmptyTaskBindingSummary() {
+  return {
+    totalBindingCount: 0,
+    reservedBindingCount: 0,
+    consumedBindingCount: 0,
+    releasedBindingCount: 0,
+    roleKeys: [],
+  }
+}
+
+async function getTaskBindingSummaryMap(taskIds = []) {
+  const rows = await listTaskInventoryBindingSummariesByTaskIds(taskIds)
+  const output = new Map()
+
+  for (const row of rows) {
+    output.set(Number(row.task_id), {
+      totalBindingCount: Number(row.total_binding_count || 0),
+      reservedBindingCount: Number(row.reserved_binding_count || 0),
+      consumedBindingCount: Number(row.consumed_binding_count || 0),
+      releasedBindingCount: Number(row.released_binding_count || 0),
+      roleKeys: Array.isArray(row.role_keys)
+        ? row.role_keys.map((value) => String(value || '').trim()).filter(Boolean)
+        : [],
+    })
+  }
+
+  return output
+}
+
+function getTaskBindingSummary(summaryMap, taskId) {
+  return summaryMap.get(Number(taskId)) || createEmptyTaskBindingSummary()
+}
+
+function createTaskBindingSummaryFromBindings(bindings = []) {
+  const normalizedBindings = Array.isArray(bindings) ? bindings : []
+  const roleKeys = Array.from(new Set(normalizedBindings
+    .map((binding) => String(binding?.role_key || '').trim())
+    .filter(Boolean)))
+
+  return {
+    totalBindingCount: normalizedBindings.length,
+    reservedBindingCount: normalizedBindings.filter((binding) => String(binding?.binding_status || '') === 'reserved').length,
+    consumedBindingCount: normalizedBindings.filter((binding) => String(binding?.binding_status || '') === 'consumed').length,
+    releasedBindingCount: normalizedBindings.filter((binding) => String(binding?.binding_status || '') === 'released').length,
+    roleKeys,
+  }
+}
+
+function mapAdminTaskInventoryBinding(binding, task) {
+  const metadata = safeParseJson(binding.metadata_json)
+
+  return {
+    bindingId: binding.id,
+    inventoryItemId: binding.inventory_item_id,
+    roleKey: String(binding.role_key || '').trim(),
+    quantity: Math.max(1, Number(binding.quantity || 1)),
+    bindingStatus: String(binding.binding_status || '').trim(),
+    inventoryStatus: String(binding.inventory_item_status || '').trim(),
+    skuCode: String(binding.sku_code || '').trim(),
+    batchNo: String(binding.batch_no || '').trim(),
+    credentialType: String(binding.credential_type || 'tencent_code').trim() || 'tencent_code',
+    displayValue: String(binding.display_value || '').trim(),
+    invalidReason: String(binding.invalid_reason || '').trim(),
+    consumedAt: binding.consumed_at || null,
+    releasedAt: binding.released_at || null,
+    createdAt: binding.created_at,
+    updatedAt: binding.updated_at,
+    metadata: normalizeRecord(metadata),
+    isPrimary: Number(binding.inventory_item_id || 0) === getTaskPrimaryInventoryItemId(task),
+    canRelease: canReleaseTaskInventoryBinding(task, binding),
+  }
+}
+
+function canReleaseTaskInventoryBinding(task, binding) {
+  if (!task || !binding) {
+    return false
+  }
+
+  if (String(binding.binding_status || '').trim() !== 'reserved') {
+    return false
+  }
+
+  return !['redeemed', 'expired'].includes(String(task.task_status || '').trim())
+}
+
 async function mapAdminOrderListItem(item) {
  const [tasks, orderItems] = await Promise.all([
    listTasksByOrderId(item.id),
    listOrderItemsByOrderId(item.id),
  ])
-  const bindingSummary = buildOrderBindingSummary(tasks)
+  const taskBindingSummaryMap = await getTaskBindingSummaryMap(tasks.map((task) => task.id))
+  const bindingSummary = buildOrderBindingSummary(tasks, taskBindingSummaryMap)
  const itemSummary = summarizeOrderItems(orderItems)

  return {
@@ -1012,6 +1306,10 @@ async function mapAdminOrderListItem(item) {
    userBindingStatus: bindingSummary.userBindingStatus,
    systemBoundTaskCount: bindingSummary.systemBoundTaskCount,
    completedBindingTaskCount: bindingSummary.completedBindingTaskCount,
+    totalBindingCount: bindingSummary.totalBindingCount,
+    reservedBindingCount: bindingSummary.reservedBindingCount,
+    consumedBindingCount: bindingSummary.consumedBindingCount,
+    releasedBindingCount: bindingSummary.releasedBindingCount,
  }
 }

@@ -1070,12 +1368,17 @@ function resolveOrderItemDeliveryMode(tasks, orderItemId) {
  return String(task.executor_key || '').trim()
 }

-function buildOrderBindingSummary(tasks) {
+function buildOrderBindingSummary(tasks, taskBindingSummaryMap = new Map()) {
  const normalizedTasks = Array.isArray(tasks) ? tasks : []
  const totalTaskCount = normalizedTasks.length
  const taskBindings = normalizedTasks.map((task) => buildTaskBindingState(task))
  const systemBoundTaskCount = normalizedTasks.filter((task) => isTaskSystemBound(task)).length
  const completedBindingTaskCount = normalizedTasks.filter((task) => String(task?.task_status || '') === 'redeemed').length
+  const bindingSummaries = normalizedTasks.map((task) => getTaskBindingSummary(taskBindingSummaryMap, task.id))
+  const totalBindingCount = bindingSummaries.reduce((sum, item) => sum + item.totalBindingCount, 0)
+  const reservedBindingCount = bindingSummaries.reduce((sum, item) => sum + item.reservedBindingCount, 0)
+  const consumedBindingCount = bindingSummaries.reduce((sum, item) => sum + item.consumedBindingCount, 0)
+  const releasedBindingCount = bindingSummaries.reduce((sum, item) => sum + item.releasedBindingCount, 0)

  let systemBindingStatus = 'pending_binding'
  let userBindingStatus = 'not_started'
@@ -1085,6 +1388,10 @@ function buildOrderBindingSummary(tasks) {
      totalTaskCount,
      systemBoundTaskCount,
      completedBindingTaskCount,
+      totalBindingCount,
+      reservedBindingCount,
+      consumedBindingCount,
+      releasedBindingCount,
      systemBindingStatus,
      userBindingStatus,
    }
@@ -1112,6 +1419,10 @@ function buildOrderBindingSummary(tasks) {
    totalTaskCount,
    systemBoundTaskCount,
    completedBindingTaskCount,
+    totalBindingCount,
+    reservedBindingCount,
+    consumedBindingCount,
+    releasedBindingCount,
    systemBindingStatus,
    userBindingStatus,
  }
@@ -1187,13 +1498,58 @@ function isTaskSystemBound(task) {
 }

 function parseTaskContext(task) {
+  const value = task?.context_json
+
+  if (!value) {
+    return {}
+  }
+
+  if (typeof value === 'object') {
+    return value
+  }
+
  try {
-    return JSON.parse(String(task?.context_json || '{}'))
+    return JSON.parse(String(value || '{}'))
  } catch {
    return {}
  }
 }

+function mapManualDispatchContext(value) {
+  if (!value || typeof value !== 'object') {
+    return null
+  }
+
+  return {
+    outcome: String(value.outcome || '').trim(),
+    deliveryReference: String(value.deliveryReference || '').trim(),
+    deliveredCredential: String(value.deliveredCredential || '').trim(),
+    resultMessage: String(value.resultMessage || '').trim(),
+    completedAt: value.completedAt || null,
+    completedBy: value.completedBy && typeof value.completedBy === 'object'
+      ? {
+        userId: Number(value.completedBy.userId || 0) || 0,
+        username: String(value.completedBy.username || '').trim(),
+        role: String(value.completedBy.role || '').trim(),
+      }
+      : null,
+  }
+}
+
+function normalizeManualDispatchOutcome(value) {
+  const normalized = String(value || '').trim().toLowerCase()
+
+  if (normalized === 'failed') {
+    return 'failed'
+  }
+
+  return 'delivered'
+}
+
+function isManualDispatchTask(task) {
+  return String(task?.executor_key || '').trim() === 'manual_dispatch'
+}
+
 function getTaskPrimaryInventoryItemId(task) {
  const value = Number(task?.primary_inventory_item_id || 0)
  return Number.isFinite(value) && value > 0 ? value : null
@@ -1233,7 +1589,7 @@ function resolveDisplayShopName(provider, shopId, shopName) {
  return normalizedShopId
 }

-function normalizeCdkImportRows(payload) {
+function normalizeInventoryImportRows(payload) {
  const rows = []
  const directRows = Array.isArray(payload.rows) ? payload.rows : []
  const bulkCodes = Array.isArray(payload.codes) ? payload.codes : []
@@ -1241,15 +1597,15 @@ function normalizeCdkImportRows(payload) {
  if (directRows.length > 0) {
    for (const row of directRows) {
      const skuCode = String(row?.skuCode || '').trim()
-      const cdkCode = String(row?.cdkCode || '').trim()
+      const displayValue = String(row?.displayValue || '').trim()
      const batchNo = String(row?.batchNo || '').trim()
      const credentialType = String(row?.credentialType || payload.credentialType || 'tencent_code').trim() || 'tencent_code'

-      if (!skuCode || !cdkCode) {
+      if (!skuCode || !displayValue) {
        continue
      }

-      rows.push({ skuCode, cdkCode, batchNo, credentialType })
+      rows.push({ skuCode, displayValue, batchNo, credentialType })
    }
  }

@@ -1261,16 +1617,16 @@ function normalizeCdkImportRows(payload) {
    if (!skuCode) {
      throw createHttpError('批量导入时缺少 skuCode', {
        statusCode: 400,
-        errorCode: 'admin_cdk_import_missing_sku',
+        errorCode: 'admin_inventory_import_missing_sku',
      })
    }

-    for (const code of bulkCodes) {
-      const cdkCode = String(code || '').trim()
-      if (!cdkCode) {
+    for (const rawValue of bulkCodes) {
+      const displayValue = String(rawValue || '').trim()
+      if (!displayValue) {
        continue
      }
-      rows.push({ skuCode, cdkCode, batchNo, credentialType })
+      rows.push({ skuCode, displayValue, batchNo, credentialType })
    }
  }

@@ -1282,7 +1638,7 @@ function dedupeRows(rows) {
  const output = []

  for (const row of rows) {
-    const key = `${row.skuCode}::${row.credentialType || 'tencent_code'}::${row.cdkCode}`
+    const key = `${row.skuCode}::${row.credentialType || 'tencent_code'}::${row.displayValue}`
    if (seen.has(key)) {
      continue
    }