1465 lines
49 KiB
JavaScript
1465 lines
49 KiB
JavaScript
// @ts-check
|
||
|
||
import {
|
||
createInventoryItems,
|
||
invalidateInventoryItem,
|
||
listInventoryItems,
|
||
markInventoryItemDelivered,
|
||
releaseReservedInventoryItem,
|
||
} from '../../repositories/inventory-repo.js'
|
||
import { updateClaimToken } from '../../repositories/claim-token-repo.js'
|
||
import { listOrderItemsByOrderId } from '../../repositories/order-item-repo.js'
|
||
import { getOrderById } from '../../repositories/order-repo.js'
|
||
import { updateTask } from '../../repositories/task-repo.js'
|
||
import {
|
||
getTaskInventoryBindingById,
|
||
listTaskInventoryBindingsByTaskId,
|
||
} from '../../repositories/task-inventory-binding-repo.js'
|
||
import { createTaskEvent } from '../../repositories/task-event-repo.js'
|
||
import { getWebhookEventById } from '../../repositories/webhook-event-repo.js'
|
||
import { createTaskClaimToken } from '../claim/claim-service.js'
|
||
import { confirmClaimRoleForAdminTask, redeemClaimTaskForAdminTask } from '../claim/claim-session-service.js'
|
||
import { reserveInventoryForTask } from '../order/inventory-service.js'
|
||
import { normalizeProductName } from '../order/product-match-service.js'
|
||
import { replayAgisoTradeWebhookEvent } from '../order/webhook-service.js'
|
||
import { ensureAgisoXianyuAutoDeliveryForDeliveredTask } from '../platforms/agiso/xianyu/auto-delivery-service.js'
|
||
import { getCloudtentaclesSourceConfig } from '../platforms/cloudtentacles/source-config-service.js'
|
||
import { getCloudtentaclesSessionState } from '../platforms/cloudtentacles/session-state-service.js'
|
||
import {
|
||
buyCloudtentaclesSku,
|
||
getCloudtentaclesAsset,
|
||
listCloudtentaclesSku,
|
||
useCloudtentaclesSku,
|
||
} from '../platforms/cloudtentacles/catalog-service.js'
|
||
import { getCloudtentaclesKnapsack } from '../platforms/cloudtentacles/knapsack-service.js'
|
||
import {
|
||
appointCloudtentaclesVirtualNumber,
|
||
backCloudtentaclesVirtualNumber,
|
||
fetchCloudtentaclesVirtualNumberCode,
|
||
generateCloudtentaclesLoginCode,
|
||
getCloudtentaclesBindUrl,
|
||
verifyCloudtentaclesLoginCode,
|
||
} from '../platforms/cloudtentacles/virtual-number-service.js'
|
||
import { closeTencentBrowserSession } from '../session/session.js'
|
||
import { createHttpError } from '../../utils/http.js'
|
||
import { nowIso } from '../../utils/time.js'
|
||
import {
|
||
canViewerConfirmAssistedRole,
|
||
canViewerRedeemAssistedTask,
|
||
createAdminViewerContext,
|
||
getTaskPrimaryClaimTokenId,
|
||
getTaskPrimaryInventoryItemId,
|
||
isAssistedClaimTask,
|
||
isManualDispatchTask,
|
||
parseTaskContext,
|
||
} from './admin-read-shared-helpers.js'
|
||
import {
|
||
getRequiredInventoryItem,
|
||
mapAdminInventoryListItem,
|
||
} from './admin-inventory-read-helpers.js'
|
||
import {
|
||
getRequiredTask,
|
||
mapTaskActionPayload,
|
||
} from './admin-task-read-helpers.js'
|
||
|
||
/** @typedef {import('../../types/admin-read-inputs.js').AdminEntityIdInput} AdminEntityIdInput */
|
||
/** @typedef {import('../../types/admin-read-inputs.js').AdminViewerSessionInput} AdminViewerSessionInput */
|
||
/** @typedef {import('../../types/admin-write-inputs.js').AdminInventoryCreateInput} AdminInventoryCreateInput */
|
||
/** @typedef {import('../../types/admin-write-inputs.js').AdminInventoryImportInput} AdminInventoryImportInput */
|
||
/** @typedef {import('../../types/admin-write-inputs.js').AdminInventoryImportRowInput} AdminInventoryImportRowInput */
|
||
/** @typedef {import('../../types/admin-write-inputs.js').AdminInventoryInvalidateInput} AdminInventoryInvalidateInput */
|
||
/** @typedef {import('../../types/admin-write-models.js').AdminInventoryImportResponse} AdminInventoryImportResponse */
|
||
/** @typedef {import('../../types/admin-write-models.js').AdminInventoryMutationResponse} AdminInventoryMutationResponse */
|
||
/** @typedef {import('../../types/admin-write-models.js').AdminTaskActionResponse} AdminTaskActionResponse */
|
||
/** @typedef {import('../../types/admin-write-models.js').AdminTaskBindingReleaseResponse} AdminTaskBindingReleaseResponse */
|
||
/** @typedef {import('../../types/admin-write-models.js').AdminTaskManualDispatchResponse} AdminTaskManualDispatchResponse */
|
||
/** @typedef {import('../../types/admin-write-models.js').AdminWebhookReplayResponse} AdminWebhookReplayResponse */
|
||
/** @typedef {import('../../types/admin-write-inputs.js').AdminTaskKuaishouCloudDispatchInput} AdminTaskKuaishouCloudDispatchInput */
|
||
|
||
const KUAISHOU_CLOUD_FIXED_VN_KEY = '1'
|
||
|
||
/** @returns {Promise<AdminInventoryMutationResponse>} */
|
||
/** @param {AdminInventoryCreateInput} [payload] */
|
||
export async function createAdminInventoryItem(payload = /** @type {AdminInventoryCreateInput} */ ({})) {
|
||
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'
|
||
const inventoryGroupCode = String(payload.inventoryGroupCode || '').trim()
|
||
|
||
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,
|
||
inventoryGroupCode,
|
||
createdAt: now,
|
||
updatedAt: now,
|
||
},
|
||
])
|
||
|
||
if (created === 0) {
|
||
throw createHttpError('库存凭据已存在，不能重复新增', {
|
||
statusCode: 409,
|
||
errorCode: 'admin_inventory_duplicate',
|
||
})
|
||
}
|
||
|
||
const { items } = await listInventoryItems({
|
||
page: 1,
|
||
pageSize: 20,
|
||
skuCode,
|
||
inventoryGroupCode,
|
||
})
|
||
const createdItem = items.find((item) => item.display_value === displayValue && item.inventory_group_code === inventoryGroupCode) || null
|
||
|
||
return {
|
||
inventoryItem: createdItem ? await mapAdminInventoryListItem(createdItem) : null,
|
||
}
|
||
}
|
||
|
||
/** @returns {Promise<AdminInventoryImportResponse>} */
|
||
/** @param {AdminInventoryImportInput} [payload] */
|
||
export async function importAdminInventoryItems(payload = /** @type {AdminInventoryImportInput} */ ({})) {
|
||
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,
|
||
inventoryGroupCode: row.inventoryGroupCode,
|
||
createdAt: now,
|
||
updatedAt: now,
|
||
}))
|
||
|
||
const created = await createInventoryItems(normalizedRows)
|
||
|
||
return {
|
||
total: normalizedRows.length,
|
||
created,
|
||
duplicated: normalizedRows.length - created,
|
||
}
|
||
}
|
||
|
||
/** @returns {Promise<AdminInventoryMutationResponse>} */
|
||
/** @param {AdminEntityIdInput} inventoryItemId */
|
||
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),
|
||
}
|
||
}
|
||
|
||
/** @returns {Promise<AdminInventoryMutationResponse>} */
|
||
/** @param {AdminEntityIdInput} inventoryItemId */
|
||
/** @param {AdminInventoryInvalidateInput} [payload] */
|
||
export async function invalidateAdminInventoryItem(
|
||
inventoryItemId,
|
||
payload = /** @type {AdminInventoryInvalidateInput} */ ({}),
|
||
) {
|
||
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),
|
||
}
|
||
}
|
||
|
||
/** @returns {Promise<AdminWebhookReplayResponse>} */
|
||
/** @param {AdminEntityIdInput} eventId */
|
||
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,
|
||
}
|
||
}
|
||
|
||
/** @returns {Promise<AdminTaskActionResponse>} */
|
||
/** @param {AdminEntityIdInput} taskId */
|
||
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',
|
||
})
|
||
}
|
||
|
||
const now = nowIso()
|
||
await releaseReservedInventoryItem(primaryInventoryItemId, now)
|
||
const updatedTask = await updateTask(task.id, {
|
||
task_status: 'waiting_inventory',
|
||
inventory_status: 'pending',
|
||
last_error: '已手动释放预占库存项',
|
||
updated_at: now,
|
||
})
|
||
|
||
return {
|
||
task: mapTaskActionPayload(updatedTask),
|
||
}
|
||
}
|
||
|
||
/** @returns {Promise<AdminTaskBindingReleaseResponse>} */
|
||
/** @param {AdminEntityIdInput} taskId */
|
||
/** @param {AdminEntityIdInput} bindingId */
|
||
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),
|
||
}
|
||
}
|
||
|
||
/** @returns {Promise<AdminTaskActionResponse>} */
|
||
/** @param {AdminEntityIdInput} taskId */
|
||
/** @param {AdminViewerSessionInput | null} [session] */
|
||
export async function regenerateAdminTaskClaimLink(taskId, session = null) {
|
||
const task = await getRequiredTask(taskId)
|
||
const primaryClaimTokenId = getTaskPrimaryClaimTokenId(task)
|
||
const viewerContext = createAdminViewerContext(session)
|
||
|
||
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 (!viewerContext.canManageTaskLifecycle && !isAssistedClaimTask(task)) {
|
||
throw createHttpError('当前账号只能重发半自动客服任务的领取链接', {
|
||
statusCode: 403,
|
||
errorCode: 'admin_task_regenerate_permission_denied',
|
||
})
|
||
}
|
||
|
||
const now = nowIso()
|
||
if (primaryClaimTokenId) {
|
||
await updateClaimToken(primaryClaimTokenId, {
|
||
status: 'revoked',
|
||
updated_at: now,
|
||
})
|
||
}
|
||
|
||
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: now,
|
||
})
|
||
|
||
return {
|
||
task: mapTaskActionPayload(updatedTask),
|
||
claimUrl: claimToken.claimUrl,
|
||
token: claimToken.token,
|
||
}
|
||
}
|
||
|
||
/** @returns {Promise<AdminTaskActionResponse>} */
|
||
/** @param {AdminEntityIdInput} taskId */
|
||
/** @param {AdminViewerSessionInput | null} [session] */
|
||
export async function confirmAdminTaskAssistedRole(taskId, session = null) {
|
||
const task = await getRequiredTask(taskId)
|
||
const viewerContext = createAdminViewerContext(session)
|
||
ensureViewerCanOperateAssistedTask(task, viewerContext, 'confirm')
|
||
await confirmClaimRoleForAdminTask(task.id)
|
||
const updatedTask = await getRequiredTask(task.id)
|
||
|
||
return {
|
||
task: mapTaskActionPayload(updatedTask),
|
||
}
|
||
}
|
||
|
||
/** @returns {Promise<AdminTaskActionResponse>} */
|
||
/** @param {AdminEntityIdInput} taskId */
|
||
/** @param {AdminViewerSessionInput | null} [session] */
|
||
export async function redeemAdminTaskAssisted(taskId, session = null) {
|
||
const task = await getRequiredTask(taskId)
|
||
const viewerContext = createAdminViewerContext(session)
|
||
ensureViewerCanOperateAssistedTask(task, viewerContext, 'redeem')
|
||
await redeemClaimTaskForAdminTask(task.id)
|
||
const updatedTask = await getRequiredTask(task.id)
|
||
|
||
return {
|
||
task: mapTaskActionPayload(updatedTask),
|
||
}
|
||
}
|
||
|
||
/** @returns {Promise<AdminTaskActionResponse>} */
|
||
/** @param {AdminEntityIdInput} taskId */
|
||
export async function closeAdminTask(taskId) {
|
||
return closeAdminTaskWithDeps(taskId)
|
||
}
|
||
|
||
/** @returns {Promise<AdminTaskActionResponse>} */
|
||
/** @param {AdminEntityIdInput} taskId */
|
||
export async function closeAdminTaskWithDeps(
|
||
taskId,
|
||
{
|
||
getRequiredTask: getTask = getRequiredTask,
|
||
listTaskInventoryBindingsByTaskId: listBindings = listTaskInventoryBindingsByTaskId,
|
||
releaseReservedInventoryItem: releaseReserved = releaseReservedInventoryItem,
|
||
updateClaimToken: updateToken = updateClaimToken,
|
||
updateTask: updateTaskRecord = updateTask,
|
||
createTaskEvent: createEvent = createTaskEvent,
|
||
closeTencentBrowserSession: closeSession = closeTencentBrowserSession,
|
||
nowIso: getNowIso = nowIso,
|
||
} = {},
|
||
) {
|
||
const task = await getTask(taskId)
|
||
|
||
if (task.task_status === 'redeemed') {
|
||
throw createHttpError('已兑换任务不能关闭', {
|
||
statusCode: 409,
|
||
errorCode: 'admin_task_close_not_allowed',
|
||
})
|
||
}
|
||
|
||
const now = getNowIso()
|
||
const bindings = await listBindings(task.id)
|
||
const reservedBindings = bindings.filter((binding) => String(binding.binding_status || '').trim() === 'reserved')
|
||
const releasedInventoryItemIds = Array.from(new Set(reservedBindings.map((binding) => Number(binding.inventory_item_id)).filter((id) => id > 0)))
|
||
const hasConsumedBindings = bindings.some((binding) => String(binding.binding_status || '').trim() === 'consumed')
|
||
const primaryClaimTokenId = getTaskPrimaryClaimTokenId(task)
|
||
let browserSessionClosed = false
|
||
|
||
if (primaryClaimTokenId) {
|
||
await updateToken(primaryClaimTokenId, {
|
||
status: 'revoked',
|
||
expired_at: now,
|
||
updated_at: now,
|
||
})
|
||
}
|
||
|
||
if (task.browser_session_id) {
|
||
try {
|
||
await closeSession(task.browser_session_id)
|
||
browserSessionClosed = true
|
||
} catch (error) {
|
||
if (!isRecoverableTaskSessionCloseError(error)) {
|
||
throw error
|
||
}
|
||
}
|
||
}
|
||
|
||
for (const inventoryItemId of releasedInventoryItemIds) {
|
||
await releaseReserved(inventoryItemId, now)
|
||
}
|
||
|
||
const closeReasonParts = ['已手动关闭任务']
|
||
if (primaryClaimTokenId) {
|
||
closeReasonParts.push('领取链接已失效')
|
||
}
|
||
if (releasedInventoryItemIds.length > 0) {
|
||
closeReasonParts.push('预占库存已释放')
|
||
}
|
||
|
||
const updatedTask = await updateTaskRecord(task.id, {
|
||
task_status: 'closed',
|
||
inventory_status: hasConsumedBindings ? 'consumed' : 'pending',
|
||
delivery_status: 'closed',
|
||
user_action_status: 'closed',
|
||
claim_expires_at: primaryClaimTokenId ? now : task.claim_expires_at,
|
||
browser_session_id: '',
|
||
last_error: task.last_error || closeReasonParts.join('，'),
|
||
updated_at: now,
|
||
})
|
||
|
||
await createEvent(task.id, 'task_closed', {
|
||
claimTokenRevoked: Boolean(primaryClaimTokenId),
|
||
releasedInventoryItemIds,
|
||
releasedInventoryCount: releasedInventoryItemIds.length,
|
||
browserSessionClosed,
|
||
}, now)
|
||
|
||
return {
|
||
task: mapTaskActionPayload(updatedTask),
|
||
}
|
||
}
|
||
|
||
/** @returns {Promise<AdminTaskActionResponse>} */
|
||
/** @param {AdminEntityIdInput} taskId */
|
||
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),
|
||
}
|
||
}
|
||
|
||
/** @returns {Promise<AdminTaskActionResponse>} */
|
||
/** @param {AdminEntityIdInput} taskId */
|
||
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 taskContext = parseTaskContext(task)
|
||
const primaryRequirement = taskContext.primaryRequirement || null
|
||
const orderItems = await listOrderItemsByOrderId(task.order_id)
|
||
const orderItem = orderItems.find((item) => item.id === task.order_item_id) || 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',
|
||
inventoryGroupCodes: resolveTaskInventoryGroupCodes(task),
|
||
})
|
||
|
||
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 response = {
|
||
task: mapTaskActionPayload(updatedTask),
|
||
}
|
||
|
||
if (claimUrl) {
|
||
response.claimUrl = claimUrl
|
||
response.token = token
|
||
}
|
||
|
||
return response
|
||
}
|
||
|
||
/** @returns {Promise<AdminTaskManualDispatchResponse>} */
|
||
/** @param {AdminEntityIdInput} taskId */
|
||
/** @param {{ outcome?: string, resultMessage?: string, deliveryReference?: string, deliveredCredential?: string }} [payload] */
|
||
/** @param {AdminViewerSessionInput | null} [session] */
|
||
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)
|
||
|
||
const taskAfterAutoDelivery = outcome === 'delivered'
|
||
? (await ensureAgisoXianyuAutoDeliveryForDeliveredTask({
|
||
order: await getOrderById(task.order_id),
|
||
task: updatedTask,
|
||
trigger: 'manual_dispatch_completed',
|
||
})).task || updatedTask
|
||
: updatedTask
|
||
|
||
return {
|
||
outcome,
|
||
task: mapTaskActionPayload(taskAfterAutoDelivery),
|
||
}
|
||
}
|
||
|
||
/** @returns {Promise<AdminTaskActionResponse>} */
|
||
/** @param {AdminEntityIdInput} taskId */
|
||
/** @param {AdminViewerSessionInput | null} [session] */
|
||
export async function prepareAdminTaskKuaishouCloudFulfillment(taskId, session = null) {
|
||
const task = await getRequiredTask(taskId)
|
||
const now = nowIso()
|
||
const viewerContext = createAdminViewerContext(session)
|
||
|
||
if (!viewerContext.canManageTaskLifecycle) {
|
||
throw createHttpError('当前账号没有权限准备绑定资源', {
|
||
statusCode: 403,
|
||
errorCode: 'admin_task_prepare_kuaishou_cloud_forbidden',
|
||
})
|
||
}
|
||
|
||
if (!isKuaishouCloudTask(task)) {
|
||
throw createHttpError('当前任务不是快手 cloud 履约任务', {
|
||
statusCode: 409,
|
||
errorCode: 'admin_task_not_kuaishou_cloud',
|
||
})
|
||
}
|
||
|
||
const taskContext = parseTaskContext(task)
|
||
const flow = normalizeKuaishouCloudFlow(taskContext.kuaishouCloudFulfillment)
|
||
const cloudContext = resolvePersistedCloudtentaclesContext()
|
||
const [knapsack, skuList] = await Promise.all([
|
||
getCloudtentaclesKnapsack(cloudContext),
|
||
listCloudtentaclesSku(cloudContext),
|
||
])
|
||
const resolvedBinding = resolveKuaishouCloudBindingResources(flow, {
|
||
skuItems: Array.isArray(skuList.items) ? skuList.items : [],
|
||
knapsackItems: Array.isArray(knapsack.items) ? knapsack.items : [],
|
||
})
|
||
const vnKeyCandidates = resolveKuaishouCloudVnKeyCandidates({
|
||
flow,
|
||
binding: resolvedBinding,
|
||
})
|
||
|
||
if (!resolvedBinding.skuId || vnKeyCandidates.length === 0) {
|
||
throw createHttpError('当前任务缺少可用 cloud 资源，且无法根据商品名自动解析 SKU / VN Key', {
|
||
statusCode: 409,
|
||
errorCode: 'admin_task_kuaishou_cloud_missing_binding_config',
|
||
})
|
||
}
|
||
|
||
const flowWithResolvedBinding = {
|
||
...flow,
|
||
binding: {
|
||
...flow.binding,
|
||
skuId: resolvedBinding.skuId,
|
||
skuName: resolvedBinding.skuName,
|
||
vnKey: KUAISHOU_CLOUD_FIXED_VN_KEY,
|
||
},
|
||
}
|
||
const knapsackItem = resolvedBinding.knapsackItem
|
||
let usedKnapsack = Number(knapsackItem?.count || 0) > 0
|
||
let purchaseTriggered = false
|
||
let assetBefore = 0
|
||
let assetAfter = 0
|
||
|
||
if (!usedKnapsack) {
|
||
if (!flowWithResolvedBinding.purchase.autoBuyEnabled) {
|
||
throw createHttpError('背包中没有现成库存，且当前配置未开启自动购买', {
|
||
statusCode: 409,
|
||
errorCode: 'admin_task_kuaishou_cloud_auto_buy_disabled',
|
||
})
|
||
}
|
||
|
||
const asset = await getCloudtentaclesAsset(cloudContext)
|
||
const targetSku = resolvedBinding.skuItem
|
||
|
||
if (!targetSku) {
|
||
throw createHttpError(`cloudtentacles 未找到 SKU ${flowWithResolvedBinding.binding.skuId}`, {
|
||
statusCode: 404,
|
||
errorCode: 'admin_task_kuaishou_cloud_sku_not_found',
|
||
})
|
||
}
|
||
|
||
assetBefore = Number(asset.asset || 0) || 0
|
||
const targetPrice = Number(targetSku.price || 0) || 0
|
||
const requiredAsset = targetPrice + flowWithResolvedBinding.purchase.minAssetReserve
|
||
if (assetBefore < requiredAsset) {
|
||
throw createHttpError(`余额不足，当前 ${assetBefore}，至少需要 ${requiredAsset}`, {
|
||
statusCode: 409,
|
||
errorCode: 'admin_task_kuaishou_cloud_asset_not_enough',
|
||
})
|
||
}
|
||
|
||
await buyCloudtentaclesSku({
|
||
...cloudContext,
|
||
id: flowWithResolvedBinding.binding.skuId,
|
||
count: 1,
|
||
})
|
||
purchaseTriggered = true
|
||
|
||
const assetResult = await getCloudtentaclesAsset(cloudContext)
|
||
assetAfter = Number(assetResult.asset || 0) || 0
|
||
}
|
||
|
||
const preparedBinding = await prepareKuaishouCloudBindResourceWithFallback({
|
||
cloudContext,
|
||
vnKeyCandidates,
|
||
})
|
||
const vnId = preparedBinding.vnId
|
||
const vnPhone = preparedBinding.vnPhone
|
||
const bindUrlResult = {
|
||
bindUrl: preparedBinding.bindUrl,
|
||
}
|
||
|
||
const nextContext = {
|
||
...taskContext,
|
||
kuaishouCloudFulfillment: {
|
||
...flowWithResolvedBinding,
|
||
binding: {
|
||
...flowWithResolvedBinding.binding,
|
||
vnKey: preparedBinding.vnKey,
|
||
prepareStatus: 'ready',
|
||
vnId,
|
||
vnPhone,
|
||
bindUrl: bindUrlResult.bindUrl,
|
||
bindPreparedAt: now,
|
||
},
|
||
purchase: {
|
||
...flowWithResolvedBinding.purchase,
|
||
usedKnapsack,
|
||
purchaseTriggered,
|
||
assetBefore,
|
||
assetAfter,
|
||
purchaseAt: purchaseTriggered ? now : flowWithResolvedBinding.purchase.purchaseAt,
|
||
},
|
||
},
|
||
}
|
||
|
||
const updatedTask = await updateTask(task.id, {
|
||
task_status: 'waiting_binding',
|
||
inventory_status: 'not_required',
|
||
user_action_status: 'pending',
|
||
last_error: '',
|
||
context_json: JSON.stringify(nextContext),
|
||
updated_at: now,
|
||
})
|
||
|
||
await createTaskEvent(task.id, 'kuaishou_cloud_binding_prepared', {
|
||
skuId: flowWithResolvedBinding.binding.skuId,
|
||
skuName: flowWithResolvedBinding.binding.skuName,
|
||
vnKey: preparedBinding.vnKey,
|
||
vnId,
|
||
vnPhoneMasked: maskPhone(vnPhone),
|
||
bindUrl: bindUrlResult.bindUrl,
|
||
purchaseTriggered,
|
||
usedKnapsack,
|
||
resolvedByName: resolvedBinding.resolvedByName,
|
||
}, now)
|
||
|
||
return {
|
||
task: mapTaskActionPayload(updatedTask),
|
||
}
|
||
}
|
||
|
||
/** @returns {Promise<AdminTaskActionResponse>} */
|
||
/** @param {AdminEntityIdInput} taskId */
|
||
/** @param {AdminTaskKuaishouCloudDispatchInput} [payload] */
|
||
/** @param {AdminViewerSessionInput | null} [session] */
|
||
export async function dispatchAdminTaskKuaishouCloudFulfillment(taskId, payload = {}, session = null) {
|
||
const task = await getRequiredTask(taskId)
|
||
const now = nowIso()
|
||
const viewerContext = createAdminViewerContext(session)
|
||
|
||
if (!viewerContext.canManageTaskLifecycle) {
|
||
throw createHttpError('当前账号没有权限执行发货', {
|
||
statusCode: 403,
|
||
errorCode: 'admin_task_dispatch_kuaishou_cloud_forbidden',
|
||
})
|
||
}
|
||
|
||
if (!isKuaishouCloudTask(task)) {
|
||
throw createHttpError('当前任务不是快手 cloud 履约任务', {
|
||
statusCode: 409,
|
||
errorCode: 'admin_task_not_kuaishou_cloud',
|
||
})
|
||
}
|
||
|
||
const taskContext = parseTaskContext(task)
|
||
const flow = normalizeKuaishouCloudFlow(taskContext.kuaishouCloudFulfillment)
|
||
const cloudContext = resolvePersistedCloudtentaclesContext()
|
||
|
||
if (!flow.binding.skuId || !flow.binding.vnId || !flow.binding.vnPhone) {
|
||
throw createHttpError('当前任务还没有准备好绑定资源，请先准备绑定资源', {
|
||
statusCode: 409,
|
||
errorCode: 'admin_task_kuaishou_cloud_not_prepared',
|
||
})
|
||
}
|
||
|
||
const ticketCode = String(payload.ticketCode || '').trim()
|
||
const dispatchResult = await useCloudtentaclesSku({
|
||
...cloudContext,
|
||
id: flow.binding.skuId,
|
||
virtualNumberId: flow.binding.vnId,
|
||
phone: flow.binding.vnPhone,
|
||
})
|
||
|
||
const nextContext = {
|
||
...taskContext,
|
||
kuaishouCloudFulfillment: {
|
||
...flow,
|
||
ticket: {
|
||
...flow.ticket,
|
||
code: ticketCode || flow.ticket.code,
|
||
capturedAt: ticketCode ? now : flow.ticket.capturedAt,
|
||
capturedBy: ticketCode && session
|
||
? {
|
||
userId: Number(session.userId || 0) || 0,
|
||
username: String(session.username || '').trim(),
|
||
role: String(session.role || '').trim(),
|
||
}
|
||
: flow.ticket.capturedBy,
|
||
},
|
||
dispatch: {
|
||
...flow.dispatch,
|
||
status: 'success',
|
||
dispatchAt: now,
|
||
dispatchBy: session
|
||
? {
|
||
userId: Number(session.userId || 0) || 0,
|
||
username: String(session.username || '').trim(),
|
||
role: String(session.role || '').trim(),
|
||
}
|
||
: null,
|
||
sendType: Number(dispatchResult.sendType || 0) || 0,
|
||
note: String(dispatchResult.note || dispatchResult.responseMessage || '').trim(),
|
||
},
|
||
},
|
||
}
|
||
|
||
const updatedTask = await updateTask(task.id, {
|
||
task_status: 'dispatched_pending_return',
|
||
delivery_status: 'delivered',
|
||
result_code: 'kuaishou_cloud_dispatched',
|
||
result_message: String(dispatchResult.responseMessage || dispatchResult.note || 'cloudtentacles 发货成功').trim(),
|
||
last_error: '',
|
||
context_json: JSON.stringify(nextContext),
|
||
updated_at: now,
|
||
})
|
||
|
||
await createTaskEvent(task.id, 'kuaishou_cloud_dispatched', {
|
||
ticketCodeMasked: maskCode(ticketCode),
|
||
skuId: flow.binding.skuId,
|
||
vnId: flow.binding.vnId,
|
||
vnPhoneMasked: maskPhone(flow.binding.vnPhone),
|
||
sendType: dispatchResult.sendType,
|
||
note: dispatchResult.note,
|
||
}, now)
|
||
|
||
return {
|
||
task: mapTaskActionPayload(updatedTask),
|
||
}
|
||
}
|
||
|
||
/** @returns {Promise<AdminTaskActionResponse>} */
|
||
/** @param {AdminEntityIdInput} taskId */
|
||
/** @param {AdminViewerSessionInput | null} [session] */
|
||
export async function returnNumberAdminTaskKuaishouCloudFulfillment(taskId, session = null) {
|
||
const task = await getRequiredTask(taskId)
|
||
const now = nowIso()
|
||
const viewerContext = createAdminViewerContext(session)
|
||
|
||
if (!viewerContext.canManageTaskLifecycle) {
|
||
throw createHttpError('当前账号没有权限退还号码', {
|
||
statusCode: 403,
|
||
errorCode: 'admin_task_return_kuaishou_cloud_forbidden',
|
||
})
|
||
}
|
||
|
||
if (!isKuaishouCloudTask(task)) {
|
||
throw createHttpError('当前任务不是快手 cloud 履约任务', {
|
||
statusCode: 409,
|
||
errorCode: 'admin_task_not_kuaishou_cloud',
|
||
})
|
||
}
|
||
|
||
const taskContext = parseTaskContext(task)
|
||
const flow = normalizeKuaishouCloudFlow(taskContext.kuaishouCloudFulfillment)
|
||
const cloudContext = resolvePersistedCloudtentaclesContext()
|
||
|
||
if (!flow.binding.vnId || !flow.binding.vnKey) {
|
||
throw createHttpError('当前任务缺少可退还的虚拟号信息', {
|
||
statusCode: 409,
|
||
errorCode: 'admin_task_kuaishou_cloud_missing_return_context',
|
||
})
|
||
}
|
||
|
||
await backCloudtentaclesVirtualNumber({
|
||
...cloudContext,
|
||
key: flow.binding.vnKey,
|
||
id: flow.binding.vnId,
|
||
})
|
||
|
||
const nextContext = {
|
||
...taskContext,
|
||
kuaishouCloudFulfillment: {
|
||
...flow,
|
||
returnNumber: {
|
||
...flow.returnNumber,
|
||
status: 'success',
|
||
returnedAt: now,
|
||
returnedBy: session
|
||
? {
|
||
userId: Number(session.userId || 0) || 0,
|
||
username: String(session.username || '').trim(),
|
||
role: String(session.role || '').trim(),
|
||
}
|
||
: null,
|
||
},
|
||
},
|
||
}
|
||
|
||
const updatedTask = await updateTask(task.id, {
|
||
task_status: 'completed',
|
||
delivery_status: 'delivered',
|
||
result_code: 'kuaishou_cloud_completed',
|
||
result_message: 'cloudtentacles 发货并退号完成',
|
||
redeemed_at: now,
|
||
last_error: '',
|
||
context_json: JSON.stringify(nextContext),
|
||
updated_at: now,
|
||
})
|
||
|
||
await createTaskEvent(task.id, 'kuaishou_cloud_number_returned', {
|
||
vnId: flow.binding.vnId,
|
||
vnPhoneMasked: maskPhone(flow.binding.vnPhone),
|
||
}, now)
|
||
|
||
return {
|
||
task: mapTaskActionPayload(updatedTask),
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @param {AdminInventoryImportInput} payload
|
||
* @returns {Array<Required<Pick<AdminInventoryImportRowInput, 'skuCode' | 'displayValue' | 'batchNo' | 'credentialType' | 'inventoryGroupCode'>>>}
|
||
*/
|
||
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'
|
||
const inventoryGroupCode = String(row?.inventoryGroupCode || payload.inventoryGroupCode || '').trim()
|
||
|
||
if (!skuCode || !displayValue) {
|
||
continue
|
||
}
|
||
|
||
rows.push({ skuCode, displayValue, batchNo, credentialType, inventoryGroupCode })
|
||
}
|
||
}
|
||
|
||
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'
|
||
const inventoryGroupCode = String(payload.inventoryGroupCode || '').trim()
|
||
|
||
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, inventoryGroupCode })
|
||
}
|
||
}
|
||
|
||
return dedupeRows(rows)
|
||
}
|
||
|
||
function isKuaishouCloudTask(task) {
|
||
return String(task?.executor_key || '').trim() === 'kuaishou_ct_assisted'
|
||
}
|
||
|
||
function resolvePersistedCloudtentaclesContext() {
|
||
const source = getCloudtentaclesSourceConfig()
|
||
const session = getCloudtentaclesSessionState()
|
||
const token = String(session.token || '').trim()
|
||
|
||
if (!token) {
|
||
throw createHttpError('当前 cloudtentacles 没有可用 token，请先到平台配置完成登录校验', {
|
||
statusCode: 409,
|
||
errorCode: 'admin_task_kuaishou_cloud_missing_cloud_token',
|
||
})
|
||
}
|
||
|
||
return {
|
||
baseUrl: String(session.baseUrl || source.baseUrl || '').trim() || 'https://123.207.217.176',
|
||
token,
|
||
deviceId: String(session.deviceId || source.deviceId || '-').trim() || '-',
|
||
deviceType: Number(session.deviceType ?? source.deviceType ?? 0),
|
||
}
|
||
}
|
||
|
||
function normalizeKuaishouCloudFlow(value) {
|
||
const source = value && typeof value === 'object' ? value : {}
|
||
const binding = source.binding && typeof source.binding === 'object' ? source.binding : {}
|
||
const purchase = source.purchase && typeof source.purchase === 'object' ? source.purchase : {}
|
||
const dispatch = source.dispatch && typeof source.dispatch === 'object' ? source.dispatch : {}
|
||
const returnNumber = source.returnNumber && typeof source.returnNumber === 'object' ? source.returnNumber : {}
|
||
const consume = source.consume && typeof source.consume === 'object' ? source.consume : {}
|
||
const ticket = source.ticket && typeof source.ticket === 'object' ? source.ticket : {}
|
||
|
||
return {
|
||
...source,
|
||
configId: String(source.configId || '').trim(),
|
||
internalSkuCode: String(source.internalSkuCode || '').trim(),
|
||
internalSkuName: String(source.internalSkuName || '').trim(),
|
||
ticket: {
|
||
code: String(ticket.code || '').trim(),
|
||
capturedAt: ticket.capturedAt || null,
|
||
capturedBy: ticket.capturedBy || null,
|
||
},
|
||
binding: {
|
||
prepareStatus: String(binding.prepareStatus || 'pending').trim() || 'pending',
|
||
cloudSourceKey: String(binding.cloudSourceKey || 'default').trim() || 'default',
|
||
skuId: Number(binding.skuId || 0) || 0,
|
||
skuName: String(binding.skuName || '').trim(),
|
||
vnKey: String(binding.vnKey || '').trim(),
|
||
vnId: Number(binding.vnId || 0) || 0,
|
||
vnPhone: String(binding.vnPhone || '').trim(),
|
||
bindUrl: String(binding.bindUrl || '').trim(),
|
||
bindPreparedAt: binding.bindPreparedAt || null,
|
||
},
|
||
purchase: {
|
||
autoBuyEnabled: purchase.autoBuyEnabled !== false,
|
||
minAssetReserve: Number(purchase.minAssetReserve || 0) || 0,
|
||
usedKnapsack: purchase.usedKnapsack === true,
|
||
purchaseTriggered: purchase.purchaseTriggered === true,
|
||
assetBefore: Number(purchase.assetBefore || 0) || 0,
|
||
assetAfter: Number(purchase.assetAfter || 0) || 0,
|
||
purchaseAt: purchase.purchaseAt || null,
|
||
},
|
||
dispatch: {
|
||
status: String(dispatch.status || 'pending').trim() || 'pending',
|
||
dispatchAt: dispatch.dispatchAt || null,
|
||
dispatchBy: dispatch.dispatchBy || null,
|
||
sendType: Number(dispatch.sendType || 0) || 0,
|
||
note: String(dispatch.note || '').trim(),
|
||
},
|
||
returnNumber: {
|
||
status: String(returnNumber.status || 'pending').trim() || 'pending',
|
||
returnedAt: returnNumber.returnedAt || null,
|
||
returnedBy: returnNumber.returnedBy || null,
|
||
autoReturnEnabled: returnNumber.autoReturnEnabled === true,
|
||
},
|
||
consume: {
|
||
status: String(consume.status || 'pending').trim() || 'pending',
|
||
shopId: String(consume.shopId || '').trim(),
|
||
autoConsumeEnabled: consume.autoConsumeEnabled === true,
|
||
},
|
||
}
|
||
}
|
||
|
||
function resolveKuaishouCloudBindingResources(flow, { skuItems = [], knapsackItems = [] } = {}) {
|
||
const normalizedSkuItems = Array.isArray(skuItems) ? skuItems.filter(isCloudSkuLikeItem) : []
|
||
const normalizedKnapsackItems = Array.isArray(knapsackItems) ? knapsackItems.filter(isCloudSkuLikeItem) : []
|
||
const currentSkuId = Number(flow?.binding?.skuId || 0) || 0
|
||
const currentVnKey = String(flow?.binding?.vnKey || '').trim()
|
||
const currentSkuName = String(flow?.binding?.skuName || '').trim()
|
||
const nameCandidates = collectKuaishouCloudNameCandidates(flow)
|
||
|
||
const skuItemById = currentSkuId > 0
|
||
? normalizedSkuItems.find((item) => Number(item.id || 0) === currentSkuId) || null
|
||
: null
|
||
const knapsackItemById = currentSkuId > 0
|
||
? normalizedKnapsackItems.find((item) => Number(item.id || 0) === currentSkuId) || null
|
||
: null
|
||
|
||
if (skuItemById || knapsackItemById) {
|
||
const matchedItem = skuItemById || knapsackItemById
|
||
return {
|
||
skuId: Number(matchedItem?.id || 0) || 0,
|
||
skuName: String(currentSkuName || matchedItem?.name || '').trim(),
|
||
vnKey: KUAISHOU_CLOUD_FIXED_VN_KEY,
|
||
skuItem: skuItemById,
|
||
knapsackItem: knapsackItemById,
|
||
resolvedByName: false,
|
||
}
|
||
}
|
||
|
||
const matchedSkuItem = findCloudItemByNames(normalizedSkuItems, nameCandidates)
|
||
const matchedKnapsackItem = findCloudItemByNames(
|
||
normalizedKnapsackItems,
|
||
nameCandidates,
|
||
matchedSkuItem ? Number(matchedSkuItem.id || 0) : 0,
|
||
)
|
||
const matchedItem = matchedSkuItem || matchedKnapsackItem
|
||
|
||
return {
|
||
skuId: Number(matchedItem?.id || 0) || 0,
|
||
skuName: String(currentSkuName || matchedItem?.name || '').trim(),
|
||
vnKey: KUAISHOU_CLOUD_FIXED_VN_KEY,
|
||
skuItem: matchedSkuItem,
|
||
knapsackItem: matchedKnapsackItem,
|
||
resolvedByName: Boolean(matchedItem),
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @param {{ flow?: any, binding?: any }} [input]
|
||
*/
|
||
function resolveKuaishouCloudVnKeyCandidates(input = {}) {
|
||
return [KUAISHOU_CLOUD_FIXED_VN_KEY]
|
||
}
|
||
|
||
/**
|
||
* @param {{ cloudContext?: Record<string, unknown>, vnKeyCandidates?: string[] }} [input]
|
||
*/
|
||
async function prepareKuaishouCloudBindResourceWithFallback(input = {}) {
|
||
const { cloudContext = {}, vnKeyCandidates = [] } = input
|
||
const candidates = Array.isArray(vnKeyCandidates) ? vnKeyCandidates : []
|
||
let lastError = null
|
||
|
||
for (const vnKey of candidates) {
|
||
let vnId = 0
|
||
let vnPhone = ''
|
||
|
||
try {
|
||
const appointed = await appointCloudtentaclesVirtualNumber({
|
||
...cloudContext,
|
||
key: vnKey,
|
||
})
|
||
vnId = Number(appointed.item?.id || 0)
|
||
vnPhone = String(appointed.item?.phone || '').trim()
|
||
|
||
if (!vnId || !vnPhone) {
|
||
throw createHttpError('申请虚拟号成功但返回数据不完整', {
|
||
statusCode: 502,
|
||
errorCode: 'admin_task_kuaishou_cloud_invalid_vn',
|
||
})
|
||
}
|
||
|
||
await generateCloudtentaclesLoginCode({
|
||
...cloudContext,
|
||
key: vnKey,
|
||
id: vnId,
|
||
})
|
||
|
||
const fetchedCode = await fetchCloudtentaclesVirtualNumberCode({
|
||
...cloudContext,
|
||
key: vnKey,
|
||
phone: vnPhone,
|
||
})
|
||
|
||
await verifyCloudtentaclesLoginCode({
|
||
...cloudContext,
|
||
key: vnKey,
|
||
id: vnId,
|
||
code: fetchedCode.code,
|
||
})
|
||
|
||
const bindUrlResult = await getCloudtentaclesBindUrl({
|
||
...cloudContext,
|
||
key: vnKey,
|
||
id: vnId,
|
||
})
|
||
|
||
return {
|
||
vnKey,
|
||
vnId,
|
||
vnPhone,
|
||
bindUrl: String(bindUrlResult.bindUrl || '').trim(),
|
||
}
|
||
} catch (error) {
|
||
lastError = error
|
||
|
||
if (vnId > 0) {
|
||
try {
|
||
await backCloudtentaclesVirtualNumber({
|
||
...cloudContext,
|
||
key: vnKey,
|
||
id: vnId,
|
||
})
|
||
} catch {
|
||
// 兜底退号失败时保留原始错误，避免吞掉主链路异常
|
||
}
|
||
}
|
||
|
||
if (!isRecoverableKuaishouCloudVnKeyError(error)) {
|
||
throw error
|
||
}
|
||
}
|
||
}
|
||
|
||
throw lastError || createHttpError('没有找到可用的 VN Key', {
|
||
statusCode: 409,
|
||
errorCode: 'admin_task_kuaishou_cloud_missing_binding_config',
|
||
})
|
||
}
|
||
|
||
function collectKuaishouCloudNameCandidates(flow) {
|
||
return Array.from(new Set([
|
||
String(flow?.binding?.skuName || '').trim(),
|
||
String(flow?.internalSkuName || '').trim(),
|
||
String(flow?.internalSkuCode || '').trim(),
|
||
].filter(Boolean)))
|
||
}
|
||
|
||
function findCloudItemByNames(items, nameCandidates, preferredId = 0) {
|
||
const normalizedItems = Array.isArray(items) ? items : []
|
||
const normalizedNames = nameCandidates
|
||
.map((item) => ({
|
||
raw: String(item || '').trim(),
|
||
normalized: normalizeProductName(item),
|
||
}))
|
||
.filter((item) => item.raw && item.normalized)
|
||
|
||
if (normalizedNames.length === 0 || normalizedItems.length === 0) {
|
||
return preferredId > 0
|
||
? normalizedItems.find((item) => Number(item.id || 0) === preferredId) || null
|
||
: null
|
||
}
|
||
|
||
if (preferredId > 0) {
|
||
const preferred = normalizedItems.find((item) => Number(item.id || 0) === preferredId) || null
|
||
if (preferred) {
|
||
return preferred
|
||
}
|
||
}
|
||
|
||
const exactMatches = normalizedItems.filter((item) => {
|
||
const itemName = normalizeProductName(item.name)
|
||
return normalizedNames.some((candidate) => candidate.normalized === itemName)
|
||
})
|
||
if (exactMatches.length > 0) {
|
||
return exactMatches[0]
|
||
}
|
||
|
||
const partialMatches = normalizedItems.filter((item) => {
|
||
const itemName = normalizeProductName(item.name)
|
||
return normalizedNames.some((candidate) => itemName.includes(candidate.normalized) || candidate.normalized.includes(itemName))
|
||
})
|
||
if (partialMatches.length > 0) {
|
||
return partialMatches.sort((left, right) => String(left.name || '').length - String(right.name || '').length)[0]
|
||
}
|
||
|
||
return null
|
||
}
|
||
|
||
function isCloudSkuLikeItem(item) {
|
||
return Boolean(item) && typeof item === 'object' && Number(item.id || 0) > 0
|
||
}
|
||
|
||
function maskPhone(value) {
|
||
const text = String(value || '').trim()
|
||
if (!text) {
|
||
return ''
|
||
}
|
||
|
||
if (text.length <= 7) {
|
||
return `${text.slice(0, 2)}***${text.slice(-2)}`
|
||
}
|
||
|
||
return `${text.slice(0, 3)}****${text.slice(-4)}`
|
||
}
|
||
|
||
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)}`
|
||
}
|
||
|
||
/**
|
||
* @param {Array<Required<Pick<AdminInventoryImportRowInput, 'skuCode' | 'displayValue' | 'batchNo' | 'credentialType' | 'inventoryGroupCode'>>>} 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 resolveTaskInventoryGroupCodes(task) {
|
||
const taskContext = parseTaskContext(task)
|
||
const inventoryGroupCode = String(taskContext?.inventoryGroupCode || '').trim()
|
||
return inventoryGroupCode ? [inventoryGroupCode] : null
|
||
}
|
||
|
||
|
||
/**
|
||
* @param {Awaited<ReturnType<typeof getRequiredTask>>} task
|
||
* @param {ReturnType<typeof createAdminViewerContext>} viewerContext
|
||
* @param {'confirm' | 'redeem'} action
|
||
*/
|
||
function ensureViewerCanOperateAssistedTask(task, viewerContext, action) {
|
||
if (!viewerContext.canOperateAssistedTask || !isAssistedClaimTask(task)) {
|
||
throw createHttpError('当前账号没有此操作权限', {
|
||
statusCode: 403,
|
||
errorCode: 'admin_task_assisted_permission_denied',
|
||
})
|
||
}
|
||
|
||
if (action === 'confirm' && !canViewerConfirmAssistedRole(task, viewerContext)) {
|
||
throw createHttpError('当前任务状态还不能确认角色', {
|
||
statusCode: 409,
|
||
errorCode: 'admin_task_assisted_confirm_not_allowed',
|
||
})
|
||
}
|
||
|
||
if (action === 'redeem' && !canViewerRedeemAssistedTask(task, viewerContext)) {
|
||
throw createHttpError('当前任务状态还不能开始兑换', {
|
||
statusCode: 409,
|
||
errorCode: 'admin_task_assisted_redeem_not_allowed',
|
||
})
|
||
}
|
||
}
|
||
|
||
function isRecoverableTaskSessionCloseError(error) {
|
||
const errorCode = String(error?.errorCode || error?.code || '').trim()
|
||
return errorCode === 'session_not_found' || errorCode === 'session_closed'
|
||
}
|
||
|
||
function isRecoverableKuaishouCloudVnKeyError(error) {
|
||
const errorCode = String(error?.errorCode || error?.code || '').trim()
|
||
const errorMessage = String(error?.message || '').trim()
|
||
return errorCode === 'cloudtentacles_vn_bind_url_failed'
|
||
&& errorMessage.includes('不支持的游戏类型')
|
||
}
|
||
|
||
function normalizeManualDispatchOutcome(value) {
|
||
const normalized = String(value || '').trim().toLowerCase()
|
||
|
||
if (normalized === 'failed') {
|
||
return 'failed'
|
||
}
|
||
|
||
return 'delivered'
|
||
}
|
||
|
||
function getTaskClaimExpiresAt(task) {
|
||
return task?.claim_expires_at || task?.primary_claim_expires_at || null
|
||
}
|