Files
order_site/apps/backend/src/services/claim/session/lifecycle.ts
T
2026-05-21 15:45:21 +08:00

176 lines
4.9 KiB
TypeScript

import {
closeTencentBrowserSession,
createTencentBrowserSession,
reloadTencentBrowserSession,
} from '../../session/session.js'
import { updateTask } from '../../../repositories/task-repo.js'
import { nowIso } from '../../../utils/time.js'
import { getClaimContext, getClaimContextByTaskId } from './context.js'
import { clearTaskSession, loadTaskSession, syncTaskWithSession } from './runtime.js'
import {
assertTaskCanProceed,
buildClaimDetailPayload,
isRecoverableSessionError,
normalizeClaimLoginType,
} from './shared.js'
type JsonObject = Record<string, any>
export async function createClaimSession(token: unknown, payload: JsonObject = {}) {
return createClaimSessionWithContextLoader(
() => getClaimContext(token),
payload,
)
}
export async function createClaimSessionForAdminTask(taskId: unknown, payload: JsonObject = {}) {
return createClaimSessionWithContextLoader(
() => getClaimContextByTaskId(taskId),
payload,
)
}
export async function reloadClaimSession(token: unknown) {
return reloadClaimSessionWithContextLoader(() => getClaimContext(token))
}
export async function reloadClaimSessionForAdminTask(taskId: unknown) {
return reloadClaimSessionWithContextLoader(() => getClaimContextByTaskId(taskId))
}
export async function closeClaimSession(token: unknown) {
return closeClaimSessionWithContextLoader(() => getClaimContext(token))
}
export async function closeClaimSessionForAdminTask(taskId: unknown) {
return closeClaimSessionWithContextLoader(() => getClaimContextByTaskId(taskId))
}
async function createClaimSessionWithContextLoader(loadContext: () => Promise<JsonObject>, payload: JsonObject = {}) {
const context = await loadContext()
assertTaskCanProceed(context.task)
const requestedLoginType = normalizeClaimLoginType(payload.loginType)
const forceRecreate = Boolean(payload.forceRecreate)
let task = context.task
if (task.browser_session_id) {
const existing = await loadTaskSession(task, { includeQrImage: true })
task = existing.task
if (existing.session) {
const existingLoginType = normalizeClaimLoginType(existing.session.loginType || task.login_type)
if (!forceRecreate && existingLoginType === requestedLoginType) {
const syncedTask = await syncTaskWithSession(task, existing.session)
return buildClaimDetailPayload({
claimToken: context.claimToken,
task: syncedTask,
order: context.order,
orderItem: context.orderItem,
session: existing.session,
})
}
try {
await closeTencentBrowserSession(existing.session.sessionId)
} catch (error) {
if (!isRecoverableSessionError(error)) {
throw error
}
}
task = await clearTaskSession(task, {
lastError: '',
})
}
}
const session = await createTencentBrowserSession({
loginType: requestedLoginType,
})
const updatedTask = await updateTask(task.id, {
task_status: 'claimed',
browser_session_id: session.sessionId,
login_type: session.loginType,
user_action_status: 'claimed',
claimed_at: task.claimed_at || nowIso(),
updated_at: nowIso(),
last_error: '',
})
return buildClaimDetailPayload({
claimToken: context.claimToken,
task: updatedTask,
order: context.order,
orderItem: context.orderItem,
session,
})
}
async function reloadClaimSessionWithContextLoader(loadContext: () => Promise<JsonObject>) {
const context = await loadContext()
assertTaskCanProceed(context.task)
const active = await loadTaskSession(context.task, {
includeQrImage: true,
})
if (!active.session) {
return buildClaimDetailPayload({
claimToken: context.claimToken,
task: active.task,
order: context.order,
orderItem: context.orderItem,
session: null,
})
}
const session = await reloadTencentBrowserSession(active.session.sessionId)
const syncedTask = await syncTaskWithSession(active.task, session)
return buildClaimDetailPayload({
claimToken: context.claimToken,
task: syncedTask,
order: context.order,
orderItem: context.orderItem,
session,
})
}
async function closeClaimSessionWithContextLoader(loadContext: () => Promise<JsonObject>) {
const context = await loadContext()
assertTaskCanProceed(context.task)
let task = context.task
if (!task.browser_session_id) {
return buildClaimDetailPayload({
claimToken: context.claimToken,
task,
order: context.order,
orderItem: context.orderItem,
session: null,
})
}
try {
await closeTencentBrowserSession(task.browser_session_id)
} catch (error) {
if (!isRecoverableSessionError(error)) {
throw error
}
}
task = await clearTaskSession(task, {
lastError: '',
})
return buildClaimDetailPayload({
claimToken: context.claimToken,
task,
order: context.order,
orderItem: context.orderItem,
session: null,
})
}