461 lines
13 KiB
TypeScript
461 lines
13 KiB
TypeScript
import { query, withTransaction } from '../db/client.js'
|
|
import type { PoolClient } from 'pg'
|
|
|
|
import type {
|
|
TaskCreateInput,
|
|
TaskListQueryInput,
|
|
TaskRuntimeContextPatch,
|
|
TaskUpdatePatch,
|
|
} from '../types/repository-inputs.js'
|
|
import type {
|
|
TaskListQueryResult,
|
|
TaskRow,
|
|
} from '../types/repository-rows.js'
|
|
|
|
type TaskQueryExecutor = (text: string, params?: unknown[]) => Promise<{ rows: unknown[] }>
|
|
|
|
type TaskRuntimeContextRow = {
|
|
browser_session_id: string
|
|
login_type: string
|
|
nickname: string
|
|
role_id: string
|
|
role_name: string
|
|
area: string
|
|
partition_name: string
|
|
screenshot_path: string
|
|
artifacts_json: string | Record<string, unknown>
|
|
state_json: string | Record<string, unknown>
|
|
}
|
|
|
|
const TASK_FIELDS = `
|
|
ft.*,
|
|
ct.id AS primary_claim_token_id,
|
|
ct.token AS primary_claim_token,
|
|
ct.status AS primary_claim_token_status,
|
|
ct.expired_at AS primary_claim_expires_at,
|
|
ctx.browser_session_id,
|
|
ctx.login_type,
|
|
ctx.nickname,
|
|
ctx.role_id,
|
|
ctx.role_name,
|
|
ctx.area,
|
|
ctx.partition_name,
|
|
ctx.screenshot_path,
|
|
ctx.artifacts_json,
|
|
ctx.state_json,
|
|
inv.inventory_item_id AS primary_inventory_item_id,
|
|
inv.display_value AS primary_inventory_display_value,
|
|
inv.credential_type AS primary_inventory_credential_type,
|
|
inv.binding_status AS primary_inventory_binding_status
|
|
`
|
|
|
|
const TASK_JOINS = `
|
|
FROM fulfillment_tasks ft
|
|
LEFT JOIN claim_tokens ct ON ct.task_id = ft.id
|
|
LEFT JOIN task_runtime_contexts ctx ON ctx.task_id = ft.id
|
|
LEFT JOIN LATERAL (
|
|
SELECT
|
|
tib.inventory_item_id,
|
|
tib.binding_status,
|
|
ii.display_value,
|
|
ii.credential_type
|
|
FROM task_inventory_bindings tib
|
|
JOIN inventory_items ii ON ii.id = tib.inventory_item_id
|
|
WHERE tib.task_id = ft.id AND tib.binding_status IN ('reserved', 'consumed')
|
|
ORDER BY
|
|
CASE tib.binding_status
|
|
WHEN 'reserved' THEN 0
|
|
WHEN 'consumed' THEN 1
|
|
ELSE 2
|
|
END ASC,
|
|
tib.id DESC
|
|
LIMIT 1
|
|
) inv ON TRUE
|
|
`
|
|
|
|
function buildTaskSelect(extraFields = ''): string {
|
|
const normalizedExtra = String(extraFields || '').trim()
|
|
const fieldSql = normalizedExtra ? `${TASK_FIELDS}, ${normalizedExtra}` : TASK_FIELDS
|
|
return `SELECT ${fieldSql} ${TASK_JOINS}`
|
|
}
|
|
|
|
export async function listTasksByOrderId(orderId: number | string): Promise<TaskRow[]> {
|
|
const result = await query<TaskRow>(
|
|
`${buildTaskSelect()}
|
|
WHERE ft.order_id = $1
|
|
ORDER BY ft.id ASC`,
|
|
[Number(orderId)],
|
|
)
|
|
return result.rows
|
|
}
|
|
|
|
export async function createTask(input: TaskCreateInput): Promise<TaskRow | null> {
|
|
return withTransaction(async (client) => {
|
|
const taskResult = await client.query<{ id: number }>(
|
|
`
|
|
INSERT INTO fulfillment_tasks (
|
|
order_id,
|
|
order_item_id,
|
|
unit_index,
|
|
task_no,
|
|
provider,
|
|
platform,
|
|
shop_id,
|
|
shop_name,
|
|
platform_order_id,
|
|
profile_id,
|
|
executor_key,
|
|
task_status,
|
|
inventory_status,
|
|
delivery_status,
|
|
result_code,
|
|
result_message,
|
|
claim_token,
|
|
claim_expires_at,
|
|
automation_mode,
|
|
requires_claim,
|
|
user_action_status,
|
|
attempt_count,
|
|
last_error,
|
|
context_json,
|
|
created_at,
|
|
updated_at
|
|
) VALUES (
|
|
$1, $2, $3, $4, $5, $6, $7, $8, $9, $10,
|
|
$11, $12, $13, $14, $15, $16, $17, $18, $19,
|
|
$20, $21, $22, $23, $24::jsonb, $25, $26
|
|
)
|
|
RETURNING id
|
|
`,
|
|
[
|
|
input.orderId,
|
|
input.orderItemId,
|
|
input.unitIndex,
|
|
input.taskNo,
|
|
input.provider,
|
|
input.platform,
|
|
input.shopId || '',
|
|
input.shopName || '',
|
|
input.platformOrderId,
|
|
input.profileId,
|
|
input.executorKey,
|
|
input.taskStatus || 'pending_payment',
|
|
input.inventoryStatus || 'pending',
|
|
input.deliveryStatus || 'pending',
|
|
input.resultCode || '',
|
|
input.resultMessage || '',
|
|
input.claimToken || '',
|
|
input.claimExpiresAt || null,
|
|
input.automationMode || 'manual',
|
|
Boolean(input.requiresClaim),
|
|
input.userActionStatus || 'not_required',
|
|
input.attemptCount || 0,
|
|
input.lastError || '',
|
|
input.contextJson || '{}',
|
|
input.createdAt,
|
|
input.updatedAt,
|
|
],
|
|
)
|
|
|
|
const taskId = Number(taskResult.rows[0]?.id || 0)
|
|
if (input.runtimeContext) {
|
|
await upsertTaskRuntimeContextWithClient(client, taskId, input.runtimeContext, input.createdAt)
|
|
}
|
|
|
|
return getTaskByIdWithExecutor(client.query.bind(client) as TaskQueryExecutor, taskId)
|
|
})
|
|
}
|
|
|
|
export async function updateTask(taskId: number | string, patch: TaskUpdatePatch): Promise<TaskRow | null> {
|
|
const current = await getTaskById(taskId)
|
|
if (!current) {
|
|
return null
|
|
}
|
|
|
|
return withTransaction(async (client) => {
|
|
const next = { ...current, ...patch }
|
|
|
|
await client.query(
|
|
`
|
|
UPDATE fulfillment_tasks
|
|
SET
|
|
task_status = $1,
|
|
inventory_status = $2,
|
|
delivery_status = $3,
|
|
result_code = $4,
|
|
result_message = $5,
|
|
claim_token = $6,
|
|
claim_expires_at = $7,
|
|
automation_mode = $8,
|
|
requires_claim = $9,
|
|
user_action_status = $10,
|
|
attempt_count = $11,
|
|
last_error = $12,
|
|
context_json = $13::jsonb,
|
|
claimed_at = $14,
|
|
role_confirmed_at = $15,
|
|
redeemed_at = $16,
|
|
updated_at = $17
|
|
WHERE id = $18
|
|
`,
|
|
[
|
|
next.task_status,
|
|
next.inventory_status,
|
|
next.delivery_status,
|
|
next.result_code,
|
|
next.result_message,
|
|
next.claim_token || '',
|
|
next.claim_expires_at || null,
|
|
next.automation_mode || 'manual',
|
|
Boolean(next.requires_claim),
|
|
next.user_action_status || 'not_required',
|
|
next.attempt_count || 0,
|
|
next.last_error || '',
|
|
next.context_json || '{}',
|
|
next.claimed_at || null,
|
|
next.role_confirmed_at || null,
|
|
next.redeemed_at || null,
|
|
next.updated_at,
|
|
Number(taskId),
|
|
],
|
|
)
|
|
|
|
if (containsRuntimeContextPatch(patch)) {
|
|
await upsertTaskRuntimeContextWithClient(client, Number(taskId), {
|
|
browserSessionId: patch.browser_session_id,
|
|
loginType: patch.login_type,
|
|
nickname: patch.nickname,
|
|
roleId: patch.role_id,
|
|
roleName: patch.role_name,
|
|
area: patch.area,
|
|
partitionName: patch.partition_name,
|
|
screenshotPath: patch.screenshot_path,
|
|
artifactsJson: patch.artifacts_json,
|
|
stateJson: patch.state_json,
|
|
}, patch.updated_at || current.updated_at)
|
|
}
|
|
|
|
return getTaskByIdWithExecutor(client.query.bind(client) as TaskQueryExecutor, taskId)
|
|
})
|
|
}
|
|
|
|
export async function getTaskById(taskId: number | string): Promise<TaskRow | null> {
|
|
return getTaskByIdWithExecutor(query, taskId)
|
|
}
|
|
|
|
export async function findTaskByClaimTokenId(claimTokenId: number | string): Promise<TaskRow | null> {
|
|
const result = await query<TaskRow>(
|
|
`${buildTaskSelect()}
|
|
JOIN claim_tokens ctf ON ctf.task_id = ft.id
|
|
WHERE ctf.id = $1
|
|
LIMIT 1`,
|
|
[Number(claimTokenId)],
|
|
)
|
|
return result.rows[0] || null
|
|
}
|
|
|
|
export async function listTasks({
|
|
page = 1,
|
|
pageSize = 20,
|
|
status = '',
|
|
platformOrderId = '',
|
|
taskNo = '',
|
|
skuCode = '',
|
|
roleId = '',
|
|
dateFrom = '',
|
|
dateTo = '',
|
|
}: TaskListQueryInput = {}): Promise<TaskListQueryResult> {
|
|
const offset = (page - 1) * pageSize
|
|
const filters: string[] = []
|
|
const params: unknown[] = []
|
|
|
|
if (status) {
|
|
params.push(status)
|
|
filters.push(`ft.task_status = $${params.length}`)
|
|
}
|
|
|
|
if (platformOrderId) {
|
|
params.push(`%${platformOrderId}%`)
|
|
filters.push(`ft.platform_order_id ILIKE $${params.length}`)
|
|
}
|
|
|
|
if (taskNo) {
|
|
params.push(`%${taskNo}%`)
|
|
filters.push(`ft.task_no ILIKE $${params.length}`)
|
|
}
|
|
|
|
if (skuCode) {
|
|
params.push(skuCode)
|
|
filters.push(`oi.sku_code = $${params.length}`)
|
|
}
|
|
|
|
if (roleId) {
|
|
params.push(`%${roleId}%`)
|
|
filters.push(`ctx.role_id ILIKE $${params.length}`)
|
|
}
|
|
|
|
if (dateFrom) {
|
|
params.push(dateFrom)
|
|
filters.push(`ft.created_at >= $${params.length}`)
|
|
}
|
|
|
|
if (dateTo) {
|
|
params.push(dateTo)
|
|
filters.push(`ft.created_at <= $${params.length}`)
|
|
}
|
|
|
|
const whereClause = filters.length > 0 ? `WHERE ${filters.join(' AND ')}` : ''
|
|
const totalResult = await query<{ [column: string]: unknown, total: number }>(
|
|
`
|
|
SELECT COUNT(*)::int AS total
|
|
FROM fulfillment_tasks ft
|
|
LEFT JOIN order_items oi ON oi.id = ft.order_item_id
|
|
LEFT JOIN task_runtime_contexts ctx ON ctx.task_id = ft.id
|
|
${whereClause}
|
|
`,
|
|
params,
|
|
)
|
|
|
|
params.push(pageSize)
|
|
params.push(offset)
|
|
const itemsResult = await query<TaskRow>(
|
|
`${buildTaskSelect('oi.sku_code, oi.sku_name, oi.quantity')}
|
|
LEFT JOIN order_items oi ON oi.id = ft.order_item_id
|
|
${whereClause}
|
|
ORDER BY ft.id DESC
|
|
LIMIT $${params.length - 1} OFFSET $${params.length}`,
|
|
params,
|
|
)
|
|
|
|
return {
|
|
items: itemsResult.rows,
|
|
total: Number(totalResult.rows[0]?.total || 0),
|
|
}
|
|
}
|
|
|
|
async function upsertTaskRuntimeContextWithClient(
|
|
client: PoolClient,
|
|
taskId: number | string,
|
|
patch: TaskRuntimeContextPatch = {},
|
|
timestamp: string | undefined,
|
|
): Promise<void> {
|
|
const currentResult = await client.query<TaskRuntimeContextRow>(
|
|
'SELECT * FROM task_runtime_contexts WHERE task_id = $1 LIMIT 1',
|
|
[Number(taskId)],
|
|
)
|
|
const current = currentResult.rows[0] || null
|
|
|
|
const next = {
|
|
browser_session_id: patch.browserSessionId ?? current?.browser_session_id ?? '',
|
|
login_type: patch.loginType ?? current?.login_type ?? '',
|
|
nickname: patch.nickname ?? current?.nickname ?? '',
|
|
role_id: patch.roleId ?? current?.role_id ?? '',
|
|
role_name: patch.roleName ?? current?.role_name ?? '',
|
|
area: patch.area ?? current?.area ?? '',
|
|
partition_name: patch.partitionName ?? current?.partition_name ?? '',
|
|
screenshot_path: patch.screenshotPath ?? current?.screenshot_path ?? '',
|
|
artifacts_json: patch.artifactsJson ?? current?.artifacts_json ?? '{}',
|
|
state_json: patch.stateJson ?? current?.state_json ?? '{}',
|
|
updated_at: timestamp,
|
|
}
|
|
|
|
if (!current) {
|
|
await client.query(
|
|
`
|
|
INSERT INTO task_runtime_contexts (
|
|
task_id,
|
|
browser_session_id,
|
|
login_type,
|
|
nickname,
|
|
role_id,
|
|
role_name,
|
|
area,
|
|
partition_name,
|
|
screenshot_path,
|
|
artifacts_json,
|
|
state_json,
|
|
created_at,
|
|
updated_at
|
|
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10::jsonb, $11::jsonb, $12, $13)
|
|
`,
|
|
[
|
|
Number(taskId),
|
|
next.browser_session_id,
|
|
next.login_type,
|
|
next.nickname,
|
|
next.role_id,
|
|
next.role_name,
|
|
next.area,
|
|
next.partition_name,
|
|
next.screenshot_path,
|
|
typeof next.artifacts_json === 'string' ? next.artifacts_json : JSON.stringify(next.artifacts_json || {}),
|
|
typeof next.state_json === 'string' ? next.state_json : JSON.stringify(next.state_json || {}),
|
|
timestamp,
|
|
timestamp,
|
|
],
|
|
)
|
|
return
|
|
}
|
|
|
|
await client.query(
|
|
`
|
|
UPDATE task_runtime_contexts
|
|
SET
|
|
browser_session_id = $1,
|
|
login_type = $2,
|
|
nickname = $3,
|
|
role_id = $4,
|
|
role_name = $5,
|
|
area = $6,
|
|
partition_name = $7,
|
|
screenshot_path = $8,
|
|
artifacts_json = $9::jsonb,
|
|
state_json = $10::jsonb,
|
|
updated_at = $11
|
|
WHERE task_id = $12
|
|
`,
|
|
[
|
|
next.browser_session_id,
|
|
next.login_type,
|
|
next.nickname,
|
|
next.role_id,
|
|
next.role_name,
|
|
next.area,
|
|
next.partition_name,
|
|
next.screenshot_path,
|
|
typeof next.artifacts_json === 'string' ? next.artifacts_json : JSON.stringify(next.artifacts_json || {}),
|
|
typeof next.state_json === 'string' ? next.state_json : JSON.stringify(next.state_json || {}),
|
|
timestamp,
|
|
Number(taskId),
|
|
],
|
|
)
|
|
}
|
|
|
|
async function getTaskByIdWithExecutor(
|
|
executor: TaskQueryExecutor,
|
|
taskId: number | string,
|
|
): Promise<TaskRow | null> {
|
|
const result = await executor(
|
|
`${buildTaskSelect()}
|
|
WHERE ft.id = $1
|
|
LIMIT 1`,
|
|
[Number(taskId)],
|
|
)
|
|
return (result.rows[0] as TaskRow | undefined) || null
|
|
}
|
|
|
|
function containsRuntimeContextPatch(patch: TaskUpdatePatch = {}): boolean {
|
|
return [
|
|
'browser_session_id',
|
|
'login_type',
|
|
'nickname',
|
|
'role_id',
|
|
'role_name',
|
|
'area',
|
|
'partition_name',
|
|
'screenshot_path',
|
|
'artifacts_json',
|
|
'state_json',
|
|
].some((key) => Object.prototype.hasOwnProperty.call(patch, key))
|
|
}
|