384 lines
13 KiB
TypeScript
384 lines
13 KiB
TypeScript
import { safeParseJson } from './admin-query-utils.js'
|
|
import { normalizeAdminRole } from './admin-auth-service.js'
|
|
import {
|
|
parseTaskContext as parseTaskContextValue,
|
|
parseTaskState as parseTaskStateValue,
|
|
} from '../../utils/task-json.js'
|
|
|
|
import type { AdminViewerSessionInput } from '../../types/admin-read-inputs.js'
|
|
import type { OrderItemRow, TaskRow } from '../../types/repository-rows.js'
|
|
|
|
type JsonRecord = Record<string, any>
|
|
|
|
type TaskLike = Partial<TaskRow> & {
|
|
state_json?: string | JsonRecord
|
|
}
|
|
|
|
export type AdminViewerContext = {
|
|
role: string
|
|
allowedInventoryGroupCodes: string[] | null
|
|
restrictInventoryGroups: boolean
|
|
canViewSensitiveTaskData: boolean
|
|
canManageSensitiveInventory: boolean
|
|
canManageTaskLifecycle: boolean
|
|
canOperateAssistedTask: boolean
|
|
}
|
|
|
|
type RedeemResolutionAttempt = {
|
|
attempt: number
|
|
inventoryItemId: number | null
|
|
codeMasked: string
|
|
credentialType: string
|
|
outcome: string
|
|
resultCode: string
|
|
resultMessage: string
|
|
}
|
|
|
|
export function mapManualDispatchContext(
|
|
value: unknown,
|
|
viewerContext: AdminViewerContext = createAdminViewerContext(),
|
|
): JsonRecord | null {
|
|
if (!value || typeof value !== 'object') {
|
|
return null
|
|
}
|
|
|
|
const record = value as JsonRecord
|
|
return {
|
|
outcome: String(record.outcome || '').trim(),
|
|
deliveryReference: String(record.deliveryReference || '').trim(),
|
|
deliveredCredential: viewerContext.canViewSensitiveTaskData ? String(record.deliveredCredential || '').trim() : '',
|
|
resultMessage: String(record.resultMessage || '').trim(),
|
|
completedAt: record.completedAt || null,
|
|
completedBy: record.completedBy && typeof record.completedBy === 'object'
|
|
? {
|
|
userId: Number(record.completedBy.userId || 0) || 0,
|
|
username: String(record.completedBy.username || '').trim(),
|
|
role: String(record.completedBy.role || '').trim(),
|
|
}
|
|
: null,
|
|
}
|
|
}
|
|
|
|
export function mapKuaishouCloudFulfillmentContext(value: unknown): JsonRecord | null {
|
|
if (!value || typeof value !== 'object') {
|
|
return null
|
|
}
|
|
|
|
const record = value as JsonRecord
|
|
const ticket = record.ticket && typeof record.ticket === 'object' ? record.ticket : {}
|
|
const binding = record.binding && typeof record.binding === 'object' ? record.binding : {}
|
|
const role = record.role && typeof record.role === 'object' ? record.role : {}
|
|
const purchase = record.purchase && typeof record.purchase === 'object' ? record.purchase : {}
|
|
const dispatch = record.dispatch && typeof record.dispatch === 'object' ? record.dispatch : {}
|
|
const returnNumber = record.returnNumber && typeof record.returnNumber === 'object' ? record.returnNumber : {}
|
|
const consume = record.consume && typeof record.consume === 'object' ? record.consume : {}
|
|
|
|
return {
|
|
flowType: String(record.flowType || '').trim(),
|
|
configId: String(record.configId || '').trim(),
|
|
internalSkuCode: String(record.internalSkuCode || '').trim(),
|
|
internalSkuName: String(record.internalSkuName || '').trim(),
|
|
ticket: {
|
|
code: String(ticket.code || '').trim(),
|
|
capturedAt: ticket.capturedAt || null,
|
|
status: String(ticket.status || 'pending').trim() || 'pending',
|
|
verifiedAt: ticket.verifiedAt || null,
|
|
goodsTitle: String(ticket.goodsTitle || '').trim(),
|
|
leftCount: Number(ticket.leftCount || 0) || 0,
|
|
},
|
|
binding: {
|
|
prepareStatus: String(binding.prepareStatus || 'pending').trim() || 'pending',
|
|
cloudSourceKey: String(binding.cloudSourceKey || '').trim(),
|
|
cloudSourceKeyFallbacks: Array.isArray(binding.cloudSourceKeyFallbacks)
|
|
? binding.cloudSourceKeyFallbacks.map((value) => String(value || '').trim()).filter(Boolean)
|
|
: [],
|
|
resolvedSourceKey: String(binding.resolvedSourceKey || '').trim(),
|
|
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,
|
|
bindExpiresAt: binding.bindExpiresAt || null,
|
|
bindProbeAt: binding.bindProbeAt || null,
|
|
bindProbeStatus: String(binding.bindProbeStatus || '').trim(),
|
|
bindProbeMessage: String(binding.bindProbeMessage || '').trim(),
|
|
},
|
|
role: {
|
|
status: String(role.status || 'pending').trim() || 'pending',
|
|
name: String(role.name || '').trim(),
|
|
rid: String(role.rid || '').trim(),
|
|
refreshedAt: role.refreshedAt || null,
|
|
errorMessage: String(role.errorMessage || '').trim(),
|
|
rawInfo: role.rawInfo && typeof role.rawInfo === 'object' ? role.rawInfo : 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,
|
|
sendType: Number(dispatch.sendType || 0) || 0,
|
|
note: String(dispatch.note || '').trim(),
|
|
},
|
|
returnNumber: {
|
|
status: String(returnNumber.status || 'pending').trim() || 'pending',
|
|
returnedAt: returnNumber.returnedAt || null,
|
|
autoReturnEnabled: returnNumber.autoReturnEnabled === true,
|
|
},
|
|
consume: {
|
|
status: String(consume.status || 'pending').trim() || 'pending',
|
|
shopId: String(consume.shopId || '').trim(),
|
|
shopName: String(consume.shopName || '').trim(),
|
|
autoConsumeEnabled: consume.autoConsumeEnabled === true,
|
|
consumedAt: consume.consumedAt || null,
|
|
errorMessage: String(consume.errorMessage || '').trim(),
|
|
},
|
|
notes: String(record.notes || '').trim(),
|
|
}
|
|
}
|
|
|
|
export function mapRedeemResolutionContext(value: unknown): JsonRecord | null {
|
|
if (!value || typeof value !== 'object') {
|
|
return null
|
|
}
|
|
|
|
const record = value as JsonRecord
|
|
const attempts = Array.isArray(record.attempts)
|
|
? record.attempts
|
|
.map((attempt) => mapRedeemResolutionAttempt(attempt))
|
|
.filter((attempt): attempt is RedeemResolutionAttempt => Boolean(attempt))
|
|
: []
|
|
|
|
return {
|
|
status: String(record.status || '').trim(),
|
|
taskStatus: String(record.taskStatus || '').trim(),
|
|
replacementCount: Math.max(0, Number(record.replacementCount || 0)),
|
|
finishedAt: record.finishedAt || null,
|
|
attempts,
|
|
}
|
|
}
|
|
|
|
export function getTaskPrimaryInventoryItemId(task: TaskLike | null | undefined): number | null {
|
|
const value = Number(task?.primary_inventory_item_id || 0)
|
|
return Number.isFinite(value) && value > 0 ? value : null
|
|
}
|
|
|
|
export function getTaskPrimaryClaimTokenId(task: TaskLike | null | undefined): number | null {
|
|
const value = Number(task?.primary_claim_token_id || 0)
|
|
return Number.isFinite(value) && value > 0 ? value : null
|
|
}
|
|
|
|
export function createAdminViewerContext(session: AdminViewerSessionInput | null = null): AdminViewerContext {
|
|
const role = normalizeAdminRole(session?.role)
|
|
const allowedInventoryGroupCodes = role === 'support'
|
|
? normalizeInventoryGroupCodes(session?.allowedInventoryGroups)
|
|
: null
|
|
|
|
return {
|
|
role,
|
|
allowedInventoryGroupCodes,
|
|
restrictInventoryGroups: role === 'support',
|
|
canViewSensitiveTaskData: role === 'admin' || role === 'operator',
|
|
canManageSensitiveInventory: role === 'admin',
|
|
canManageTaskLifecycle: role === 'admin' || role === 'operator',
|
|
canOperateAssistedTask: role === 'admin' || role === 'operator' || role === 'support',
|
|
}
|
|
}
|
|
|
|
export async function resolveAdminTaskScreenshotUrl(
|
|
task: TaskLike,
|
|
viewerContext: AdminViewerContext,
|
|
): Promise<string> {
|
|
if (task.screenshot_path || task.browser_session_id) {
|
|
return `/api/v1/admin/tasks/${task.id}/screenshot`
|
|
}
|
|
|
|
return ''
|
|
}
|
|
|
|
export function canViewerCloseTask(task: TaskLike, viewerContext: AdminViewerContext): boolean {
|
|
if (!['admin', 'operator', 'support'].includes(viewerContext.role)) {
|
|
return false
|
|
}
|
|
|
|
return !['redeemed', 'completed', 'closed'].includes(String(task?.task_status || '').trim())
|
|
}
|
|
|
|
export function resolveDisplayShopName(provider: unknown, shopId: unknown, shopName: unknown): string {
|
|
const normalizedShopName = String(shopName || '').trim()
|
|
if (normalizedShopName) {
|
|
return normalizedShopName
|
|
}
|
|
|
|
const normalizedShopId = String(shopId || '').trim()
|
|
if (!normalizedShopId) {
|
|
return ''
|
|
}
|
|
|
|
return normalizedShopId
|
|
}
|
|
|
|
export function parseTaskContext(task: TaskLike | null | undefined): JsonRecord {
|
|
return parseTaskContextValue(task)
|
|
}
|
|
|
|
export function parseTaskState(task: TaskLike | null | undefined): JsonRecord {
|
|
return parseTaskStateValue(task)
|
|
}
|
|
|
|
export function resolveOrderItemTitle(item: Partial<OrderItemRow> | null | undefined): string {
|
|
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,
|
|
])
|
|
}
|
|
|
|
export function resolveOrderItemDeliveryMode(tasks: TaskLike[] | null | undefined, orderItemId: number | string): string {
|
|
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 (String(task.executor_key || '').trim() === 'kuaishou_ct_assisted') {
|
|
return 'kuaishou_cloud'
|
|
}
|
|
|
|
if (task.requires_claim || getTaskPrimaryClaimTokenId(task) || task.primary_claim_token || task.claim_token) {
|
|
return 'claim_link'
|
|
}
|
|
|
|
return String(task.executor_key || '').trim()
|
|
}
|
|
|
|
export function isManualDispatchTask(task: TaskLike | null | undefined): boolean {
|
|
return String(task?.executor_key || '').trim() === 'manual_dispatch'
|
|
}
|
|
|
|
export function isAssistedClaimTask(task: TaskLike | null | undefined): boolean {
|
|
return String(task?.executor_key || '').trim() === 'tencent_claim_assisted'
|
|
}
|
|
|
|
export function canRegenerateClaimLinkForViewer(task: TaskLike, viewerContext: AdminViewerContext): boolean {
|
|
if (isManualDispatchTask(task)) {
|
|
return false
|
|
}
|
|
|
|
const baseAllowed = ['link_generated', 'claimed', 'role_confirmed', 'retry_pending', 'manual_review'].includes(task.task_status)
|
|
|
|
if (!baseAllowed) {
|
|
return false
|
|
}
|
|
|
|
if (viewerContext.canManageTaskLifecycle) {
|
|
return true
|
|
}
|
|
|
|
return viewerContext.canOperateAssistedTask
|
|
&& isAssistedClaimTask(task)
|
|
&& canViewerAccessTaskInventoryGroup(task, viewerContext)
|
|
}
|
|
|
|
export function canViewerConfirmAssistedRole(task: TaskLike, viewerContext: AdminViewerContext): boolean {
|
|
if (!viewerContext.canOperateAssistedTask || !isAssistedClaimTask(task) || !canViewerAccessTaskInventoryGroup(task, viewerContext)) {
|
|
return false
|
|
}
|
|
|
|
return String(task?.task_status || '').trim() === 'claimed'
|
|
}
|
|
|
|
export function canViewerRedeemAssistedTask(task: TaskLike, viewerContext: AdminViewerContext): boolean {
|
|
if (!viewerContext.canOperateAssistedTask || !isAssistedClaimTask(task) || !canViewerAccessTaskInventoryGroup(task, viewerContext)) {
|
|
return false
|
|
}
|
|
|
|
return ['role_confirmed', 'redeeming'].includes(String(task?.task_status || '').trim())
|
|
}
|
|
|
|
export function canViewerAccessTaskInventoryGroup(
|
|
task: TaskLike,
|
|
viewerContext: AdminViewerContext = createAdminViewerContext(),
|
|
): boolean {
|
|
if (!viewerContext.restrictInventoryGroups) {
|
|
return true
|
|
}
|
|
|
|
const allowedInventoryGroupCodes = Array.isArray(viewerContext.allowedInventoryGroupCodes)
|
|
? viewerContext.allowedInventoryGroupCodes
|
|
: []
|
|
|
|
if (allowedInventoryGroupCodes.length === 0) {
|
|
return false
|
|
}
|
|
|
|
const taskContext = parseTaskContext(task)
|
|
const inventoryGroupCode = String(taskContext?.inventoryGroupCode || '').trim()
|
|
|
|
if (!inventoryGroupCode) {
|
|
return true
|
|
}
|
|
|
|
return allowedInventoryGroupCodes.includes(inventoryGroupCode)
|
|
}
|
|
|
|
export function normalizeInventoryGroupCodes(values: unknown): string[] {
|
|
return Array.from(new Set((Array.isArray(values) ? values : [])
|
|
.map((value) => String(value || '').trim())
|
|
.filter(Boolean)))
|
|
}
|
|
|
|
function mapRedeemResolutionAttempt(value: unknown): RedeemResolutionAttempt | null {
|
|
if (!value || typeof value !== 'object') {
|
|
return null
|
|
}
|
|
|
|
const record = value as JsonRecord
|
|
return {
|
|
attempt: Math.max(1, Number(record.attempt || 1)),
|
|
inventoryItemId: Number(record.inventoryItemId || 0) || null,
|
|
codeMasked: String(record.codeMasked || '').trim(),
|
|
credentialType: String(record.credentialType || '').trim(),
|
|
outcome: String(record.outcome || '').trim(),
|
|
resultCode: String(record.resultCode || '').trim(),
|
|
resultMessage: String(record.resultMessage || '').trim(),
|
|
}
|
|
}
|
|
|
|
function pickFirstNonEmpty(values: unknown[]): string {
|
|
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 ''
|
|
}
|