1736 lines
55 KiB
JavaScript
1736 lines
55 KiB
JavaScript
import { runtimeConfig } from '../../config/runtime.js'
|
|
import { query } from '../../db/client.js'
|
|
import { createTaskClaimToken } from '../claim/claim-service.js'
|
|
import {
|
|
getAgisoShopConfig,
|
|
getAgisoShopConfigMap,
|
|
getAgisoShopsFilePath,
|
|
saveAgisoShopConfigMap,
|
|
} from '../platforms/agiso/shop-config-service.js'
|
|
import { getClaimTokenById, updateClaimToken } from '../../repositories/claim-token-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 { reserveInventoryForTask } from '../order/inventory-service.js'
|
|
import { replayAgisoTradeWebhookEvent } from '../order/webhook-service.js'
|
|
import { normalizeDateQuery, normalizePage, normalizePageSize, safeParseJson } from './admin-query-utils.js'
|
|
|
|
export async function getAdminDashboardSummary() {
|
|
const todayPrefix = nowIso().slice(0, 10)
|
|
const result = await query(
|
|
`
|
|
SELECT
|
|
(SELECT COUNT(*)::int FROM orders WHERE to_char(created_at AT TIME ZONE 'Asia/Shanghai', 'YYYY-MM-DD') = $1) AS today_orders,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM fulfillment_tasks
|
|
WHERE task_status IN ('paid', 'link_generated')
|
|
OR (inventory_status = 'reserved' AND task_status NOT IN ('claimed', 'role_confirmed', 'redeeming', 'redeemed', 'closed', 'expired'))
|
|
) AS paid_pending_claim,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM fulfillment_tasks
|
|
WHERE task_status IN ('claimed', 'role_confirmed', 'redeeming')
|
|
) AS claiming_tasks,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM fulfillment_tasks
|
|
WHERE task_status = 'redeemed'
|
|
AND to_char(updated_at AT TIME ZONE 'Asia/Shanghai', 'YYYY-MM-DD') = $1
|
|
) AS redeemed_today,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM fulfillment_tasks
|
|
WHERE task_status IN ('retry_pending', 'manual_review', 'waiting_inventory')
|
|
) AS abnormal_tasks,
|
|
(
|
|
SELECT COUNT(DISTINCT sku_code)::int
|
|
FROM inventory_items
|
|
WHERE status = 'available'
|
|
) AS sku_with_inventory
|
|
`,
|
|
[todayPrefix],
|
|
)
|
|
const summary = result.rows[0] || {}
|
|
|
|
return {
|
|
todayOrders: Number(summary?.today_orders || 0),
|
|
paidPendingClaim: Number(summary?.paid_pending_claim || 0),
|
|
claimingTasks: Number(summary?.claiming_tasks || 0),
|
|
redeemedToday: Number(summary?.redeemed_today || 0),
|
|
abnormalTasks: Number(summary?.abnormal_tasks || 0),
|
|
skuWithInventory: Number(summary?.sku_with_inventory || 0),
|
|
}
|
|
}
|
|
|
|
export async function getAdminOrders(query = {}) {
|
|
const page = normalizePage(query.page)
|
|
const pageSize = normalizePageSize(query.pageSize)
|
|
const { items, total } = await listOrders({
|
|
page,
|
|
pageSize,
|
|
platformOrderId: String(query.platformOrderId || '').trim(),
|
|
payStatus: String(query.payStatus || '').trim(),
|
|
skuCode: String(query.skuCode || '').trim(),
|
|
dateFrom: normalizeDateQuery(query.dateFrom),
|
|
dateTo: normalizeDateQuery(query.dateTo, true),
|
|
})
|
|
|
|
return {
|
|
items: await Promise.all(items.map((item) => mapAdminOrderListItem(item))),
|
|
pagination: { page, pageSize, total },
|
|
}
|
|
}
|
|
|
|
export async function getAdminOrderDetail(orderId) {
|
|
const order = await getOrderById(Number(orderId))
|
|
|
|
if (!order) {
|
|
throw createHttpError('订单不存在', {
|
|
statusCode: 404,
|
|
errorCode: 'admin_order_not_found',
|
|
})
|
|
}
|
|
|
|
const [items, tasks, webhookEvents] = await Promise.all([
|
|
listOrderItemsByOrderId(order.id),
|
|
listTasksByOrderId(order.id),
|
|
listWebhookEventsByOrderId(order.id),
|
|
])
|
|
const taskBindingSummaryMap = await getTaskBindingSummaryMap(tasks.map((task) => task.id))
|
|
const itemSummary = summarizeOrderItems(items)
|
|
|
|
return {
|
|
order: {
|
|
orderId: order.id,
|
|
provider: order.provider || 'agiso',
|
|
platform: order.platform,
|
|
shopId: order.shop_id || '',
|
|
shopName: resolveDisplayShopName(order.provider, order.shop_id, order.shop_name),
|
|
platformOrderId: order.platform_order_id,
|
|
orderStatus: order.order_status,
|
|
payStatus: order.pay_status,
|
|
buyerId: order.buyer_id,
|
|
buyerName: order.buyer_name,
|
|
receiverContact: order.receiver_contact,
|
|
totalAmount: formatFenToAmount(order.total_amount),
|
|
totalAmountFen: normalizeFen(order.total_amount),
|
|
currency: order.currency,
|
|
paidAt: order.paid_at,
|
|
createdAt: order.created_at,
|
|
updatedAt: order.updated_at,
|
|
itemSummary,
|
|
rawPayload: safeParseJson(order.raw_payload_json),
|
|
bindingSummary: buildOrderBindingSummary(tasks, taskBindingSummaryMap),
|
|
},
|
|
items: items.map((item) => ({
|
|
orderItemId: item.id,
|
|
skuCode: item.sku_code,
|
|
skuName: item.sku_name,
|
|
itemTitle: resolveOrderItemTitle(item),
|
|
quantity: item.quantity,
|
|
deliveryMode: resolveOrderItemDeliveryMode(tasks, item.id),
|
|
spec: safeParseJson(item.spec_json),
|
|
})),
|
|
tasks: tasks.map((task) => mapAdminTaskSummary(task, getTaskBindingSummary(taskBindingSummaryMap, task.id))),
|
|
webhookEvents: webhookEvents.map((event) => ({
|
|
eventId: event.id,
|
|
provider: event.provider || 'agiso',
|
|
platform: event.platform,
|
|
shopId: event.shop_id || '',
|
|
shopName: resolveDisplayShopName(event.provider, event.shop_id, event.shop_name),
|
|
eventType: event.event_type,
|
|
eventKey: event.event_key,
|
|
signatureValid: Boolean(event.signature_valid),
|
|
processed: Boolean(event.processed),
|
|
processError: event.process_error,
|
|
createdAt: event.created_at,
|
|
})),
|
|
}
|
|
}
|
|
|
|
export async function getAdminTasks(query = {}) {
|
|
const page = normalizePage(query.page)
|
|
const pageSize = normalizePageSize(query.pageSize)
|
|
const { items, total } = await listTasks({
|
|
page,
|
|
pageSize,
|
|
status: String(query.status || '').trim(),
|
|
platformOrderId: String(query.platformOrderId || '').trim(),
|
|
taskNo: String(query.taskNo || '').trim(),
|
|
skuCode: String(query.skuCode || '').trim(),
|
|
roleId: String(query.roleId || '').trim(),
|
|
dateFrom: normalizeDateQuery(query.dateFrom),
|
|
dateTo: normalizeDateQuery(query.dateTo, true),
|
|
})
|
|
const taskBindingSummaryMap = await getTaskBindingSummaryMap(items.map((item) => item.id))
|
|
|
|
return {
|
|
items: items.map((item) => mapAdminTaskListItem(item, getTaskBindingSummary(taskBindingSummaryMap, item.id))),
|
|
pagination: { page, pageSize, total },
|
|
}
|
|
}
|
|
|
|
export async function getAdminTaskDetail(taskId) {
|
|
const task = await getTaskById(Number(taskId))
|
|
|
|
if (!task) {
|
|
throw createHttpError('任务不存在', {
|
|
statusCode: 404,
|
|
errorCode: 'admin_task_not_found',
|
|
})
|
|
}
|
|
|
|
const [order, claimToken, inventoryItem, taskEvents, inventoryBindings] = await Promise.all([
|
|
getOrderById(task.order_id),
|
|
getTaskPrimaryClaimTokenId(task) ? getClaimTokenById(getTaskPrimaryClaimTokenId(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 || '',
|
|
inventory_display_value: inventoryItem?.display_value || '',
|
|
claim_token: claimToken?.token || '',
|
|
}, taskBindingSummary),
|
|
order: order
|
|
? {
|
|
orderId: order.id,
|
|
provider: order.provider || 'agiso',
|
|
platform: order.platform,
|
|
shopId: order.shop_id || '',
|
|
shopName: order.shop_name || '',
|
|
platformOrderId: order.platform_order_id,
|
|
payStatus: order.pay_status,
|
|
orderStatus: order.order_status,
|
|
}
|
|
: null,
|
|
orderItem: orderItem
|
|
? {
|
|
orderItemId: orderItem.id,
|
|
skuCode: orderItem.sku_code,
|
|
skuName: orderItem.sku_name,
|
|
quantity: orderItem.quantity,
|
|
}
|
|
: null,
|
|
claimToken: claimToken
|
|
? {
|
|
primaryClaimTokenId: claimToken.id,
|
|
token: claimToken.token,
|
|
status: claimToken.status,
|
|
expiredAt: claimToken.expired_at,
|
|
}
|
|
: null,
|
|
inventory: inventoryItem
|
|
? {
|
|
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: !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),
|
|
},
|
|
}
|
|
}
|
|
|
|
export async function getAdminTaskScreenshotPath(taskId) {
|
|
const task = await getRequiredTask(taskId)
|
|
|
|
if (!task.screenshot_path) {
|
|
throw createHttpError('当前任务还没有截图', {
|
|
statusCode: 404,
|
|
errorCode: 'admin_task_screenshot_not_found',
|
|
})
|
|
}
|
|
|
|
return task.screenshot_path
|
|
}
|
|
|
|
export async function getAdminInventoryItems(query = {}) {
|
|
const page = normalizePage(query.page)
|
|
const pageSize = normalizePageSize(query.pageSize)
|
|
const { items, total } = await listInventoryItems({
|
|
page,
|
|
pageSize,
|
|
skuCode: String(query.skuCode || '').trim(),
|
|
status: String(query.status || '').trim(),
|
|
batchNo: String(query.batchNo || '').trim(),
|
|
})
|
|
|
|
return {
|
|
items: await Promise.all(items.map((item) => mapAdminInventoryListItem(item))),
|
|
pagination: { page, pageSize, total },
|
|
}
|
|
}
|
|
|
|
export async function createAdminInventoryItem(payload = {}) {
|
|
const skuCode = String(payload.skuCode || '').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 || !displayValue) {
|
|
throw createHttpError('缺少 skuCode 或 displayValue', {
|
|
statusCode: 400,
|
|
errorCode: 'admin_inventory_create_invalid',
|
|
})
|
|
}
|
|
|
|
const now = nowIso()
|
|
const created = await createInventoryItems([
|
|
{
|
|
skuCode,
|
|
displayValue,
|
|
batchNo,
|
|
credentialType,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
},
|
|
])
|
|
|
|
if (created === 0) {
|
|
throw createHttpError('库存凭据已存在，不能重复新增', {
|
|
statusCode: 409,
|
|
errorCode: 'admin_inventory_duplicate',
|
|
})
|
|
}
|
|
|
|
const { items } = await listInventoryItems({
|
|
page: 1,
|
|
pageSize: 1,
|
|
skuCode,
|
|
})
|
|
const createdItem = items.find((item) => item.display_value === displayValue) || null
|
|
|
|
return {
|
|
inventoryItem: createdItem ? await mapAdminInventoryListItem(createdItem) : null,
|
|
}
|
|
}
|
|
|
|
export async function importAdminInventoryItems(payload = {}) {
|
|
const rows = normalizeInventoryImportRows(payload)
|
|
|
|
if (rows.length === 0) {
|
|
throw createHttpError('没有可导入的库存凭据数据', {
|
|
statusCode: 400,
|
|
errorCode: 'admin_inventory_import_empty',
|
|
})
|
|
}
|
|
|
|
const now = nowIso()
|
|
const normalizedRows = rows.map((row) => ({
|
|
skuCode: row.skuCode,
|
|
batchNo: row.batchNo,
|
|
displayValue: row.displayValue,
|
|
credentialType: row.credentialType,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
}))
|
|
|
|
const created = await createInventoryItems(normalizedRows)
|
|
|
|
return {
|
|
total: normalizedRows.length,
|
|
created,
|
|
duplicated: normalizedRows.length - created,
|
|
}
|
|
}
|
|
|
|
export async function releaseAdminInventoryItem(inventoryItemId) {
|
|
const inventoryItem = await getRequiredInventoryItem(inventoryItemId)
|
|
|
|
if (inventoryItem.status !== 'reserved') {
|
|
throw createHttpError('当前库存项不是预占状态，不能释放', {
|
|
statusCode: 409,
|
|
errorCode: 'admin_inventory_release_not_allowed',
|
|
})
|
|
}
|
|
|
|
const updated = await releaseReservedInventoryItem(inventoryItem.id, nowIso())
|
|
|
|
return {
|
|
inventoryItem: await mapAdminInventoryListItem(updated),
|
|
}
|
|
}
|
|
|
|
export async function invalidateAdminInventoryItem(inventoryItemId, payload = {}) {
|
|
const inventoryItem = await getRequiredInventoryItem(inventoryItemId)
|
|
|
|
if (inventoryItem.status !== 'available') {
|
|
throw createHttpError('只有可用库存项才能作废，请先释放预占', {
|
|
statusCode: 409,
|
|
errorCode: 'admin_inventory_invalidate_not_allowed',
|
|
})
|
|
}
|
|
|
|
const reason = String(payload.reason || '').trim() || '后台手动作废'
|
|
const updated = await invalidateInventoryItem(inventoryItem.id, reason, nowIso())
|
|
|
|
return {
|
|
inventoryItem: await mapAdminInventoryListItem(updated),
|
|
}
|
|
}
|
|
|
|
export async function getAdminWebhookEvents(query = {}) {
|
|
const page = normalizePage(query.page)
|
|
const pageSize = normalizePageSize(query.pageSize)
|
|
const { items, total } = await listWebhookEvents({
|
|
page,
|
|
pageSize,
|
|
provider: String(query.provider || '').trim(),
|
|
platform: String(query.platform || '').trim(),
|
|
processed: String(query.processed || '').trim(),
|
|
relatedOrderId: String(query.relatedOrderId || '').trim(),
|
|
dateFrom: normalizeDateQuery(query.dateFrom),
|
|
dateTo: normalizeDateQuery(query.dateTo, true),
|
|
})
|
|
|
|
return {
|
|
items: await Promise.all(items.map((item) => mapAdminWebhookEvent(item))),
|
|
pagination: { page, pageSize, total },
|
|
}
|
|
}
|
|
|
|
export async function getAdminWebhookEventDetail(eventId) {
|
|
const event = await getWebhookEventById(Number(eventId))
|
|
|
|
if (!event) {
|
|
throw createHttpError('Webhook 事件不存在', {
|
|
statusCode: 404,
|
|
errorCode: 'admin_webhook_not_found',
|
|
})
|
|
}
|
|
|
|
return mapAdminWebhookEvent(event, { includeRaw: true })
|
|
}
|
|
|
|
export async function replayAdminWebhookEvent(eventId) {
|
|
const event = await getWebhookEventById(Number(eventId))
|
|
|
|
if (!event) {
|
|
throw createHttpError('Webhook 事件不存在', {
|
|
statusCode: 404,
|
|
errorCode: 'admin_webhook_not_found',
|
|
})
|
|
}
|
|
|
|
if (String(event.provider || event.platform || '').trim() !== 'agiso') {
|
|
throw createHttpError('当前只支持重放 agiso webhook', {
|
|
statusCode: 409,
|
|
errorCode: 'admin_webhook_replay_not_supported',
|
|
})
|
|
}
|
|
|
|
const result = await replayAgisoTradeWebhookEvent(event)
|
|
|
|
return {
|
|
eventId: event.id,
|
|
replayed: true,
|
|
result,
|
|
}
|
|
}
|
|
|
|
export async function getAdminAgisoShopConfigs() {
|
|
const configMap = getAgisoShopConfigMap()
|
|
const rowsResult = await query(
|
|
`
|
|
SELECT
|
|
shop_id,
|
|
MAX(CASE WHEN trim(shop_name) != '' THEN shop_name ELSE '' END) AS detected_shop_name,
|
|
MAX(created_at) AS latest_seen_at,
|
|
COUNT(*)::int AS webhook_event_count
|
|
FROM webhook_events
|
|
WHERE provider = 'agiso' AND trim(shop_id) != ''
|
|
GROUP BY shop_id
|
|
ORDER BY latest_seen_at DESC, shop_id DESC
|
|
`,
|
|
)
|
|
const rows = rowsResult.rows
|
|
|
|
return {
|
|
filePath: getAgisoShopsFilePath(),
|
|
shops: Object.entries(configMap)
|
|
.sort(([left], [right]) => left.localeCompare(right))
|
|
.map(([shopId, config]) => ({
|
|
shopId,
|
|
shopName: String(config.shopName || '').trim(),
|
|
accessToken: String(config.accessToken || '').trim(),
|
|
accessTokenMasked: maskSecret(config.accessToken),
|
|
enabled: typeof config.enabled === 'boolean' ? config.enabled : null,
|
|
messageTemplate: String(config.messageTemplate || '').trim(),
|
|
appSecretConfigured: Boolean(String(config.appSecret || '').trim()),
|
|
apiVersion: String(config.apiVersion || '').trim(),
|
|
sendMessageEndpoint: String(config.sendMessageEndpoint || '').trim(),
|
|
})),
|
|
observedShops: rows.map((row) => ({
|
|
shopId: String(row.shop_id || '').trim(),
|
|
detectedShopName: String(row.detected_shop_name || '').trim(),
|
|
displayShopName: resolveDisplayShopName('agiso', row.shop_id, row.detected_shop_name),
|
|
latestSeenAt: row.latest_seen_at || null,
|
|
webhookEventCount: Number(row.webhook_event_count || 0),
|
|
configured: Boolean(configMap[String(row.shop_id || '').trim()]),
|
|
})),
|
|
}
|
|
}
|
|
|
|
export function updateAdminAgisoShopConfigs(payload = {}) {
|
|
const rawItems = Array.isArray(payload.shops) ? payload.shops : []
|
|
const nextMap = {}
|
|
|
|
for (const item of rawItems) {
|
|
const shopId = String(item?.shopId || '').trim()
|
|
if (!shopId) {
|
|
continue
|
|
}
|
|
|
|
const next = {}
|
|
const shopName = String(item?.shopName || '').trim()
|
|
const accessToken = String(item?.accessToken || '').trim()
|
|
const messageTemplate = String(item?.messageTemplate || '').trim()
|
|
const appSecret = String(item?.appSecret || '').trim()
|
|
const apiVersion = String(item?.apiVersion || '').trim()
|
|
const sendMessageEndpoint = String(item?.sendMessageEndpoint || '').trim()
|
|
|
|
if (shopName) {
|
|
next.shopName = shopName
|
|
}
|
|
if (accessToken) {
|
|
next.accessToken = accessToken
|
|
}
|
|
if (messageTemplate) {
|
|
next.messageTemplate = messageTemplate
|
|
}
|
|
if (appSecret) {
|
|
next.appSecret = appSecret
|
|
}
|
|
if (apiVersion) {
|
|
next.apiVersion = apiVersion
|
|
}
|
|
if (sendMessageEndpoint) {
|
|
next.sendMessageEndpoint = sendMessageEndpoint
|
|
}
|
|
if (typeof item?.enabled === 'boolean') {
|
|
next.enabled = item.enabled
|
|
}
|
|
|
|
if (!next.accessToken) {
|
|
continue
|
|
}
|
|
|
|
nextMap[shopId] = next
|
|
}
|
|
|
|
const saved = saveAgisoShopConfigMap(nextMap)
|
|
|
|
return {
|
|
filePath: getAgisoShopsFilePath(),
|
|
shops: Object.entries(saved)
|
|
.sort(([left], [right]) => left.localeCompare(right))
|
|
.map(([shopId, config]) => ({
|
|
shopId,
|
|
shopName: String(config.shopName || '').trim(),
|
|
accessToken: String(config.accessToken || '').trim(),
|
|
accessTokenMasked: maskSecret(config.accessToken),
|
|
enabled: typeof config.enabled === 'boolean' ? config.enabled : null,
|
|
messageTemplate: String(config.messageTemplate || '').trim(),
|
|
appSecretConfigured: Boolean(String(config.appSecret || '').trim()),
|
|
apiVersion: String(config.apiVersion || '').trim(),
|
|
sendMessageEndpoint: String(config.sendMessageEndpoint || '').trim(),
|
|
})),
|
|
}
|
|
}
|
|
|
|
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,
|
|
errorCode: 'admin_task_retry_not_allowed',
|
|
})
|
|
}
|
|
|
|
const orderItems = await listOrderItemsByOrderId(task.order_id)
|
|
const orderItem = orderItems.find((item) => item.id === task.order_item_id) || null
|
|
const taskContext = parseTaskContext(task)
|
|
const primaryRequirement = taskContext.primaryRequirement || null
|
|
let reservedInventoryItemId = getTaskPrimaryInventoryItemId(task)
|
|
let claimTokenId = getTaskPrimaryClaimTokenId(task)
|
|
let nextStatus = 'link_generated'
|
|
let lastError = ''
|
|
let claimExpiresAt = getTaskClaimExpiresAt(task)
|
|
let claimUrl = ''
|
|
let token = ''
|
|
|
|
if (!reservedInventoryItemId) {
|
|
const reserved = await reserveInventoryForTask({
|
|
skuCode: orderItem?.sku_code || '',
|
|
taskId: task.id,
|
|
credentialType: primaryRequirement?.credentialType || 'tencent_code',
|
|
roleKey: primaryRequirement?.roleKey || 'primary_code',
|
|
})
|
|
|
|
if (!reserved) {
|
|
nextStatus = 'waiting_inventory'
|
|
lastError = '库存不足，等待可用库存凭据'
|
|
} else {
|
|
reservedInventoryItemId = reserved.id
|
|
}
|
|
}
|
|
|
|
if (nextStatus === 'link_generated' && !claimTokenId) {
|
|
const claimToken = await createTaskClaimToken(task.id)
|
|
claimTokenId = claimToken.id
|
|
claimExpiresAt = claimToken.expired_at
|
|
claimUrl = claimToken.claimUrl
|
|
token = claimToken.token
|
|
}
|
|
|
|
const updatedTask = await updateTask(task.id, {
|
|
task_status: nextStatus,
|
|
inventory_status: reservedInventoryItemId ? 'reserved' : 'pending',
|
|
claim_token: token || task.claim_token || '',
|
|
claim_expires_at: claimExpiresAt,
|
|
last_error: lastError,
|
|
updated_at: now,
|
|
})
|
|
|
|
const payload = {
|
|
task: mapTaskActionPayload(updatedTask),
|
|
}
|
|
|
|
if (claimUrl) {
|
|
payload.claimUrl = claimUrl
|
|
payload.token = token
|
|
}
|
|
|
|
return payload
|
|
}
|
|
|
|
export async function releaseAdminTaskInventory(taskId) {
|
|
const task = await getRequiredTask(taskId)
|
|
const primaryInventoryItemId = getTaskPrimaryInventoryItemId(task)
|
|
|
|
if (!primaryInventoryItemId) {
|
|
throw createHttpError('当前任务没有预占库存项', {
|
|
statusCode: 409,
|
|
errorCode: 'admin_task_no_reserved_inventory',
|
|
})
|
|
}
|
|
|
|
if (task.task_status === 'redeemed') {
|
|
throw createHttpError('已兑换任务不能释放库存项', {
|
|
statusCode: 409,
|
|
errorCode: 'admin_task_release_not_allowed',
|
|
})
|
|
}
|
|
|
|
await releaseReservedInventoryItem(primaryInventoryItemId, nowIso())
|
|
const updatedTask = await updateTask(task.id, {
|
|
task_status: 'waiting_inventory',
|
|
inventory_status: 'pending',
|
|
last_error: '已手动释放预占库存项',
|
|
updated_at: nowIso(),
|
|
})
|
|
|
|
return {
|
|
task: mapTaskActionPayload(updatedTask),
|
|
}
|
|
}
|
|
|
|
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,
|
|
errorCode: 'admin_task_regenerate_not_allowed',
|
|
})
|
|
}
|
|
|
|
if (primaryClaimTokenId) {
|
|
await updateClaimToken(primaryClaimTokenId, {
|
|
status: 'revoked',
|
|
updated_at: nowIso(),
|
|
})
|
|
}
|
|
|
|
const claimToken = await createTaskClaimToken(task.id)
|
|
const updatedTask = await updateTask(task.id, {
|
|
claim_token: claimToken.token,
|
|
claim_expires_at: claimToken.expired_at,
|
|
task_status: 'link_generated',
|
|
last_error: '',
|
|
updated_at: nowIso(),
|
|
})
|
|
|
|
return {
|
|
task: mapTaskActionPayload(updatedTask),
|
|
claimUrl: claimToken.claimUrl,
|
|
token: claimToken.token,
|
|
}
|
|
}
|
|
|
|
export async function closeAdminTask(taskId) {
|
|
const task = await getRequiredTask(taskId)
|
|
|
|
if (task.task_status === 'redeemed') {
|
|
throw createHttpError('已兑换任务不能关闭', {
|
|
statusCode: 409,
|
|
errorCode: 'admin_task_close_not_allowed',
|
|
})
|
|
}
|
|
|
|
const updatedTask = await updateTask(task.id, {
|
|
task_status: 'closed',
|
|
delivery_status: 'closed',
|
|
last_error: task.last_error || '已手动关闭任务',
|
|
updated_at: nowIso(),
|
|
})
|
|
|
|
return {
|
|
task: mapTaskActionPayload(updatedTask),
|
|
}
|
|
}
|
|
|
|
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(),
|
|
})
|
|
|
|
return {
|
|
task: mapTaskActionPayload(updatedTask),
|
|
}
|
|
}
|
|
|
|
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 {
|
|
taskId: task.id,
|
|
taskNo: task.task_no,
|
|
status: task.task_status,
|
|
systemBindingStatus: binding.systemBindingStatus,
|
|
userBindingStatus: binding.userBindingStatus,
|
|
loginType: task.login_type,
|
|
browserSessionId: task.browser_session_id,
|
|
claimedAt: task.claimed_at,
|
|
roleConfirmedAt: task.role_confirmed_at,
|
|
redeemedAt: task.redeemed_at,
|
|
lastError: task.last_error,
|
|
retryCount: getTaskRetryCount(task),
|
|
bindingSummary,
|
|
createdAt: task.created_at,
|
|
updatedAt: task.updated_at,
|
|
}
|
|
}
|
|
|
|
async function mapAdminWebhookEvent(item, { includeRaw = false } = {}) {
|
|
const headers = normalizeRecord(safeParseJson(item.headers_json))
|
|
const query = normalizeRecord(safeParseJson(item.query_json))
|
|
const body = normalizeRecord(safeParseJson(item.body_json))
|
|
const payload = extractWebhookPayload(body)
|
|
const itemSources = extractWebhookItemSources(payload)
|
|
const firstItem = itemSources[0] || {}
|
|
const rawAmount = pickFirstNonEmpty([
|
|
payload.total_fee,
|
|
payload.totalFee,
|
|
payload.TotalFee,
|
|
payload.pay_fee,
|
|
payload.payFee,
|
|
payload.Payment,
|
|
payload.payment,
|
|
payload.buy_amount,
|
|
payload.buyAmount,
|
|
])
|
|
const totalAmountFen = parseAmountToFen(rawAmount)
|
|
const taskCount = item.related_order_id ? (await listTasksByOrderId(item.related_order_id)).length : 0
|
|
|
|
const mapped = {
|
|
eventId: item.id,
|
|
provider: item.provider || 'agiso',
|
|
platform: item.platform,
|
|
platformRaw: pickFirstNonEmpty([
|
|
query.fromPlatform,
|
|
query.from_platform,
|
|
body.fromPlatform,
|
|
body.from_platform,
|
|
payload.fromPlatform,
|
|
payload.FromPlatform,
|
|
payload.platform,
|
|
payload.Platform,
|
|
]),
|
|
shopId: item.shop_id || pickFirstNonEmpty([
|
|
payload.PlatformUserId,
|
|
payload.platformUserId,
|
|
payload.platform_user_id,
|
|
payload.seller_id,
|
|
payload.sellerId,
|
|
payload.SellerId,
|
|
payload.seller_nick,
|
|
payload.sellerNick,
|
|
payload.SellerNick,
|
|
]),
|
|
shopName: resolveDisplayShopName(
|
|
item.provider,
|
|
item.shop_id || pickFirstNonEmpty([
|
|
payload.PlatformUserId,
|
|
payload.platformUserId,
|
|
payload.platform_user_id,
|
|
payload.seller_id,
|
|
payload.sellerId,
|
|
payload.SellerId,
|
|
payload.seller_nick,
|
|
payload.sellerNick,
|
|
payload.SellerNick,
|
|
]),
|
|
item.shop_name || pickFirstNonEmpty([
|
|
payload.shopName,
|
|
payload.shop_name,
|
|
payload.ShopName,
|
|
payload.seller_nick,
|
|
payload.sellerNick,
|
|
payload.SellerNick,
|
|
]),
|
|
),
|
|
eventType: item.event_type,
|
|
eventKey: item.event_key,
|
|
signatureValid: Boolean(item.signature_valid),
|
|
processed: Boolean(item.processed),
|
|
processError: item.process_error,
|
|
relatedOrderId: item.related_order_id,
|
|
createdAt: item.created_at,
|
|
platformOrderId: pickFirstNonEmpty([
|
|
payload.biz_order_id,
|
|
payload.bizOrderId,
|
|
payload.Tid,
|
|
payload.tid,
|
|
payload.Oid,
|
|
payload.oid,
|
|
payload.order_id,
|
|
payload.orderId,
|
|
firstItem.Oid,
|
|
firstItem.oid,
|
|
]),
|
|
buyerId: pickFirstNonEmpty([
|
|
payload.buyer_id,
|
|
payload.buyerId,
|
|
payload.BuyerId,
|
|
payload.openid,
|
|
payload.BuyerOpenUid,
|
|
payload.buyer_open_uid,
|
|
payload.buyerOpenUid,
|
|
]),
|
|
buyerName: pickFirstNonEmpty([
|
|
payload.buyer_name,
|
|
payload.buyerName,
|
|
payload.BuyerName,
|
|
payload.nick,
|
|
payload.BuyerNick,
|
|
payload.buyer_nick,
|
|
payload.buyerNick,
|
|
]),
|
|
totalAmount: rawAmount ? formatFenToAmount(totalAmountFen) : '',
|
|
totalAmountFen,
|
|
currency: pickFirstNonEmpty([payload.currency, payload.Currency, 'CNY']) || 'CNY',
|
|
itemCount: itemSources.length,
|
|
taskCount,
|
|
messageText: pickFirstNonEmpty([
|
|
payload.MsgTypeDes,
|
|
payload.msgTypeDes,
|
|
payload.msg_type_desc,
|
|
payload.message,
|
|
payload.msg,
|
|
]),
|
|
requestTimestamp: pickFirstNonEmpty([query.timestamp]),
|
|
requestSign: pickFirstNonEmpty([query.sign]),
|
|
aopic: pickFirstNonEmpty([query.aopic]),
|
|
sourceHost: pickFirstNonEmpty([headers['x-forwarded-host'], headers.host]),
|
|
sourceIp: pickFirstNonEmpty([headers['x-forwarded-for'], headers['x-real-ip']]),
|
|
userAgent: pickFirstNonEmpty([headers['user-agent'], headers['User-Agent']]),
|
|
}
|
|
|
|
if (!includeRaw) {
|
|
return mapped
|
|
}
|
|
|
|
return {
|
|
...mapped,
|
|
headers,
|
|
query,
|
|
body,
|
|
payload,
|
|
}
|
|
}
|
|
|
|
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 {
|
|
inventoryItemId: item.id,
|
|
skuCode: item.sku_code,
|
|
batchNo: item.batch_no,
|
|
credentialType: item.credential_type || 'tencent_code',
|
|
displayValue: item.display_value,
|
|
status: item.status,
|
|
reservedByTaskId: item.reserved_by_task_id,
|
|
reservedByTaskNo: task?.task_no || '',
|
|
platformOrderId: order?.platform_order_id || '',
|
|
systemBindingStatus: item.status === 'consumed' ? 'system_bound' : binding.systemBindingStatus,
|
|
userBindingStatus: item.status === 'consumed' ? 'binding_completed' : binding.userBindingStatus,
|
|
invalidReason: item.invalid_reason || '',
|
|
deliveredAt: item.delivered_at,
|
|
createdAt: item.created_at,
|
|
updatedAt: item.updated_at,
|
|
}
|
|
}
|
|
|
|
function mapTaskActionPayload(task) {
|
|
const inventoryItemId = getTaskPrimaryInventoryItemId(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,
|
|
primaryClaimTokenId,
|
|
lastError: task.last_error,
|
|
updatedAt: task.updated_at,
|
|
}
|
|
}
|
|
|
|
async function getRequiredTask(taskId) {
|
|
const task = await getTaskById(Number(taskId))
|
|
|
|
if (!task) {
|
|
throw createHttpError('任务不存在', {
|
|
statusCode: 404,
|
|
errorCode: 'admin_task_not_found',
|
|
})
|
|
}
|
|
|
|
return task
|
|
}
|
|
|
|
async function getRequiredInventoryItem(inventoryItemId) {
|
|
const inventoryItem = await getInventoryItemById(Number(inventoryItemId))
|
|
|
|
if (!inventoryItem) {
|
|
throw createHttpError('库存项不存在', {
|
|
statusCode: 404,
|
|
errorCode: 'admin_inventory_not_found',
|
|
})
|
|
}
|
|
|
|
return inventoryItem
|
|
}
|
|
|
|
function mapAdminTaskListItem(task, bindingSummary = createEmptyTaskBindingSummary()) {
|
|
const binding = buildTaskBindingState(task)
|
|
|
|
return {
|
|
taskId: task.id,
|
|
taskNo: task.task_no,
|
|
platformOrderId: task.platform_order_id,
|
|
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,
|
|
roleName: task.role_name,
|
|
roleId: task.role_id,
|
|
browserSessionId: task.browser_session_id,
|
|
claimedAt: task.claimed_at,
|
|
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,
|
|
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 taskBindingSummaryMap = await getTaskBindingSummaryMap(tasks.map((task) => task.id))
|
|
const bindingSummary = buildOrderBindingSummary(tasks, taskBindingSummaryMap)
|
|
const itemSummary = summarizeOrderItems(orderItems)
|
|
|
|
return {
|
|
orderId: item.id,
|
|
provider: item.provider || 'agiso',
|
|
platform: item.platform,
|
|
shopId: item.shop_id || '',
|
|
shopName: resolveDisplayShopName(item.provider, item.shop_id, item.shop_name),
|
|
platformOrderId: item.platform_order_id,
|
|
orderStatus: item.order_status,
|
|
payStatus: item.pay_status,
|
|
buyerId: item.buyer_id || '',
|
|
buyerName: item.buyer_name,
|
|
receiverContact: item.receiver_contact || '',
|
|
totalAmount: formatFenToAmount(item.total_amount),
|
|
totalAmountFen: normalizeFen(item.total_amount),
|
|
currency: item.currency,
|
|
paidAt: item.paid_at,
|
|
createdAt: item.created_at,
|
|
updatedAt: item.updated_at,
|
|
itemCount: orderItems.length,
|
|
totalQuantity: orderItems.reduce((sum, orderItem) => sum + Math.max(1, Number(orderItem.quantity || 1)), 0),
|
|
itemSummary,
|
|
taskCount: Number(item.task_count || tasks.length || 0),
|
|
systemBindingStatus: bindingSummary.systemBindingStatus,
|
|
userBindingStatus: bindingSummary.userBindingStatus,
|
|
systemBoundTaskCount: bindingSummary.systemBoundTaskCount,
|
|
completedBindingTaskCount: bindingSummary.completedBindingTaskCount,
|
|
totalBindingCount: bindingSummary.totalBindingCount,
|
|
reservedBindingCount: bindingSummary.reservedBindingCount,
|
|
consumedBindingCount: bindingSummary.consumedBindingCount,
|
|
releasedBindingCount: bindingSummary.releasedBindingCount,
|
|
}
|
|
}
|
|
|
|
function summarizeOrderItems(items) {
|
|
const normalizedItems = Array.isArray(items) ? items : []
|
|
|
|
if (normalizedItems.length === 0) {
|
|
return ''
|
|
}
|
|
|
|
const [firstItem] = normalizedItems
|
|
const firstLabel = resolveOrderItemTitle(firstItem)
|
|
|| String(firstItem?.sku_name || firstItem?.sku_code || '').trim()
|
|
|
|
if (normalizedItems.length === 1) {
|
|
return firstLabel
|
|
}
|
|
|
|
return `${firstLabel} 等 ${normalizedItems.length} 项`
|
|
}
|
|
|
|
function resolveOrderItemTitle(item) {
|
|
if (!item) {
|
|
return ''
|
|
}
|
|
|
|
const spec = safeParseJson(item.spec_json)
|
|
|
|
return pickFirstNonEmpty([
|
|
spec.title,
|
|
spec.Title,
|
|
spec.itemTitle,
|
|
spec.item_title,
|
|
spec.goods_name,
|
|
spec.goodsName,
|
|
item.sku_name,
|
|
item.sku_code,
|
|
])
|
|
}
|
|
|
|
function resolveOrderItemDeliveryMode(tasks, orderItemId) {
|
|
const task = (Array.isArray(tasks) ? tasks : []).find((item) => item.order_item_id === orderItemId)
|
|
|
|
if (!task) {
|
|
return ''
|
|
}
|
|
|
|
if (String(task.executor_key || '').trim() === 'manual_dispatch') {
|
|
return 'manual_dispatch'
|
|
}
|
|
|
|
if (task.requires_claim || getTaskPrimaryClaimTokenId(task) || task.primary_claim_token || task.claim_token) {
|
|
return 'claim_link'
|
|
}
|
|
|
|
return String(task.executor_key || '').trim()
|
|
}
|
|
|
|
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'
|
|
|
|
if (totalTaskCount === 0) {
|
|
return {
|
|
totalTaskCount,
|
|
systemBoundTaskCount,
|
|
completedBindingTaskCount,
|
|
totalBindingCount,
|
|
reservedBindingCount,
|
|
consumedBindingCount,
|
|
releasedBindingCount,
|
|
systemBindingStatus,
|
|
userBindingStatus,
|
|
}
|
|
}
|
|
|
|
if (normalizedTasks.every((task) => String(task.task_status || '') === 'redeemed')) {
|
|
systemBindingStatus = 'system_bound'
|
|
userBindingStatus = 'binding_completed'
|
|
} else if (taskBindings.some((item) => ['binding_in_progress', 'binding_confirmed', 'link_opened'].includes(item.userBindingStatus))) {
|
|
systemBindingStatus = systemBoundTaskCount > 0 ? 'system_bound' : 'pending_binding'
|
|
userBindingStatus = 'user_binding'
|
|
} else if (taskBindings.some((item) => item.userBindingStatus === 'waiting_user_claim')) {
|
|
systemBindingStatus = systemBoundTaskCount > 0 ? 'system_bound' : 'pending_binding'
|
|
userBindingStatus = 'waiting_user_claim'
|
|
} else if (taskBindings.some((item) => item.userBindingStatus === 'binding_exception')) {
|
|
systemBindingStatus = systemBoundTaskCount > 0 ? 'system_bound' : 'pending_binding'
|
|
userBindingStatus = 'binding_exception'
|
|
} else if (systemBoundTaskCount > 0) {
|
|
systemBindingStatus = 'system_bound'
|
|
} else if (taskBindings.some((item) => ['manual_review', 'retry_pending', 'waiting_inventory'].includes(item.systemBindingStatus))) {
|
|
systemBindingStatus = 'binding_exception'
|
|
}
|
|
|
|
return {
|
|
totalTaskCount,
|
|
systemBoundTaskCount,
|
|
completedBindingTaskCount,
|
|
totalBindingCount,
|
|
reservedBindingCount,
|
|
consumedBindingCount,
|
|
releasedBindingCount,
|
|
systemBindingStatus,
|
|
userBindingStatus,
|
|
}
|
|
}
|
|
|
|
function buildTaskBindingState(task) {
|
|
const normalizedStatus = String(task?.task_status || '').trim()
|
|
|
|
if (!normalizedStatus) {
|
|
return {
|
|
systemBindingStatus: 'pending_binding',
|
|
userBindingStatus: 'not_started',
|
|
}
|
|
}
|
|
|
|
if (normalizedStatus === 'pending_payment') {
|
|
return { systemBindingStatus: 'pending_payment', userBindingStatus: 'not_started' }
|
|
}
|
|
|
|
if (normalizedStatus === 'paid') {
|
|
return { systemBindingStatus: 'pending_binding', userBindingStatus: 'not_started' }
|
|
}
|
|
|
|
if (normalizedStatus === 'waiting_inventory') {
|
|
return { systemBindingStatus: 'waiting_inventory', userBindingStatus: 'not_started' }
|
|
}
|
|
|
|
if (normalizedStatus === 'manual_review') {
|
|
return { systemBindingStatus: 'manual_review', userBindingStatus: 'binding_exception' }
|
|
}
|
|
|
|
if (normalizedStatus === 'retry_pending') {
|
|
return { systemBindingStatus: 'retry_pending', userBindingStatus: 'binding_exception' }
|
|
}
|
|
|
|
if (normalizedStatus === 'closed') {
|
|
return { systemBindingStatus: 'closed', userBindingStatus: 'closed' }
|
|
}
|
|
|
|
if (normalizedStatus === 'expired') {
|
|
return { systemBindingStatus: 'expired', userBindingStatus: 'expired' }
|
|
}
|
|
|
|
if (normalizedStatus === 'link_generated') {
|
|
return { systemBindingStatus: 'system_bound', userBindingStatus: 'waiting_user_claim' }
|
|
}
|
|
|
|
if (normalizedStatus === 'claimed') {
|
|
return { systemBindingStatus: 'system_bound', userBindingStatus: 'link_opened' }
|
|
}
|
|
|
|
if (normalizedStatus === 'role_confirmed') {
|
|
return { systemBindingStatus: 'system_bound', userBindingStatus: 'binding_confirmed' }
|
|
}
|
|
|
|
if (normalizedStatus === 'redeeming') {
|
|
return { systemBindingStatus: 'system_bound', userBindingStatus: 'binding_in_progress' }
|
|
}
|
|
|
|
if (normalizedStatus === 'redeemed') {
|
|
return { systemBindingStatus: 'system_bound', userBindingStatus: 'binding_completed' }
|
|
}
|
|
|
|
if (isTaskSystemBound(task)) {
|
|
return { systemBindingStatus: 'system_bound', userBindingStatus: 'waiting_user_claim' }
|
|
}
|
|
|
|
return { systemBindingStatus: 'pending_binding', userBindingStatus: 'not_started' }
|
|
}
|
|
|
|
function isTaskSystemBound(task) {
|
|
return Boolean(task && (getTaskPrimaryInventoryItemId(task) || getTaskPrimaryClaimTokenId(task)))
|
|
}
|
|
|
|
function parseTaskContext(task) {
|
|
const value = task?.context_json
|
|
|
|
if (!value) {
|
|
return {}
|
|
}
|
|
|
|
if (typeof value === 'object') {
|
|
return value
|
|
}
|
|
|
|
try {
|
|
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
|
|
}
|
|
|
|
function getTaskPrimaryClaimTokenId(task) {
|
|
const value = Number(task?.primary_claim_token_id || 0)
|
|
return Number.isFinite(value) && value > 0 ? value : null
|
|
}
|
|
|
|
function getTaskClaimExpiresAt(task) {
|
|
return task?.claim_expires_at || task?.primary_claim_expires_at || null
|
|
}
|
|
|
|
function getTaskRetryCount(task) {
|
|
return Number(task?.attempt_count || 0)
|
|
}
|
|
|
|
function resolveDisplayShopName(provider, shopId, shopName) {
|
|
const normalizedShopName = String(shopName || '').trim()
|
|
if (normalizedShopName) {
|
|
return normalizedShopName
|
|
}
|
|
|
|
const normalizedShopId = String(shopId || '').trim()
|
|
if (!normalizedShopId) {
|
|
return ''
|
|
}
|
|
|
|
if (String(provider || '').trim().toLowerCase() === 'agiso') {
|
|
const configuredName = String(getAgisoShopConfig(normalizedShopId)?.shopName || '').trim()
|
|
if (configuredName) {
|
|
return configuredName
|
|
}
|
|
}
|
|
|
|
return normalizedShopId
|
|
}
|
|
|
|
function normalizeInventoryImportRows(payload) {
|
|
const rows = []
|
|
const directRows = Array.isArray(payload.rows) ? payload.rows : []
|
|
const bulkCodes = Array.isArray(payload.codes) ? payload.codes : []
|
|
|
|
if (directRows.length > 0) {
|
|
for (const row of directRows) {
|
|
const skuCode = String(row?.skuCode || '').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 || !displayValue) {
|
|
continue
|
|
}
|
|
|
|
rows.push({ skuCode, displayValue, batchNo, credentialType })
|
|
}
|
|
}
|
|
|
|
if (bulkCodes.length > 0) {
|
|
const skuCode = String(payload.skuCode || '').trim()
|
|
const batchNo = String(payload.batchNo || '').trim()
|
|
const credentialType = String(payload.credentialType || 'tencent_code').trim() || 'tencent_code'
|
|
|
|
if (!skuCode) {
|
|
throw createHttpError('批量导入时缺少 skuCode', {
|
|
statusCode: 400,
|
|
errorCode: 'admin_inventory_import_missing_sku',
|
|
})
|
|
}
|
|
|
|
for (const rawValue of bulkCodes) {
|
|
const displayValue = String(rawValue || '').trim()
|
|
if (!displayValue) {
|
|
continue
|
|
}
|
|
rows.push({ skuCode, displayValue, batchNo, credentialType })
|
|
}
|
|
}
|
|
|
|
return dedupeRows(rows)
|
|
}
|
|
|
|
function dedupeRows(rows) {
|
|
const seen = new Set()
|
|
const output = []
|
|
|
|
for (const row of rows) {
|
|
const key = `${row.skuCode}::${row.credentialType || 'tencent_code'}::${row.displayValue}`
|
|
if (seen.has(key)) {
|
|
continue
|
|
}
|
|
seen.add(key)
|
|
output.push(row)
|
|
}
|
|
|
|
return output
|
|
}
|
|
|
|
function maskSecret(value) {
|
|
const normalized = String(value || '').trim()
|
|
if (!normalized) {
|
|
return ''
|
|
}
|
|
|
|
if (normalized.length <= 10) {
|
|
return `${normalized.slice(0, 2)}****${normalized.slice(-2)}`
|
|
}
|
|
|
|
return `${normalized.slice(0, 6)}****${normalized.slice(-6)}`
|
|
}
|
|
|
|
function normalizeRecord(value) {
|
|
return value && typeof value === 'object' && !Array.isArray(value) ? value : {}
|
|
}
|
|
|
|
function extractWebhookPayload(body) {
|
|
const normalizedBody = normalizeRecord(body)
|
|
const rawJson = String(normalizedBody.json || normalizedBody.JSON || '').trim()
|
|
|
|
if (rawJson) {
|
|
return normalizeRecord(safeParseJson(rawJson))
|
|
}
|
|
|
|
return normalizedBody
|
|
}
|
|
|
|
function extractWebhookItemSources(payload) {
|
|
const normalizedPayload = normalizeRecord(payload)
|
|
const candidates = [
|
|
normalizedPayload.orders,
|
|
normalizedPayload.Orders,
|
|
normalizedPayload.items,
|
|
normalizedPayload.Items,
|
|
normalizedPayload.order_items,
|
|
]
|
|
|
|
for (const candidate of candidates) {
|
|
if (Array.isArray(candidate) && candidate.length > 0) {
|
|
return candidate.map((item) => normalizeRecord(item)).filter((item) => Object.keys(item).length > 0)
|
|
}
|
|
}
|
|
|
|
if (
|
|
pickFirstNonEmpty([
|
|
normalizedPayload.item_id,
|
|
normalizedPayload.itemId,
|
|
normalizedPayload.ItemId,
|
|
normalizedPayload.num_iid,
|
|
normalizedPayload.numIid,
|
|
normalizedPayload.NumIid,
|
|
])
|
|
) {
|
|
return [normalizedPayload]
|
|
}
|
|
|
|
return []
|
|
}
|
|
|
|
function pickFirstNonEmpty(values) {
|
|
for (const value of values) {
|
|
if (typeof value === 'string' && value.trim()) {
|
|
return value.trim()
|
|
}
|
|
|
|
if (typeof value === 'number' && Number.isFinite(value)) {
|
|
return String(value)
|
|
}
|
|
}
|
|
|
|
return ''
|
|
}
|
|
|
|
function maskCode(value) {
|
|
const text = String(value || '').trim()
|
|
if (!text) {
|
|
return ''
|
|
}
|
|
if (text.length <= 8) {
|
|
return `${text.slice(0, 2)}****${text.slice(-2)}`
|
|
}
|
|
return `${text.slice(0, 4)}****${text.slice(-4)}`
|
|
}
|