dachui/order_site
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'dev'

Browse Source
This commit is contained in:
zhaoxing
2026-11-02 12:04:32 +08:00
parent 8b0666caec db3f477ab3
commit 360cfceac7
38 changed files with 1615 additions and 942 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/backend/src/services/worker-platform/admin-work-order-assignment-service.ts
+22
View File
@@ -4,6 +4,7 @@ import {
countWorkerActiveOrders,
createWorkOrderEvent,
getWorkerUserById,
listWorkOrderShares,
} from '../../repositories/worker-platform/index.js'
import type { JsonObject } from '../../types/json.js'
import { createHttpError } from '../../utils/http.js'
@@ -64,6 +65,18 @@ export async function assignAdminWorkOrderToWorker(
})
}
// 已有拼单份额的订单不能再按整单指派；放在核销电子凭证之前，
// 避免“凭证已核销但指派失败”的副作用。
const activeShares = (await listWorkOrderShares(workOrder.id)).filter(
(share) => share.status !== 'cancelled',
)
if (activeShares.length > 0) {
throw createHttpError('该订单已有拼单份额，不能按整单指派；请使用拼单管理', {
statusCode: 409,
errorCode: 'work_order_has_shares',
})
}
const voucherConsume = await consumeIndustryVouchersBeforeWorkOrderAssign(workOrder)
if (!voucherConsume.ok) {
const failedAt = nowIso()
@@ -112,6 +125,15 @@ export async function assignAdminWorkOrderToWorker(
{ statusCode: 409, errorCode: 'worker_deposit_insufficient' },
)
}
if (failureReason === 'work_order_has_shares') {
throw createHttpError(
resolveAssignFailureMessage(
voucherConsume.voucherCount,
'该订单已有拼单份额，不能按整单指派；请使用拼单管理',
),
{ statusCode: 409, errorCode: 'work_order_has_shares' },
)
}
if (!updated) {
throw createHttpError(
resolveAssignFailureMessage(voucherConsume.voucherCount, '指派失败，订单状态可能已变化'),
apps/backend/src/services/worker-platform/admin-work-order-material-reset-service.ts
+74
View File
@@ -0,0 +1,74 @@
import { withTransaction } from '../../db/client.js'
import { WORK_ORDER_STATUS } from '../../domain/work-order-status.js'
import {
createWorkOrderEventWithClient,
getWorkOrderForUpdateWithClient,
resetWorkOrderMaterialStatusWithClient,
} from '../../repositories/worker-platform/index.js'
import { createHttpError } from '../../utils/http.js'
import { nowIso } from '../../utils/time.js'
import { publishWorkOrderRealtimeChange } from '../realtime/realtime-event-service.js'
import { mapWorkOrderAdmin } from './mappers.js'
import {
resolveMaterialResetBlockMessage,
resolveMaterialResetBlockReason,
} from './work-order-material-link-service.js'
/**
* 客服重置补资料状态：把「待分配」工单改回「待完善」，让客户可以凭订单号重新提交。
*
* 只允许未指派、无拼单份额、未发布的工单；原资料保留，客户刷新补资料页后
* 会看到之前填过的内容，可以在此基础上修改。
*/
export async function resetAdminWorkOrderMaterialStatus(
workOrderId: number | string,
actorName = '',
) {
const result = await withTransaction(async (client) => {
const order = await getWorkOrderForUpdateWithClient(client, workOrderId)
if (!order) {
throw createHttpError('接单订单不存在', {
statusCode: 404,
errorCode: 'work_order_not_found',
})
}
const blockReason = resolveMaterialResetBlockReason(order)
if (blockReason) {
throw createHttpError(resolveMaterialResetBlockMessage(blockReason), {
statusCode: 409,
errorCode: 'work_order_material_reset_invalid',
})
}
const now = nowIso()
const updated = await resetWorkOrderMaterialStatusWithClient(client, {
workOrderId: order.id,
fromStatus: WORK_ORDER_STATUS.UNASSIGNED,
toStatus: WORK_ORDER_STATUS.PENDING_MATERIAL,
now,
})
if (!updated) {
throw createHttpError('重置补资料状态失败，订单可能已变化', {
statusCode: 409,
errorCode: 'work_order_material_reset_failed',
})
}
await createWorkOrderEventWithClient(client, {
workOrderId: order.id,
actorType: 'admin',
actorId: String(actorName || '').trim(),
eventType: 'material_reset',
fromStatus: WORK_ORDER_STATUS.UNASSIGNED,
toStatus: WORK_ORDER_STATUS.PENDING_MATERIAL,
payloadJson: JSON.stringify({ source: 'admin_reset' }),
now,
})
return { order: updated }
})
publishWorkOrderRealtimeChange({ workOrderId: Number(result.order.id) })
return { order: mapWorkOrderAdmin(result.order) }
}
apps/backend/src/services/worker-platform/index.ts
+1 -1
View File
@@ -37,6 +37,7 @@ export * from './admin-worker-cancel-service.js'
export * from './admin-work-order-sharing-service.js'
export * from './admin-work-order-realtime-service.js'
export * from './admin-work-order-material-service.js'
export * from './admin-work-order-material-reset-service.js'
export * from './admin-work-order-gift-service.js'
export * from './admin-mock-work-order-service.js'
export * from './admin-mock-custom-shop-service.js'
@@ -64,4 +65,3 @@ export * from './worker-acceptance-config-service.js'
export * from './sync-worker-orders-service.js'
export * from './consignment-contact-service.js'
export * from './work-order-material-link-service.js'
export * from './worker-material-link-config-service.js'
apps/backend/src/services/worker-platform/work-order-display-mappers.ts
+6
View File
@@ -290,6 +290,12 @@ export function mapWorkOrderAdmin(
workOrder.status === WORK_ORDER_STATUS.UNASSIGNED ||
workOrder.status === WORK_ORDER_STATUS.OPEN ||
workOrder.status === WORK_ORDER_STATUS.IN_PROGRESS,
canResetMaterial:
workOrder.status === WORK_ORDER_STATUS.UNASSIGNED &&
!workOrder.assigned_worker_id &&
!hasActiveShares &&
!workOrder.published_at &&
!workOrder.hall_queued_at,
canAccept:
status === WORK_ORDER_STATUS.PENDING_ACCEPTANCE ||
(isFriendGift &&
apps/backend/src/services/worker-platform/work-order-material-link-service.test.ts
+131 -47
View File
@@ -2,67 +2,151 @@ import assert from 'node:assert/strict'
import test from 'node:test'
import {
resolveWorkOrderMaterialLinkUnavailableReason,
formatPublicMaterialStatus,
pickPendingMaterialOrders,
pickSubmittedMaterialFields,
resolveMaterialResetBlockReason,
resolvePublicMaterialOrderState,
} from './work-order-material-link-service.js'
import type { WorkOrderRow } from '../../repositories/worker-platform/types.js'
const NOW = '2026-10-31T12:00:00.000Z'
test('公开补资料：只有待完善且未指派/无份额可提交', () => {
const editable = resolvePublicMaterialOrderState({
status: 'pending_material',
assigned_worker_id: null,
active_share_quantity: 0,
})
assert.equal(editable.canSubmit, true)
assert.equal(editable.blockedReason, '')
assert.equal(editable.statusLabel, '待完善')
test('补资料链接：active 且未过期时可用', () => {
const alreadySubmitted = resolvePublicMaterialOrderState({
status: 'unassigned',
assigned_worker_id: null,
active_share_quantity: 0,
})
assert.equal(alreadySubmitted.canSubmit, false)
assert.equal(alreadySubmitted.blockedReason, 'already_submitted')
assert.equal(alreadySubmitted.statusLabel, '待分配')
assert.match(alreadySubmitted.message, /联系客服/)
const assigned = resolvePublicMaterialOrderState({
status: 'pending_material',
assigned_worker_id: 9,
active_share_quantity: 0,
})
assert.equal(assigned.canSubmit, false)
assert.equal(assigned.blockedReason, 'assigned')
const shares = resolvePublicMaterialOrderState({
status: 'pending_material',
assigned_worker_id: null,
active_share_quantity: 2,
})
assert.equal(shares.canSubmit, false)
assert.equal(shares.blockedReason, 'shares')
const open = resolvePublicMaterialOrderState({
status: 'open',
assigned_worker_id: null,
active_share_quantity: 0,
})
assert.equal(open.canSubmit, false)
assert.equal(open.blockedReason, 'status')
assert.equal(open.statusLabel, '待抢单')
assert.match(open.message, /联系客服/)
})
test('公开补资料：状态文案覆盖待分配与后续流程', () => {
assert.equal(formatPublicMaterialStatus('pending_material'), '待完善')
assert.equal(formatPublicMaterialStatus('unassigned'), '待分配')
assert.equal(formatPublicMaterialStatus('in_progress'), '代练中')
assert.equal(formatPublicMaterialStatus('pending_acceptance'), '待验收')
assert.equal(formatPublicMaterialStatus('accepted'), '已验收')
assert.equal(formatPublicMaterialStatus('cancelled'), '已取消')
assert.equal(formatPublicMaterialStatus('unknown_status'), 'unknown_status')
})
test('客服重置补资料：只允许待分配、未指派、无份额、未发布', () => {
assert.equal(
resolveWorkOrderMaterialLinkUnavailableReason(
{ status: 'active', expires_at: '2026-10-31T13:00:00.000Z' },
NOW,
),
resolveMaterialResetBlockReason({
status: 'unassigned',
assigned_worker_id: null,
active_share_quantity: 0,
published_at: null,
hall_queued_at: null,
}),
'',
)
})
test('补资料链接：active 但已过期按过期处理', () => {
assert.equal(
resolveWorkOrderMaterialLinkUnavailableReason({ status: 'active', expires_at: NOW }, NOW),
'expired',
resolveMaterialResetBlockReason({
status: 'pending_material',
assigned_worker_id: null,
active_share_quantity: 0,
published_at: null,
hall_queued_at: null,
}),
'status',
)
assert.equal(
resolveMaterialResetBlockReason({
status: 'unassigned',
assigned_worker_id: 9,
active_share_quantity: 0,
published_at: null,
hall_queued_at: null,
}),
'assigned',
)
assert.equal(
resolveMaterialResetBlockReason({
status: 'unassigned',
assigned_worker_id: null,
active_share_quantity: 2,
published_at: null,
hall_queued_at: null,
}),
'shares',
)
assert.equal(
resolveMaterialResetBlockReason({
status: 'unassigned',
assigned_worker_id: null,
active_share_quantity: 0,
published_at: '2026-11-01T00:00:00.000Z',
hall_queued_at: null,
}),
'published',
)
assert.equal(
resolveMaterialResetBlockReason({
status: 'unassigned',
assigned_worker_id: null,
active_share_quantity: 0,
published_at: null,
hall_queued_at: '2026-11-01T00:00:00.000Z',
}),
'published',
)
})
test('补资料链接：used / expired / revoked 分别返回对应原因', () => {
assert.equal(
resolveWorkOrderMaterialLinkUnavailableReason(
{ status: 'used', expires_at: '2026-10-31T13:00:00.000Z' },
NOW,
),
'used',
)
assert.equal(
resolveWorkOrderMaterialLinkUnavailableReason(
{ status: 'expired', expires_at: '2026-10-31T13:00:00.000Z' },
NOW,
),
'expired',
)
assert.equal(
resolveWorkOrderMaterialLinkUnavailableReason(
{ status: 'revoked', expires_at: '2026-10-31T13:00:00.000Z' },
NOW,
),
'revoked',
test('公开补资料：只查询待完善工单，其他状态一律不返回', () => {
const orders = [
{ status: 'pending_material' },
{ status: 'unassigned' },
{ status: 'open' },
{ status: 'accepted' },
{ status: 'cancelled' },
] as WorkOrderRow[]
assert.deepEqual(
pickPendingMaterialOrders(orders).map((order) => order.status),
['pending_material'],
)
assert.deepEqual(pickPendingMaterialOrders([]), [])
})
test('补资料链接：未知状态一律视为失效，避免误放行', () => {
assert.equal(
resolveWorkOrderMaterialLinkUnavailableReason(
{
status: 'unknown' as never,
expires_at: '2026-10-31T13:00:00.000Z',
},
NOW,
),
'revoked',
)
})
test('补资料链接：提交字段只保留 requirements 白名单，额外字段被丢弃', () => {
test('公开补资料：提交字段只保留 requirements 白名单，额外字段被丢弃', () => {
const result = pickSubmittedMaterialFields([{ key: 'gameId' }, { key: 'gameNickname' }], {
gameId: '123',
gameNickname: '张三',
apps/backend/src/services/worker-platform/work-order-material-link-service.ts
+239 -203
View File
@@ -1,19 +1,10 @@
import { randomBytes } from 'node:crypto'
import { withTransaction } from '../../db/client.js'
import { WORK_ORDER_STATUS } from '../../domain/work-order-status.js'
import {
createWorkOrderEventWithClient,
createWorkOrderMaterialLinkWithClient,
findWorkOrderMaterialLinkByToken,
findActiveWorkOrderMaterialLinkWithClient,
getWorkOrderForUpdateWithClient,
getWorkOrderMaterialLinkForUpdateWithClient,
markWorkOrderMaterialLinkExpired,
markWorkOrderMaterialLinkUsedWithClient,
revokeActiveWorkOrderMaterialLinksWithClient,
listWorkOrdersByPlatformOrderId,
updateWorkOrderMaterialWithClient,
type WorkOrderMaterialLinkRow,
} from '../../repositories/worker-platform/index.js'
import type { WorkOrderRow } from '../../repositories/worker-platform/types.js'
import type { JsonObject } from '../../types/json.js'
@@ -25,44 +16,134 @@ import { resolveAdminNotificationEntity } from '../admin/admin-notification-serv
import { publishWorkOrderRealtimeChange } from '../realtime/realtime-event-service.js'
import {
mapCollectLookupOrder,
mapWorkOrderAdmin,
normalizeOptionalId,
normalizeSubmittedFields,
normalizeUploadedFiles,
resolveRequirementFields,
} from './mappers.js'
import { getWorkerMaterialLinkConfig } from './worker-material-link-config-service.js'
import { getRequiredWorkOrder } from './worker-session-context-service.js'
const ALLOWED_MATERIAL_LINK_ORDER_STATUSES = new Set<string>([
WORK_ORDER_STATUS.PENDING_MATERIAL,
WORK_ORDER_STATUS.UNASSIGNED,
])
const MAX_MATERIAL_SCREENSHOTS = 5
export type WorkOrderMaterialLinkUnavailableReason = 'used' | 'expired' | 'revoked' | ''
const PUBLIC_MATERIAL_STATUS_LABELS: Record<string, string> = {
[WORK_ORDER_STATUS.PENDING_MATERIAL]: '待完善',
[WORK_ORDER_STATUS.UNASSIGNED]: '待分配',
[WORK_ORDER_STATUS.OPEN]: '待抢单',
[WORK_ORDER_STATUS.IN_PROGRESS]: '代练中',
[WORK_ORDER_STATUS.PENDING_ACCEPTANCE]: '待验收',
[WORK_ORDER_STATUS.PROBLEM]: '问题单',
[WORK_ORDER_STATUS.ACCEPTED]: '已验收',
[WORK_ORDER_STATUS.CANCELLED]: '已取消',
vip_evidence_pending: '待补图',
}
export type PublicMaterialOrderBlockReason =
| 'already_submitted'
| 'status'
| 'assigned'
| 'shares'
| ''
export type PublicMaterialOrderState = {
canSubmit: boolean
blockedReason: PublicMaterialOrderBlockReason
statusLabel: string
message: string
}
export type MaterialResetBlockReason = 'status' | 'assigned' | 'shares' | 'published' | ''
/** 公开页状态文案；后台状态列/时间线也统一用「待分配」。 */
export function formatPublicMaterialStatus(status: string): string {
const normalized = String(status || '').trim()
return PUBLIC_MATERIAL_STATUS_LABELS[normalized] || normalized || '未知状态'
}
/**
* 判断链接是否还能用。
* 公开补资料页的准入判断。
*
* 只做纯函数判断，方便单测覆盖；数据库状态与过期时间都由调用方传入。
* 只有「待完善 + 未指派 + 无拼单份额」可以提交；待分配视为已提交，
* 其他状态只展示状态与客服提示，不再展示表单。
*/
export function resolveWorkOrderMaterialLinkUnavailableReason(
link: Pick<WorkOrderMaterialLinkRow, 'status' | 'expires_at'>,
now: string,
): WorkOrderMaterialLinkUnavailableReason {
if (link.status === 'used') return 'used'
if (link.status === 'revoked') return 'revoked'
if (link.status === 'expired') return 'expired'
if (link.status !== 'active') return 'revoked'
if (new Date(link.expires_at).getTime() <= new Date(now).getTime()) return 'expired'
export function resolvePublicMaterialOrderState(
order: Pick<WorkOrderRow, 'status' | 'assigned_worker_id' | 'active_share_quantity'>,
): PublicMaterialOrderState {
const statusLabel = formatPublicMaterialStatus(order.status)
if (order.status === WORK_ORDER_STATUS.UNASSIGNED) {
return {
canSubmit: false,
blockedReason: 'already_submitted',
statusLabel,
message: '资料已提交，订单已进入待分配；如需修改请联系客服。',
}
}
if (order.status !== WORK_ORDER_STATUS.PENDING_MATERIAL) {
return {
canSubmit: false,
blockedReason: 'status',
statusLabel,
message: `当前状态为「${statusLabel}」，不能修改资料；如需修改请联系客服。`,
}
}
if (order.assigned_worker_id) {
return {
canSubmit: false,
blockedReason: 'assigned',
statusLabel,
message: '订单已指派打手，不能修改资料；如需修改请联系客服。',
}
}
if (Number(order.active_share_quantity || 0) > 0) {
return {
canSubmit: false,
blockedReason: 'shares',
statusLabel,
message: '订单已有拼单份额，不能修改资料；如需修改请联系客服。',
}
}
return {
canSubmit: true,
blockedReason: '',
statusLabel,
message: '',
}
}
/**
* 客服重置补资料状态的前置条件。
*
* 只允许「待分配 + 未指派 + 无份额 + 未发布」的工单回到待完善；
* 其他状态一律拒绝，避免把已进入接单流程的工单改回可编辑。
*/
export function resolveMaterialResetBlockReason(
order: Pick<
WorkOrderRow,
'status' | 'assigned_worker_id' | 'active_share_quantity' | 'published_at' | 'hall_queued_at'
>,
): MaterialResetBlockReason {
if (order.status !== WORK_ORDER_STATUS.UNASSIGNED) return 'status'
if (order.assigned_worker_id) return 'assigned'
if (Number(order.active_share_quantity || 0) > 0) return 'shares'
if (order.published_at || order.hall_queued_at) return 'published'
return ''
}
export function resolveMaterialResetBlockMessage(reason: MaterialResetBlockReason): string {
if (reason === 'assigned') return '订单已指派打手，不能重置补资料状态'
if (reason === 'shares') return '订单已有拼单份额，不能重置补资料状态'
if (reason === 'published') return '订单已发布到接单大厅，不能重置补资料状态'
return '只有待分配（未指派、无份额、未发布）的工单可以重置补资料状态'
}
/**
* 只保留工单 requirement 里定义过的字段。
*
* 公开链接的提交体是客户可构造的，不能让 `rewardAmount`、`status` 之类的
* 公开提交体是客户可构造的，不能让 `rewardAmount`、`status` 之类的
* 额外 key 混进 material.collect.fields；这里按白名单裁剪一次。
*/
export function pickSubmittedMaterialFields(
@@ -73,57 +154,19 @@ export function pickSubmittedMaterialFields(
return Object.fromEntries(Object.entries(submitted).filter(([key]) => allowedKeys.has(key)))
}
function throwMaterialLinkUnavailable(
reason: Exclude<WorkOrderMaterialLinkUnavailableReason, ''>,
): never {
if (reason === 'used') {
throw createHttpError('链接已使用，如需修改资料请联系客服重新获取', {
statusCode: 410,
errorCode: 'material_link_used',
function throwPublicMaterialBlocked(state: PublicMaterialOrderState): never {
if (state.blockedReason === 'already_submitted') {
throw createHttpError(state.message, {
statusCode: 409,
errorCode: 'material_link_already_submitted',
})
}
if (reason === 'expired') {
throw createHttpError('链接已过期，请联系客服重新获取', {
statusCode: 410,
errorCode: 'material_link_expired',
})
}
throw createHttpError('链接已失效，请联系客服重新获取', {
statusCode: 410,
errorCode: 'material_link_revoked',
throw createHttpError(state.message, {
statusCode: 409,
errorCode: 'material_link_order_status_invalid',
})
}
/**
* 公开链接只对「待完善 / 未分配」开放，且不能已经指派打手或有进行中的拼单份额。
* 这三个条件同时满足，提交后才可以安全地把状态改成「未分配」。
*/
function assertWorkOrderAllowedForMaterialLink(order: WorkOrderRow): void {
if (!ALLOWED_MATERIAL_LINK_ORDER_STATUSES.has(order.status)) {
throw createHttpError('订单当前状态不允许补资料，请联系客服重新获取链接', {
statusCode: 409,
errorCode: 'material_link_order_status_invalid',
})
}
if (order.assigned_worker_id) {
throw createHttpError('订单已指派打手，不能通过公开链接修改资料', {
statusCode: 409,
errorCode: 'material_link_order_status_invalid',
})
}
if (Number(order.active_share_quantity || 0) > 0) {
throw createHttpError('订单已有拼单份额，不能通过公开链接修改资料', {
statusCode: 409,
errorCode: 'material_link_order_status_invalid',
})
}
}
function assertMaterialLinkRecordUsable(link: WorkOrderMaterialLinkRow, now: string): void {
const reason = resolveWorkOrderMaterialLinkUnavailableReason(link, now)
if (reason) throwMaterialLinkUnavailable(reason)
}
function mapPublicOrder(order: WorkOrderRow) {
return {
workOrderNo: order.work_order_no,
@@ -133,149 +176,150 @@ function mapPublicOrder(order: WorkOrderRow) {
}
}
/** PostgreSQL 返回的 timestamptz 可能是 "YYYY-MM-DD HH:mm:ss" 字符串，统一转 ISO。 */
function toIsoTimestamp(value: string): string {
const date = new Date(value)
return Number.isNaN(date.getTime()) ? String(value || '') : date.toISOString()
function mapPublicMaterialOrder(order: WorkOrderRow) {
const state = resolvePublicMaterialOrderState(order)
const base = {
workOrderId: Number(order.id),
workOrderNo: order.work_order_no,
platformOrderId: order.platform_order_id,
productName: order.product_name,
status: order.status,
statusLabel: state.statusLabel,
canSubmit: state.canSubmit,
blockedReason: state.blockedReason,
message: state.message,
}
if (!state.canSubmit) return base
const mapped = mapCollectLookupOrder(order)
return {
...base,
fields: mapped.fields,
values: mapped.values,
screenshots: mapped.screenshots,
}
}
/**
* 管理端生成/复用一次性链接。
*
* 幂等策略：同一工单已有未过期 active 链接时直接返回，避免客服连续点两次
* 把刚发出去的链接顶掉；只有已使用/已过期/已撤销时才生成新 token。
*/
export async function createAdminWorkOrderMaterialLink(
workOrderId: number | string,
actorName = '',
) {
const { ttlMinutes } = getWorkerMaterialLinkConfig()
return withTransaction(async (client) => {
const order = await getWorkOrderForUpdateWithClient(client, workOrderId)
if (!order) {
throw createHttpError('接单订单不存在', {
async function resolvePublicMaterialTarget(
platformOrderId: string,
workOrderIdInput: unknown,
): Promise<WorkOrderRow> {
const workOrderId = normalizeOptionalId(workOrderIdInput)
if (workOrderId) {
const order = await getRequiredWorkOrder(workOrderId)
if (String(order.platform_order_id || '').trim() !== platformOrderId) {
throw createHttpError('订单号无效，请确认订单号是否正确', {
statusCode: 404,
errorCode: 'work_order_not_found',
errorCode: 'material_link_work_order_invalid',
})
}
return order
}
if (!mapWorkOrderAdmin(order).capabilities.canUpdateMaterial) {
throw createHttpError('当前状态不能生成补资料链接', {
statusCode: 409,
errorCode: 'material_link_status_invalid',
})
}
assertWorkOrderAllowedForMaterialLink(order)
// 锁到手后再取时间，避免等锁期间旧链接过期却仍按旧时间复用。
const now = nowIso()
const existing = await findActiveWorkOrderMaterialLinkWithClient(client, order.id, now)
if (existing) {
return {
token: existing.token,
expiresAt: toIsoTimestamp(existing.expires_at),
reused: true,
}
}
await revokeActiveWorkOrderMaterialLinksWithClient(client, order.id, now)
const token = randomBytes(24).toString('base64url')
const expiresAt = new Date(Date.now() + ttlMinutes * 60 * 1000).toISOString()
const link = await createWorkOrderMaterialLinkWithClient(client, {
workOrderId: order.id,
token,
expiresAt,
createdBy: String(actorName || '').trim(),
now,
const orders = await listWorkOrdersByPlatformOrderId(platformOrderId)
if (orders.length === 0) {
throw createHttpError('订单号无效，请确认订单号是否正确', {
statusCode: 404,
errorCode: 'material_link_not_found',
})
return {
token: link.token,
expiresAt: toIsoTimestamp(link.expires_at),
reused: false,
}
})
}
if (orders.length > 1) {
throw createHttpError('该订单号下有多个商品，请先选择商品', {
statusCode: 409,
errorCode: 'material_link_work_order_required',
})
}
return orders[0]!
}
/**
* 公开页读取链接内容。
* 公开页只允许查询待完善工单。
*
* 只返回客户补资料需要的最少信息：商品/单号、动态字段、已填值、截图、过期时间。
* 不返回发单价格、押金、成本、打手、后台备注等任何后台字段。
* 待分配、待抢单、代练中、已验收、已取消等状态一律不返回，
* 避免客户用订单号看到已完成订单的商品与状态。
*/
export async function getPublicWorkOrderMaterialLink(token: string) {
const link = await findWorkOrderMaterialLinkByToken(token)
if (!link) {
throw createHttpError('链接无效，请确认链接是否完整', {
export function pickPendingMaterialOrders(orders: WorkOrderRow[]): WorkOrderRow[] {
return orders.filter((order) => order.status === WORK_ORDER_STATUS.PENDING_MATERIAL)
}
/**
* 公开页按平台订单号读取补资料内容。
*
* 不再要求客服先生成链接；订单号存在且仍有待完善工单时才返回内容。
* 只返回待完善工单；已提交（待分配）及其他状态统一提示无需补充资料。
*/
export async function getPublicWorkOrderMaterialLink(platformOrderId: string) {
const code = String(platformOrderId || '').trim()
if (!code) {
throw createHttpError('订单号无效，请确认订单号是否正确', {
statusCode: 404,
errorCode: 'material_link_not_found',
})
}
const now = nowIso()
const reason = resolveWorkOrderMaterialLinkUnavailableReason(link, now)
if (reason) {
if (reason === 'expired') {
await markWorkOrderMaterialLinkExpired(link.id, now)
}
throwMaterialLinkUnavailable(reason)
const orders = await listWorkOrdersByPlatformOrderId(code)
if (orders.length === 0) {
throw createHttpError('订单号无效，请确认订单号是否正确', {
statusCode: 404,
errorCode: 'material_link_not_found',
})
}
const order = await getRequiredWorkOrder(link.work_order_id)
assertWorkOrderAllowedForMaterialLink(order)
const pendingOrders = pickPendingMaterialOrders(orders)
if (pendingOrders.length === 0) {
throw createHttpError('该订单当前无需补充资料', {
statusCode: 404,
errorCode: 'material_link_not_pending',
})
}
const mapped = mapCollectLookupOrder(order)
const publicOrders = pendingOrders.map(mapPublicMaterialOrder)
return {
order: {
workOrderNo: mapped.workOrderNo,
platformOrderId: mapped.platformOrderId,
productName: mapped.productName,
status: mapped.status,
},
fields: mapped.fields,
values: mapped.values,
screenshots: mapped.screenshots,
expiresAt: toIsoTimestamp(link.expires_at),
platformOrderId: code,
orders: publicOrders,
pendingCount: publicOrders.filter((order) => order.canSubmit).length,
}
}
/**
* 公开页提交资料。
*
* 一次性语义：只有「完整提交」成功时才把 token 标为 used；
* 少填必填项、订单状态变化、网络失败等都会在事务里回滚，链接继续可用。
* 一次性语义完全由工单状态保证：只有 `pending_material` 能成功提交，
* 提交后改成 `unassigned`；并发的第二个提交会锁到 `unassigned` 并返回 409。
*/
export async function submitPublicWorkOrderMaterialLink(token: string, payload: JsonObject = {}) {
const preliminary = await findWorkOrderMaterialLinkByToken(token)
if (!preliminary) {
throw createHttpError('链接无效，请确认链接是否完整', {
export async function submitPublicWorkOrderMaterialLink(
platformOrderId: string,
payload: JsonObject = {},
) {
const code = String(platformOrderId || '').trim()
if (!code) {
throw createHttpError('订单号无效，请确认订单号是否正确', {
statusCode: 404,
errorCode: 'material_link_not_found',
})
}
const target = await resolvePublicMaterialTarget(code, payload.workOrderId)
const targetState = resolvePublicMaterialOrderState(target)
if (!targetState.canSubmit) throwPublicMaterialBlocked(targetState)
const result = await withTransaction(async (client) => {
// 先锁工单再锁链接，和后台生成链接保持同样的加锁顺序，避免死锁。
const order = await getWorkOrderForUpdateWithClient(client, preliminary.work_order_id)
// 锁工单：并发提交/客服重置都串行化，状态是唯一的一次性凭据。
const order = await getWorkOrderForUpdateWithClient(client, target.id)
if (!order) {
throw createHttpError('接单订单不存在', {
statusCode: 404,
errorCode: 'work_order_not_found',
})
}
const link = await getWorkOrderMaterialLinkForUpdateWithClient(client, preliminary.id)
if (!link) {
throw createHttpError('链接无效，请确认链接是否完整', {
if (String(order.platform_order_id || '').trim() !== code) {
throw createHttpError('订单号无效，请确认订单号是否正确', {
statusCode: 404,
errorCode: 'material_link_not_found',
errorCode: 'material_link_work_order_invalid',
})
}
// 锁到手后再取时间：等锁期间链接可能已经过期，不能沿用进入事务前的时间。
const now = nowIso()
assertMaterialLinkRecordUsable(link, now)
assertWorkOrderAllowedForMaterialLink(order)
const orderState = resolvePublicMaterialOrderState(order)
if (!orderState.canSubmit) throwPublicMaterialBlocked(orderState)
const fields = resolveRequirementFields(order)
const submittedFields = pickSubmittedMaterialFields(
@@ -304,6 +348,7 @@ export async function submitPublicWorkOrderMaterialLink(token: string, payload:
})
}
const now = nowIso()
const material = {
...safeParseJson(order.material_json),
collect: {
@@ -311,7 +356,7 @@ export async function submitPublicWorkOrderMaterialLink(token: string, payload:
screenshots,
submittedAt: now,
complete: true,
source: 'customer_link',
source: 'customer_order_no',
},
}
@@ -328,33 +373,22 @@ export async function submitPublicWorkOrderMaterialLink(token: string, payload:
})
}
const used = await markWorkOrderMaterialLinkUsedWithClient(client, link.id, now)
if (!used) {
// 并发提交，或刚好在写入瞬间过期：按当前状态给出准确原因，事务整体回滚。
const latest = await getWorkOrderMaterialLinkForUpdateWithClient(client, link.id)
if (latest) {
const reason = resolveWorkOrderMaterialLinkUnavailableReason(latest, now)
if (reason) throwMaterialLinkUnavailable(reason)
}
throwMaterialLinkUnavailable('used')
}
await createWorkOrderEventWithClient(client, {
workOrderId: order.id,
actorType: 'collect',
actorId: '客户补资料链接',
actorId: '客户按订单号补资料',
eventType: 'material_completed',
fromStatus: order.status,
toStatus: WORK_ORDER_STATUS.UNASSIGNED,
payloadJson: JSON.stringify({
fields: submittedFields,
complete: true,
source: 'customer_link',
source: 'customer_order_no',
}),
now,
})
return { order: updated, link: used }
return { order: updated }
})
// 事务已提交，后续通知/实时广播失败不能让客户误以为提交失败。
@@ -374,28 +408,30 @@ export async function submitPublicWorkOrderMaterialLink(token: string, payload:
return {
complete: true,
workOrderId: Number(result.order.id),
order: mapPublicOrder(result.order),
}
}
/**
* 上传前校验 token 与工单状态；返回工单 id 供文件归属使用。
* 注意：这里不消耗 token，只有最终提交才消耗。
* 上传前校验平台订单号 / workOrderId 与工单状态；返回工单供文件归属使用。
* 注意：这里不消耗提交机会，只有最终提交才把状态改成待分配。
*/
export async function getPublicWorkOrderMaterialLinkUploadContext(token: string) {
const link = await findWorkOrderMaterialLinkByToken(token)
if (!link) {
throw createHttpError('链接无效，请确认链接是否完整', {
export async function getPublicWorkOrderMaterialLinkUploadContext(
platformOrderId: string,
workOrderId?: unknown,
) {
const code = String(platformOrderId || '').trim()
if (!code) {
throw createHttpError('订单号无效，请确认订单号是否正确', {
statusCode: 404,
errorCode: 'material_link_not_found',
})
}
const now = nowIso()
assertMaterialLinkRecordUsable(link, now)
const order = await resolvePublicMaterialTarget(code, workOrderId)
const orderState = resolvePublicMaterialOrderState(order)
if (!orderState.canSubmit) throwPublicMaterialBlocked(orderState)
const order = await getRequiredWorkOrder(link.work_order_id)
assertWorkOrderAllowedForMaterialLink(order)
return { link, order, now }
return { order, now: nowIso() }
}
apps/backend/src/services/worker-platform/worker-material-link-config-service.test.ts
-41
View File
@@ -1,41 +0,0 @@
import assert from 'node:assert/strict'
import test from 'node:test'
import {
createDefaultWorkerMaterialLinkConfig,
normalizeWorkerMaterialLinkConfig,
WORK_ORDER_MATERIAL_LINK_DEFAULT_TTL_MINUTES,
WORK_ORDER_MATERIAL_LINK_MAX_TTL_MINUTES,
WORK_ORDER_MATERIAL_LINK_MIN_TTL_MINUTES,
} from './worker-material-link-config-service.js'
test('补资料链接配置：默认 30 分钟', () => {
assert.deepEqual(createDefaultWorkerMaterialLinkConfig(), {
ttlMinutes: WORK_ORDER_MATERIAL_LINK_DEFAULT_TTL_MINUTES,
})
assert.equal(WORK_ORDER_MATERIAL_LINK_DEFAULT_TTL_MINUTES, 30)
assert.deepEqual(normalizeWorkerMaterialLinkConfig(undefined), { ttlMinutes: 30 })
})
test('补资料链接配置：接受 ttlMinutes / ttl_minutes / 数字字符串', () => {
assert.deepEqual(normalizeWorkerMaterialLinkConfig({ ttlMinutes: 45 }), { ttlMinutes: 45 })
assert.deepEqual(normalizeWorkerMaterialLinkConfig({ ttl_minutes: '10' }), { ttlMinutes: 10 })
assert.deepEqual(normalizeWorkerMaterialLinkConfig({ ttlMinutes: 90.4 }), { ttlMinutes: 90 })
})
test('补资料链接配置：越界值收敛到 1 - 10080 分钟', () => {
assert.deepEqual(normalizeWorkerMaterialLinkConfig({ ttlMinutes: 0 }), {
ttlMinutes: WORK_ORDER_MATERIAL_LINK_MIN_TTL_MINUTES,
})
assert.deepEqual(normalizeWorkerMaterialLinkConfig({ ttlMinutes: -5 }), { ttlMinutes: 1 })
assert.deepEqual(normalizeWorkerMaterialLinkConfig({ ttlMinutes: 999999 }), {
ttlMinutes: WORK_ORDER_MATERIAL_LINK_MAX_TTL_MINUTES,
})
assert.equal(WORK_ORDER_MATERIAL_LINK_MAX_TTL_MINUTES, 10080)
})
test('补资料链接配置：非法输入回退默认值，不会写入 NaN', () => {
assert.deepEqual(normalizeWorkerMaterialLinkConfig({ ttlMinutes: 'abc' }), { ttlMinutes: 30 })
assert.deepEqual(normalizeWorkerMaterialLinkConfig({ ttlMinutes: null }), { ttlMinutes: 30 })
assert.deepEqual(normalizeWorkerMaterialLinkConfig('not-an-object'), { ttlMinutes: 30 })
})
apps/backend/src/services/worker-platform/worker-material-link-config-service.ts
-62
View File
@@ -1,62 +0,0 @@
import { APP_CONFIG_KEYS } from '../../config/app-config-keys.js'
import type { JsonObject } from '../../types/json.js'
import { readAppConfigEntry, saveAppConfigEntry } from '../config/app-config-store.js'
/** 补资料链接默认有效期（分钟）：30 分钟。 */
export const WORK_ORDER_MATERIAL_LINK_DEFAULT_TTL_MINUTES = 30
/** 允许配置的最短有效期（分钟）。 */
export const WORK_ORDER_MATERIAL_LINK_MIN_TTL_MINUTES = 1
/** 允许配置的最长有效期（分钟）：7 天。 */
export const WORK_ORDER_MATERIAL_LINK_MAX_TTL_MINUTES = 7 * 24 * 60
export type WorkerMaterialLinkConfig = {
/** 新生成的补资料链接有效期，单位分钟。 */
ttlMinutes: number
}
/** 读取配置（内存缓存），未配置时返回默认 30 分钟。 */
export function getWorkerMaterialLinkConfig(): WorkerMaterialLinkConfig {
return readAppConfigEntry({
configKey: APP_CONFIG_KEYS.workOrderMaterialLink,
fallback: createDefaultWorkerMaterialLinkConfig,
normalize: normalizeWorkerMaterialLinkConfig,
})
}
export async function saveWorkerMaterialLinkConfig(
rawValue: unknown,
): Promise<WorkerMaterialLinkConfig> {
return saveAppConfigEntry({
configKey: APP_CONFIG_KEYS.workOrderMaterialLink,
value: rawValue,
normalize: normalizeWorkerMaterialLinkConfig,
})
}
export function createDefaultWorkerMaterialLinkConfig(): WorkerMaterialLinkConfig {
return { ttlMinutes: WORK_ORDER_MATERIAL_LINK_DEFAULT_TTL_MINUTES }
}
export function normalizeWorkerMaterialLinkConfig(rawValue: unknown): WorkerMaterialLinkConfig {
const source = isPlainObject(rawValue) ? rawValue : {}
const raw = source.ttlMinutes ?? source.ttl_minutes
if (raw === undefined || raw === null || raw === '') {
return createDefaultWorkerMaterialLinkConfig()
}
const value = Number(raw)
if (!Number.isFinite(value)) {
return createDefaultWorkerMaterialLinkConfig()
}
return {
ttlMinutes: Math.min(
WORK_ORDER_MATERIAL_LINK_MAX_TTL_MINUTES,
Math.max(WORK_ORDER_MATERIAL_LINK_MIN_TTL_MINUTES, Math.round(value)),
),
}
}
function isPlainObject(value: unknown): value is JsonObject {
return Object.prototype.toString.call(value) === '[object Object]'
}