feat(collect): 补资料改为订单号直连并按状态一次性提交

- 公开补资料页 /supplement/:订单号 直接按平台订单号查询,不再依赖链接记录;旧 token 链接一律 404
- 仅「待完善 + 未指派 + 无拼单份额」可提交,提交后状态变为待分配,重复提交返回 409
- 非可编辑工单只返回商品、工单号、状态与客服提示,不返回已填资料和截图
- 管理端新增「重置补资料」:待分配且未指派、无份额、未发布时一键重置回待完善
- 新增 canResetMaterial 能力与 material_reset 流转事件,工单状态文案统一为「待分配」
This commit is contained in:
2026-11-01 18:12:44 +08:00
parent aed76e047e
commit a2cf48f5fc
24 changed files with 1223 additions and 494 deletions
@@ -537,6 +537,8 @@ export type WorkOrderCapabilities = {
canPin: boolean canPin: boolean
canUnpublish: boolean canUnpublish: boolean
canUpdateMaterial: boolean canUpdateMaterial: boolean
/** 待分配且未指派、无份额、未发布时,客服可以把补资料状态重置回待完善。 */
canResetMaterial: boolean
canAccept: boolean canAccept: boolean
canMarkProblem: boolean canMarkProblem: boolean
canDelete: boolean canDelete: boolean
@@ -1,6 +1,5 @@
import type { PoolClient } from 'pg' import type { PoolClient } from 'pg'
import { query } from '../../db/client.js'
import type { WorkOrderRow } from './types.js' import type { WorkOrderRow } from './types.js'
export type WorkOrderMaterialLinkStatus = 'active' | 'used' | 'expired' | 'revoked' export type WorkOrderMaterialLinkStatus = 'active' | 'used' | 'expired' | 'revoked'
@@ -17,52 +16,31 @@ export type WorkOrderMaterialLinkRow = {
updated_at: string updated_at: string
} }
export async function findWorkOrderMaterialLinkByToken( /**
token: string, * 锁工单并回读「有效拼单份额」。
): Promise<WorkOrderMaterialLinkRow | null> { *
const result = await query<WorkOrderMaterialLinkRow>( * `SELECT * FROM work_orders` 本身没有聚合字段,直接看 `active_share_quantity`
'SELECT * FROM work_order_material_links WHERE token = $1 LIMIT 1', * 会永远是 0,导致补资料绕过「已有拼单份额不允许改资料」的守卫。
[String(token || '').trim()], */
)
return result.rows[0] || null
}
export async function findActiveWorkOrderMaterialLink(
workOrderId: number | string,
now: string,
): Promise<WorkOrderMaterialLinkRow | null> {
const result = await query<WorkOrderMaterialLinkRow>(
`SELECT * FROM work_order_material_links
WHERE work_order_id = $1 AND status = 'active' AND expires_at > $2
ORDER BY id DESC
LIMIT 1`,
[Number(workOrderId), now],
)
return result.rows[0] || null
}
export async function getWorkOrderForUpdateWithClient( export async function getWorkOrderForUpdateWithClient(
client: PoolClient, client: PoolClient,
workOrderId: number | string, workOrderId: number | string,
): Promise<WorkOrderRow | null> { ): Promise<WorkOrderRow | null> {
const result = await client.query<WorkOrderRow>( const result = await client.query<WorkOrderRow>(
'SELECT * FROM work_orders WHERE id = $1 FOR UPDATE', `SELECT wo.*,
COALESCE((
SELECT SUM(wos.quantity)
FROM work_order_shares wos
WHERE wos.work_order_id = wo.id AND wos.status != 'cancelled'
), 0)::int AS active_share_quantity
FROM work_orders wo
WHERE wo.id = $1
FOR UPDATE`,
[Number(workOrderId)], [Number(workOrderId)],
) )
return result.rows[0] || null return result.rows[0] || null
} }
export async function getWorkOrderMaterialLinkForUpdateWithClient(
client: PoolClient,
linkId: number | string,
): Promise<WorkOrderMaterialLinkRow | null> {
const result = await client.query<WorkOrderMaterialLinkRow>(
'SELECT * FROM work_order_material_links WHERE id = $1 FOR UPDATE',
[Number(linkId)],
)
return result.rows[0] || null
}
export async function findActiveWorkOrderMaterialLinkWithClient( export async function findActiveWorkOrderMaterialLinkWithClient(
client: PoolClient, client: PoolClient,
workOrderId: number | string, workOrderId: number | string,
@@ -120,33 +98,6 @@ export async function createWorkOrderMaterialLinkWithClient(
return result.rows[0]! return result.rows[0]!
} }
export async function markWorkOrderMaterialLinkUsedWithClient(
client: PoolClient,
linkId: number | string,
now: string,
): Promise<WorkOrderMaterialLinkRow | null> {
const result = await client.query<WorkOrderMaterialLinkRow>(
`UPDATE work_order_material_links
SET status = 'used', used_at = $2, updated_at = $2
WHERE id = $1 AND status = 'active' AND expires_at > $2
RETURNING *`,
[Number(linkId), now],
)
return result.rows[0] || null
}
export async function markWorkOrderMaterialLinkExpired(
linkId: number | string,
now: string,
): Promise<void> {
await query(
`UPDATE work_order_material_links
SET status = 'expired', updated_at = $2
WHERE id = $1 AND status = 'active'`,
[Number(linkId), now],
)
}
export async function updateWorkOrderMaterialWithClient( export async function updateWorkOrderMaterialWithClient(
client: PoolClient, client: PoolClient,
input: { input: {
@@ -165,3 +116,32 @@ export async function updateWorkOrderMaterialWithClient(
) )
return result.rows[0] || null return result.rows[0] || null
} }
/**
* 客服重置补资料状态:只允许「待分配、未指派、未发布」的工单回到待完善。
*
* 服务层已经在事务里锁工单并校验过拼单份额;这里的 WHERE 条件再兜一层,
* 防止并发或调用方漏校验。
*/
export async function resetWorkOrderMaterialStatusWithClient(
client: PoolClient,
input: {
workOrderId: number | string
fromStatus: string
toStatus: string
now: string
},
): Promise<WorkOrderRow | null> {
const result = await client.query<WorkOrderRow>(
`UPDATE work_orders
SET status = $2, updated_at = $3
WHERE id = $1
AND status = $4
AND assigned_worker_id IS NULL
AND published_at IS NULL
AND hall_queued_at IS NULL
RETURNING *`,
[Number(input.workOrderId), input.toStatus, input.now, input.fromStatus],
)
return result.rows[0] || null
}
@@ -23,6 +23,7 @@ import {
reopenAdminCancelledWorkOrder, reopenAdminCancelledWorkOrder,
reprocessAdminKuaishouSendCodeWorkOrders, reprocessAdminKuaishouSendCodeWorkOrders,
resetAdminWorkOrderGiftMaterial, resetAdminWorkOrderGiftMaterial,
resetAdminWorkOrderMaterialStatus,
submitAdminWorkOrderMaterial, submitAdminWorkOrderMaterial,
unassignAdminWorkOrder, unassignAdminWorkOrder,
unpublishAdminWorkOrder, unpublishAdminWorkOrder,
@@ -216,6 +217,29 @@ router.post(
), ),
) )
router.post(
'/worker-platform/orders/:workOrderId/reset-material',
requireAdminPermission('worker_order.update_material'),
createJsonHandler(
(req) =>
resetAdminWorkOrderMaterialStatus(
String(req.params.workOrderId || ''),
req.adminSession?.displayName || req.adminSession?.username || '',
),
{
successMessage: '补资料状态已重置为待完善',
errorMessage: '重置补资料状态失败',
scope: '[admin/worker-platform/orders/:workOrderId/reset-material]',
audit: (req) => ({
action: 'work_order_material_reset',
targetType: 'work_order',
targetId: String(req.params.workOrderId || ''),
data: {},
}),
},
),
)
router.put( router.put(
'/worker-platform/orders/:workOrderId', '/worker-platform/orders/:workOrderId',
requireAdminPermission('worker_order.edit'), requireAdminPermission('worker_order.edit'),
+35 -12
View File
@@ -29,21 +29,40 @@ const materialLinkReadRateLimit = createRateLimitMiddleware({
scope: 'collect:link:read', scope: 'collect:link:read',
windowMs: 60_000, windowMs: 60_000,
max: 120, max: 120,
key: getParamRateLimitKey('token'), key: getParamRateLimitKey('code'),
})
/** 平台订单号可被枚举,额外加一层只按 IP 的总限流,避免换 code 绕过单链接限流。 */
const materialLinkReadIpRateLimit = createRateLimitMiddleware({
scope: 'collect:link:read:ip',
windowMs: 60_000,
max: 300,
}) })
const materialLinkWriteRateLimit = createRateLimitMiddleware({ const materialLinkWriteRateLimit = createRateLimitMiddleware({
scope: 'collect:link:write', scope: 'collect:link:write',
windowMs: 60_000, windowMs: 60_000,
max: 20, max: 20,
key: getParamRateLimitKey('token'), key: getParamRateLimitKey('code'),
})
const materialLinkWriteIpRateLimit = createRateLimitMiddleware({
scope: 'collect:link:write:ip',
windowMs: 60_000,
max: 40,
}) })
const materialLinkUploadRateLimit = createRateLimitMiddleware({ const materialLinkUploadRateLimit = createRateLimitMiddleware({
scope: 'collect:link:upload', scope: 'collect:link:upload',
windowMs: 60_000, windowMs: 60_000,
max: 30, max: 30,
key: getParamRateLimitKey('token'), key: getParamRateLimitKey('code'),
})
const materialLinkUploadIpRateLimit = createRateLimitMiddleware({
scope: 'collect:link:upload:ip',
windowMs: 60_000,
max: 60,
}) })
router.post( router.post(
@@ -88,35 +107,39 @@ router.post(
) )
router.get( router.get(
'/link/:token', '/link/:code',
materialLinkReadIpRateLimit,
materialLinkReadRateLimit, materialLinkReadRateLimit,
createRouteHandler((req) => getPublicWorkOrderMaterialLink(String(req.params.token || '')), { createRouteHandler((req) => getPublicWorkOrderMaterialLink(String(req.params.code || '')), {
errorMessage: '读取补资料链接失败', errorMessage: '读取补资料链接失败',
scope: '[collect/link/:token]', scope: '[collect/link/:code]',
}), }),
) )
router.post( router.post(
'/link/:token/submit', '/link/:code/submit',
materialLinkWriteIpRateLimit,
materialLinkWriteRateLimit, materialLinkWriteRateLimit,
createRouteHandler( createRouteHandler(
(req) => submitPublicWorkOrderMaterialLink(String(req.params.token || ''), req.body || {}), (req) => submitPublicWorkOrderMaterialLink(String(req.params.code || ''), req.body || {}),
{ {
successMessage: '资料已提交', successMessage: '资料已提交',
errorMessage: '提交补资料失败', errorMessage: '提交补资料失败',
scope: '[collect/link/:token/submit]', scope: '[collect/link/:code/submit]',
}, },
), ),
) )
router.post( router.post(
'/link/:token/upload', '/link/:code/upload',
materialLinkUploadIpRateLimit,
materialLinkUploadRateLimit, materialLinkUploadRateLimit,
uploadSingleFile, uploadSingleFile,
createRouteHandler( createRouteHandler(
async (req) => { async (req) => {
const { order } = await getPublicWorkOrderMaterialLinkUploadContext( const { order } = await getPublicWorkOrderMaterialLinkUploadContext(
String(req.params.token || ''), String(req.params.code || ''),
req.query.workOrderId,
) )
return uploadFileAsset({ return uploadFileAsset({
file: req.file, file: req.file,
@@ -128,7 +151,7 @@ router.post(
{ {
successMessage: '文件已上传', successMessage: '文件已上传',
errorMessage: '文件上传失败', errorMessage: '文件上传失败',
scope: '[collect/link/:token/upload]', scope: '[collect/link/:code/upload]',
}, },
), ),
) )
@@ -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) }
}
@@ -37,6 +37,7 @@ export * from './admin-worker-cancel-service.js'
export * from './admin-work-order-sharing-service.js' export * from './admin-work-order-sharing-service.js'
export * from './admin-work-order-realtime-service.js' export * from './admin-work-order-realtime-service.js'
export * from './admin-work-order-material-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-work-order-gift-service.js'
export * from './admin-mock-work-order-service.js' export * from './admin-mock-work-order-service.js'
export * from './admin-mock-custom-shop-service.js' export * from './admin-mock-custom-shop-service.js'
@@ -290,6 +290,12 @@ export function mapWorkOrderAdmin(
workOrder.status === WORK_ORDER_STATUS.UNASSIGNED || workOrder.status === WORK_ORDER_STATUS.UNASSIGNED ||
workOrder.status === WORK_ORDER_STATUS.OPEN || workOrder.status === WORK_ORDER_STATUS.OPEN ||
workOrder.status === WORK_ORDER_STATUS.IN_PROGRESS, 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: canAccept:
status === WORK_ORDER_STATUS.PENDING_ACCEPTANCE || status === WORK_ORDER_STATUS.PENDING_ACCEPTANCE ||
(isFriendGift && (isFriendGift &&
@@ -2,63 +2,173 @@ import assert from 'node:assert/strict'
import test from 'node:test' import test from 'node:test'
import { import {
resolveWorkOrderMaterialLinkUnavailableReason, formatPublicMaterialStatus,
pickSubmittedMaterialFields, pickSubmittedMaterialFields,
resolveMaterialResetBlockReason,
resolvePublicMaterialOrderState,
resolveWorkOrderMaterialLinkOrderBlockReason,
} from './work-order-material-link-service.js' } from './work-order-material-link-service.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( assert.equal(
resolveWorkOrderMaterialLinkUnavailableReason( resolveMaterialResetBlockReason({
{ status: 'active', expires_at: '2026-10-31T13:00:00.000Z' }, status: 'unassigned',
NOW, assigned_worker_id: null,
), active_share_quantity: 0,
published_at: null,
hall_queued_at: null,
}),
'', '',
) )
})
test('补资料链接:active 但已过期按过期处理', () => {
assert.equal( assert.equal(
resolveWorkOrderMaterialLinkUnavailableReason({ status: 'active', expires_at: NOW }, NOW), resolveMaterialResetBlockReason({
'expired', 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 分别返回对应原因', () => { test('管理端链接准入:待完善/待分配可用,已指派/有份额/其他状态拒绝', () => {
assert.equal( assert.equal(
resolveWorkOrderMaterialLinkUnavailableReason( resolveWorkOrderMaterialLinkOrderBlockReason({
{ status: 'used', expires_at: '2026-10-31T13:00:00.000Z' }, status: 'pending_material',
NOW, assigned_worker_id: null,
), active_share_quantity: 0,
'used', }),
'',
) )
assert.equal( assert.equal(
resolveWorkOrderMaterialLinkUnavailableReason( resolveWorkOrderMaterialLinkOrderBlockReason({
{ status: 'expired', expires_at: '2026-10-31T13:00:00.000Z' }, status: 'unassigned',
NOW, assigned_worker_id: null,
), active_share_quantity: 0,
'expired', }),
'',
) )
assert.equal( assert.equal(
resolveWorkOrderMaterialLinkUnavailableReason( resolveWorkOrderMaterialLinkOrderBlockReason({
{ status: 'revoked', expires_at: '2026-10-31T13:00:00.000Z' }, status: 'open',
NOW, assigned_worker_id: null,
), active_share_quantity: 0,
'revoked', }),
'status',
) )
})
test('补资料链接:未知状态一律视为失效,避免误放行', () => {
assert.equal( assert.equal(
resolveWorkOrderMaterialLinkUnavailableReason( resolveWorkOrderMaterialLinkOrderBlockReason({
{ status: 'pending_material',
status: 'unknown' as never, assigned_worker_id: 9,
expires_at: '2026-10-31T13:00:00.000Z', active_share_quantity: 0,
}, }),
NOW, 'assigned',
), )
'revoked', assert.equal(
resolveWorkOrderMaterialLinkOrderBlockReason({
status: 'pending_material',
assigned_worker_id: null,
active_share_quantity: 2,
}),
'shares',
) )
}) })
@@ -5,15 +5,11 @@ import { WORK_ORDER_STATUS } from '../../domain/work-order-status.js'
import { import {
createWorkOrderEventWithClient, createWorkOrderEventWithClient,
createWorkOrderMaterialLinkWithClient, createWorkOrderMaterialLinkWithClient,
findWorkOrderMaterialLinkByToken,
findActiveWorkOrderMaterialLinkWithClient, findActiveWorkOrderMaterialLinkWithClient,
getWorkOrderForUpdateWithClient, getWorkOrderForUpdateWithClient,
getWorkOrderMaterialLinkForUpdateWithClient, listWorkOrdersByPlatformOrderId,
markWorkOrderMaterialLinkExpired,
markWorkOrderMaterialLinkUsedWithClient,
revokeActiveWorkOrderMaterialLinksWithClient, revokeActiveWorkOrderMaterialLinksWithClient,
updateWorkOrderMaterialWithClient, updateWorkOrderMaterialWithClient,
type WorkOrderMaterialLinkRow,
} from '../../repositories/worker-platform/index.js' } from '../../repositories/worker-platform/index.js'
import type { WorkOrderRow } from '../../repositories/worker-platform/types.js' import type { WorkOrderRow } from '../../repositories/worker-platform/types.js'
import type { JsonObject } from '../../types/json.js' import type { JsonObject } from '../../types/json.js'
@@ -26,6 +22,7 @@ import { publishWorkOrderRealtimeChange } from '../realtime/realtime-event-servi
import { import {
mapCollectLookupOrder, mapCollectLookupOrder,
mapWorkOrderAdmin, mapWorkOrderAdmin,
normalizeOptionalId,
normalizeSubmittedFields, normalizeSubmittedFields,
normalizeUploadedFiles, normalizeUploadedFiles,
resolveRequirementFields, resolveRequirementFields,
@@ -40,29 +37,142 @@ const ALLOWED_MATERIAL_LINK_ORDER_STATUSES = new Set<string>([
const MAX_MATERIAL_SCREENSHOTS = 5 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 WorkOrderMaterialLinkOrderBlockReason = 'status' | 'assigned' | 'shares' | ''
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( export function resolvePublicMaterialOrderState(
link: Pick<WorkOrderMaterialLinkRow, 'status' | 'expires_at'>, order: Pick<WorkOrderRow, 'status' | 'assigned_worker_id' | 'active_share_quantity'>,
now: string, ): PublicMaterialOrderState {
): WorkOrderMaterialLinkUnavailableReason { const statusLabel = formatPublicMaterialStatus(order.status)
if (link.status === 'used') return 'used'
if (link.status === 'revoked') return 'revoked' if (order.status === WORK_ORDER_STATUS.UNASSIGNED) {
if (link.status === 'expired') return 'expired' return {
if (link.status !== 'active') return 'revoked' canSubmit: false,
if (new Date(link.expires_at).getTime() <= new Date(now).getTime()) return 'expired' 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 '只有待分配(未指派、无份额、未发布)的工单可以重置补资料状态'
}
/**
* 管理端生成/复用一次性链接的准入判断。
*
* 用户要求保留现有“复制补资料链接”按钮,所以这里仍按原口径允许
* 待完善 / 待分配,并拒绝已指派/有份额的工单。
*/
export function resolveWorkOrderMaterialLinkOrderBlockReason(
order: Pick<WorkOrderRow, 'status' | 'assigned_worker_id' | 'active_share_quantity'>,
): WorkOrderMaterialLinkOrderBlockReason {
if (!ALLOWED_MATERIAL_LINK_ORDER_STATUSES.has(order.status)) return 'status'
if (order.assigned_worker_id) return 'assigned'
if (Number(order.active_share_quantity || 0) > 0) return 'shares'
return '' return ''
} }
/** /**
* 只保留工单 requirement 里定义过的字段。 * 只保留工单 requirement 里定义过的字段。
* *
* 公开链接的提交体是客户可构造的,不能让 `rewardAmount`、`status` 之类的 * 公开提交体是客户可构造的,不能让 `rewardAmount`、`status` 之类的
* 额外 key 混进 material.collect.fields;这里按白名单裁剪一次。 * 额外 key 混进 material.collect.fields;这里按白名单裁剪一次。
*/ */
export function pickSubmittedMaterialFields( export function pickSubmittedMaterialFields(
@@ -73,57 +183,42 @@ export function pickSubmittedMaterialFields(
return Object.fromEntries(Object.entries(submitted).filter(([key]) => allowedKeys.has(key))) return Object.fromEntries(Object.entries(submitted).filter(([key]) => allowedKeys.has(key)))
} }
function throwMaterialLinkUnavailable( function throwPublicMaterialBlocked(state: PublicMaterialOrderState): never {
reason: Exclude<WorkOrderMaterialLinkUnavailableReason, ''>, if (state.blockedReason === 'already_submitted') {
): never { throw createHttpError(state.message, {
if (reason === 'used') { statusCode: 409,
throw createHttpError('链接已使用,如需修改资料请联系客服重新获取', { errorCode: 'material_link_already_submitted',
statusCode: 410,
errorCode: 'material_link_used',
}) })
} }
if (reason === 'expired') { throw createHttpError(state.message, {
throw createHttpError('链接已过期,请联系客服重新获取', { statusCode: 409,
statusCode: 410, errorCode: 'material_link_order_status_invalid',
errorCode: 'material_link_expired',
})
}
throw createHttpError('链接已失效,请联系客服重新获取', {
statusCode: 410,
errorCode: 'material_link_revoked',
}) })
} }
/** /** 管理端生成补资料链接时仍沿用旧的准入文案。 */
* 公开链接只对「待完善 / 未分配」开放,且不能已经指派打手或有进行中的拼单份额。
* 这三个条件同时满足,提交后才可以安全地把状态改成「未分配」。
*/
function assertWorkOrderAllowedForMaterialLink(order: WorkOrderRow): void { function assertWorkOrderAllowedForMaterialLink(order: WorkOrderRow): void {
if (!ALLOWED_MATERIAL_LINK_ORDER_STATUSES.has(order.status)) { const reason = resolveWorkOrderMaterialLinkOrderBlockReason(order)
throw createHttpError('订单当前状态不允许补资料,请联系客服重新获取链接', { if (reason === 'status') {
throw createHttpError('当前状态不能生成补资料链接', {
statusCode: 409, statusCode: 409,
errorCode: 'material_link_order_status_invalid', errorCode: 'material_link_status_invalid',
}) })
} }
if (order.assigned_worker_id) { if (reason === 'assigned') {
throw createHttpError('订单已指派打手,不能通过公开链接修改资料', { throw createHttpError('订单已指派打手,不能生成补资料链接', {
statusCode: 409, statusCode: 409,
errorCode: 'material_link_order_status_invalid', errorCode: 'material_link_status_invalid',
}) })
} }
if (Number(order.active_share_quantity || 0) > 0) { if (reason === 'shares') {
throw createHttpError('订单已有拼单份额,不能通过公开链接修改资料', { throw createHttpError('订单已有拼单份额,不能生成补资料链接', {
statusCode: 409, statusCode: 409,
errorCode: 'material_link_order_status_invalid', errorCode: 'material_link_status_invalid',
}) })
} }
} }
function assertMaterialLinkRecordUsable(link: WorkOrderMaterialLinkRow, now: string): void {
const reason = resolveWorkOrderMaterialLinkUnavailableReason(link, now)
if (reason) throwMaterialLinkUnavailable(reason)
}
function mapPublicOrder(order: WorkOrderRow) { function mapPublicOrder(order: WorkOrderRow) {
return { return {
workOrderNo: order.work_order_no, workOrderNo: order.work_order_no,
@@ -139,11 +234,67 @@ function toIsoTimestamp(value: string): string {
return Number.isNaN(date.getTime()) ? String(value || '') : date.toISOString() 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,
}
}
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: 'material_link_work_order_invalid',
})
}
return order
}
const orders = await listWorkOrdersByPlatformOrderId(platformOrderId)
if (orders.length === 0) {
throw createHttpError('订单号无效,请确认订单号是否正确', {
statusCode: 404,
errorCode: 'material_link_not_found',
})
}
if (orders.length > 1) {
throw createHttpError('该订单号下有多个商品,请先选择商品', {
statusCode: 409,
errorCode: 'material_link_work_order_required',
})
}
return orders[0]!
}
/** /**
* 管理端生成/复用一次性链接。 * 管理端生成/复用一次性链接。
* *
* 幂等策略:同一工单已有未过期 active 链接时直接返回,避免客服连续点两次 * 用户要求保留现有“复制补资料链接”按钮,因此链接记录仍会生成;
* 把刚发出去的链接顶掉;只有已使用/已过期/已撤销时才生成新 token。 * 但公开页已经不再依赖它,复制出的 `/supplement/<平台订单号>` 始终可用。
*/ */
export async function createAdminWorkOrderMaterialLink( export async function createAdminWorkOrderMaterialLink(
workOrderId: number | string, workOrderId: number | string,
@@ -166,6 +317,15 @@ export async function createAdminWorkOrderMaterialLink(
errorCode: 'material_link_status_invalid', errorCode: 'material_link_status_invalid',
}) })
} }
const platformOrderId = String(order.platform_order_id || '').trim()
if (!platformOrderId) {
throw createHttpError('该工单没有平台订单号,不能生成补资料链接', {
statusCode: 409,
errorCode: 'material_link_platform_order_missing',
})
}
assertWorkOrderAllowedForMaterialLink(order) assertWorkOrderAllowedForMaterialLink(order)
// 锁到手后再取时间,避免等锁期间旧链接过期却仍按旧时间复用。 // 锁到手后再取时间,避免等锁期间旧链接过期却仍按旧时间复用。
@@ -174,6 +334,7 @@ export async function createAdminWorkOrderMaterialLink(
if (existing) { if (existing) {
return { return {
token: existing.token, token: existing.token,
platformOrderId,
expiresAt: toIsoTimestamp(existing.expires_at), expiresAt: toIsoTimestamp(existing.expires_at),
reused: true, reused: true,
} }
@@ -192,6 +353,7 @@ export async function createAdminWorkOrderMaterialLink(
return { return {
token: link.token, token: link.token,
platformOrderId,
expiresAt: toIsoTimestamp(link.expires_at), expiresAt: toIsoTimestamp(link.expires_at),
reused: false, reused: false,
} }
@@ -199,83 +361,76 @@ export async function createAdminWorkOrderMaterialLink(
} }
/** /**
* 公开页读取链接内容。 * 公开页按平台订单号读取补资料内容。
* *
* 只返回客户补资料需要的最少信息:商品/单号、动态字段、已填值、截图、过期时间。 * 不再要求客服先生成链接;只要订单号存在,就返回该订单号下所有工单的
* 不返回发单价格、押金、成本、打手、后台备注等任何后台字段。 * 状态与准入信息。只有可提交的待完善工单返回字段/已填值/截图,其他状态
* 只返回商品、工单号、状态和客服提示。
*/ */
export async function getPublicWorkOrderMaterialLink(token: string) { export async function getPublicWorkOrderMaterialLink(platformOrderId: string) {
const link = await findWorkOrderMaterialLinkByToken(token) const code = String(platformOrderId || '').trim()
if (!link) { if (!code) {
throw createHttpError('链接无效,请确认链接是否完整', { throw createHttpError('订单号无效,请确认订单号是否正确', {
statusCode: 404, statusCode: 404,
errorCode: 'material_link_not_found', errorCode: 'material_link_not_found',
}) })
} }
const now = nowIso() const orders = await listWorkOrdersByPlatformOrderId(code)
const reason = resolveWorkOrderMaterialLinkUnavailableReason(link, now) if (orders.length === 0) {
if (reason) { throw createHttpError('订单号无效,请确认订单号是否正确', {
if (reason === 'expired') { statusCode: 404,
await markWorkOrderMaterialLinkExpired(link.id, now) errorCode: 'material_link_not_found',
} })
throwMaterialLinkUnavailable(reason)
} }
const order = await getRequiredWorkOrder(link.work_order_id) const publicOrders = orders.map(mapPublicMaterialOrder)
assertWorkOrderAllowedForMaterialLink(order)
const mapped = mapCollectLookupOrder(order)
return { return {
order: { platformOrderId: code,
workOrderNo: mapped.workOrderNo, orders: publicOrders,
platformOrderId: mapped.platformOrderId, pendingCount: publicOrders.filter((order) => order.canSubmit).length,
productName: mapped.productName,
status: mapped.status,
},
fields: mapped.fields,
values: mapped.values,
screenshots: mapped.screenshots,
expiresAt: toIsoTimestamp(link.expires_at),
} }
} }
/** /**
* 公开页提交资料。 * 公开页提交资料。
* *
* 一次性语义:只有「完整提交」成功时才把 token 标为 used; * 一次性语义完全由工单状态保证:只有 `pending_material` 能成功提交,
* 少填必填项、订单状态变化、网络失败等都会在事务里回滚,链接继续可用。 * 提交后改成 `unassigned`;并发的第二个提交会锁到 `unassigned` 并返回 409。
*/ */
export async function submitPublicWorkOrderMaterialLink(token: string, payload: JsonObject = {}) { export async function submitPublicWorkOrderMaterialLink(
const preliminary = await findWorkOrderMaterialLinkByToken(token) platformOrderId: string,
if (!preliminary) { payload: JsonObject = {},
throw createHttpError('链接无效,请确认链接是否完整', { ) {
const code = String(platformOrderId || '').trim()
if (!code) {
throw createHttpError('订单号无效,请确认订单号是否正确', {
statusCode: 404, statusCode: 404,
errorCode: 'material_link_not_found', 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 result = await withTransaction(async (client) => {
// 先锁工单再锁链接,和后台生成链接保持同样的加锁顺序,避免死锁。 // 锁工单:并发提交/客服重置都串行化,状态是唯一的一次性凭据。
const order = await getWorkOrderForUpdateWithClient(client, preliminary.work_order_id) const order = await getWorkOrderForUpdateWithClient(client, target.id)
if (!order) { if (!order) {
throw createHttpError('接单订单不存在', { throw createHttpError('接单订单不存在', {
statusCode: 404, statusCode: 404,
errorCode: 'work_order_not_found', errorCode: 'work_order_not_found',
}) })
} }
const link = await getWorkOrderMaterialLinkForUpdateWithClient(client, preliminary.id) if (String(order.platform_order_id || '').trim() !== code) {
if (!link) { throw createHttpError('订单号无效,请确认订单号是否正确', {
throw createHttpError('链接无效,请确认链接是否完整', {
statusCode: 404, statusCode: 404,
errorCode: 'material_link_not_found', errorCode: 'material_link_work_order_invalid',
}) })
} }
const orderState = resolvePublicMaterialOrderState(order)
// 锁到手后再取时间:等锁期间链接可能已经过期,不能沿用进入事务前的时间。 if (!orderState.canSubmit) throwPublicMaterialBlocked(orderState)
const now = nowIso()
assertMaterialLinkRecordUsable(link, now)
assertWorkOrderAllowedForMaterialLink(order)
const fields = resolveRequirementFields(order) const fields = resolveRequirementFields(order)
const submittedFields = pickSubmittedMaterialFields( const submittedFields = pickSubmittedMaterialFields(
@@ -304,6 +459,7 @@ export async function submitPublicWorkOrderMaterialLink(token: string, payload:
}) })
} }
const now = nowIso()
const material = { const material = {
...safeParseJson(order.material_json), ...safeParseJson(order.material_json),
collect: { collect: {
@@ -311,7 +467,7 @@ export async function submitPublicWorkOrderMaterialLink(token: string, payload:
screenshots, screenshots,
submittedAt: now, submittedAt: now,
complete: true, complete: true,
source: 'customer_link', source: 'customer_order_no',
}, },
} }
@@ -328,33 +484,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, { await createWorkOrderEventWithClient(client, {
workOrderId: order.id, workOrderId: order.id,
actorType: 'collect', actorType: 'collect',
actorId: '客户补资料链接', actorId: '客户按订单号补资料',
eventType: 'material_completed', eventType: 'material_completed',
fromStatus: order.status, fromStatus: order.status,
toStatus: WORK_ORDER_STATUS.UNASSIGNED, toStatus: WORK_ORDER_STATUS.UNASSIGNED,
payloadJson: JSON.stringify({ payloadJson: JSON.stringify({
fields: submittedFields, fields: submittedFields,
complete: true, complete: true,
source: 'customer_link', source: 'customer_order_no',
}), }),
now, now,
}) })
return { order: updated, link: used } return { order: updated }
}) })
// 事务已提交,后续通知/实时广播失败不能让客户误以为提交失败。 // 事务已提交,后续通知/实时广播失败不能让客户误以为提交失败。
@@ -374,28 +519,30 @@ export async function submitPublicWorkOrderMaterialLink(token: string, payload:
return { return {
complete: true, complete: true,
workOrderId: Number(result.order.id),
order: mapPublicOrder(result.order), order: mapPublicOrder(result.order),
} }
} }
/** /**
* 上传前校验 token 与工单状态;返回工单 id 供文件归属使用。 * 上传前校验平台订单号 / workOrderId 与工单状态;返回工单供文件归属使用。
* 注意:这里不消耗 token,只有最终提交才消耗。 * 注意:这里不消耗提交机会,只有最终提交才把状态改成待分配。
*/ */
export async function getPublicWorkOrderMaterialLinkUploadContext(token: string) { export async function getPublicWorkOrderMaterialLinkUploadContext(
const link = await findWorkOrderMaterialLinkByToken(token) platformOrderId: string,
if (!link) { workOrderId?: unknown,
throw createHttpError('链接无效,请确认链接是否完整', { ) {
const code = String(platformOrderId || '').trim()
if (!code) {
throw createHttpError('订单号无效,请确认订单号是否正确', {
statusCode: 404, statusCode: 404,
errorCode: 'material_link_not_found', errorCode: 'material_link_not_found',
}) })
} }
const now = nowIso() const order = await resolvePublicMaterialTarget(code, workOrderId)
assertMaterialLinkRecordUsable(link, now) const orderState = resolvePublicMaterialOrderState(order)
if (!orderState.canSubmit) throwPublicMaterialBlocked(orderState)
const order = await getRequiredWorkOrder(link.work_order_id) return { order, now: nowIso() }
assertWorkOrderAllowedForMaterialLink(order)
return { link, order, now }
} }
+13 -5
View File
@@ -46,6 +46,9 @@ const AdminWorkerPlatformPage = lazy(() => import('@/pages/admin/AdminWorkerPlat
const ClaimPage = lazy(() => import('@/pages/claim/ClaimPage')) const ClaimPage = lazy(() => import('@/pages/claim/ClaimPage'))
const H5ClaimEntryPage = lazy(() => import('@/pages/claim/H5ClaimEntryPage')) const H5ClaimEntryPage = lazy(() => import('@/pages/claim/H5ClaimEntryPage'))
const CollectPage = lazy(() => import('@/pages/collect/CollectPage')) const CollectPage = lazy(() => import('@/pages/collect/CollectPage'))
const CollectMaterialLinkEntryPage = lazy(
() => import('@/pages/collect/CollectMaterialLinkEntryPage'),
)
const CollectMaterialLinkPage = lazy(() => import('@/pages/collect/CollectMaterialLinkPage')) const CollectMaterialLinkPage = lazy(() => import('@/pages/collect/CollectMaterialLinkPage'))
const NotFoundPage = lazy(() => import('@/pages/NotFoundPage')) const NotFoundPage = lazy(() => import('@/pages/NotFoundPage'))
const RedeemPage = lazy(() => import('@/pages/redeem/RedeemPage')) const RedeemPage = lazy(() => import('@/pages/redeem/RedeemPage'))
@@ -124,8 +127,8 @@ export default function App() {
return <RedeemApplication /> return <RedeemApplication />
} }
// 一次性补资料链接(`/supplement/<token>`):路径式公开页,先于站点判断, // 一次性补资料链接(`/supplement`):路径式公开页,先于站点判断,
// 保证在后台域名和打手端域名下都能打开。 // 保证在后台域名和打手端域名下都能打开。带订单号直接进补资料页,不带订单号进输入页。
if (isCollectMaterialLinkPath(window.location.pathname)) { if (isCollectMaterialLinkPath(window.location.pathname)) {
return <CollectMaterialLinkApplication /> return <CollectMaterialLinkApplication />
} }
@@ -235,9 +238,13 @@ function ClaimApplication() {
} }
/** /**
* 一次性补资料链接(`/supplement/<token>`)的独立路由树。 * 一次性补资料链接(`/supplement`)的独立路由树。
* *
* 路径式公开页,不带 hash;页面只读取 token,不依赖后台会话。 * - `/supplement`:输入平台订单号;
* - `/supplement/<订单号>`:直接打开对应订单的补资料页;
* - 其余子路径:交给补资料页展示「链接无效」。
*
* 路径式公开页,不带 hash;不依赖后台会话。
*/ */
function CollectMaterialLinkApplication() { function CollectMaterialLinkApplication() {
useClearStrayHash() useClearStrayHash()
@@ -246,7 +253,8 @@ function CollectMaterialLinkApplication() {
<BrowserRouter> <BrowserRouter>
<Suspense fallback={<RouteLoading />}> <Suspense fallback={<RouteLoading />}>
<Routes> <Routes>
<Route path="/supplement/:token" element={<CollectMaterialLinkPage />} /> <Route path="/supplement" element={<CollectMaterialLinkEntryPage />} />
<Route path="/supplement/:code" element={<CollectMaterialLinkPage />} />
<Route path="*" element={<CollectMaterialLinkPage />} /> <Route path="*" element={<CollectMaterialLinkPage />} />
</Routes> </Routes>
</Suspense> </Suspense>
@@ -21,7 +21,7 @@ type EventNodeStyle = {
/** 工单状态中文名 */ /** 工单状态中文名 */
const STATUS_LABELS: Record<string, string> = { const STATUS_LABELS: Record<string, string> = {
pending_material: '待完善资料', pending_material: '待完善资料',
unassigned: '未分配', unassigned: '待分配',
open: '待抢单', open: '待抢单',
in_progress: '代练中', in_progress: '代练中',
pending_acceptance: '待验收', pending_acceptance: '待验收',
@@ -176,6 +176,14 @@ export function formatWorkOrderEvent(event: WorkOrderEvent): EventNodeStyle {
return { title: '完善了订单资料', color: 'cyan' } return { title: '完善了订单资料', color: 'cyan' }
case 'material_updated': case 'material_updated':
return { title: '更新了订单资料', color: 'cyan' } return { title: '更新了订单资料', color: 'cyan' }
case 'material_reset':
return {
title: note ? `客服重置补资料状态:${note}` : '客服重置补资料状态',
description: `订单状态:${formatStatusLabel(event.fromStatus)} → ${formatStatusLabel(
event.toStatus,
)}`,
color: 'orange',
}
// —— 好友赠送节点 —— // —— 好友赠送节点 ——
case 'gift_material_submitted': case 'gift_material_submitted':
@@ -28,7 +28,7 @@ type ImageUploadProps = {
captureGlobalPaste?: boolean captureGlobalPaste?: boolean
/** 是否显示移动端「拍照」入口;不传时按「打手端 + 移动端」自动判断 */ /** 是否显示移动端「拍照」入口;不传时按「打手端 + 移动端」自动判断 */
allowCamera?: boolean allowCamera?: boolean
/** 自定义上传函数;公开一次性链接用它把文件传到 token 校验过的上传接口。 */ /** 自定义上传函数;公开一次性链接用它把文件传到带订单号 / workOrderId 校验的上传接口。 */
uploader?: ImageUploadUploader uploader?: ImageUploadUploader
} }
@@ -78,6 +78,7 @@ import {
reduceAdminWorkOrderShareQuantity, reduceAdminWorkOrderShareQuantity,
reopenAdminCancelledWorkOrder, reopenAdminCancelledWorkOrder,
resetAdminWorkOrderGiftMaterial, resetAdminWorkOrderGiftMaterial,
resetAdminWorkOrderMaterialStatus,
resolveAdminProblemWorkOrder, resolveAdminProblemWorkOrder,
submitAdminWorkOrderMaterial, submitAdminWorkOrderMaterial,
unpublishAdminWorkOrder, unpublishAdminWorkOrder,
@@ -106,6 +107,7 @@ import dayjs, { ADMIN_DATE_FORMAT } from '@/lib/dayjs'
import { ADMIN_DEFAULT_PAGE_SIZE, buildAdminTablePagination } from '@/utils/admin-pagination' import { ADMIN_DEFAULT_PAGE_SIZE, buildAdminTablePagination } from '@/utils/admin-pagination'
import { getAdminUsername, hasAdminPermission, hasAdminRole } from '@/utils/admin-auth' import { getAdminUsername, hasAdminPermission, hasAdminRole } from '@/utils/admin-auth'
import { formatAdminDateTime } from '@/utils/admin-time' import { formatAdminDateTime } from '@/utils/admin-time'
import { buildCollectMaterialLinkUrl } from '@/utils/collect-link'
import { isExplicitOrderNoSearch, normalizeSearchText } from '@/utils/admin-realtime-work-orders' import { isExplicitOrderNoSearch, normalizeSearchText } from '@/utils/admin-realtime-work-orders'
import { import {
DeadlineCountdown, DeadlineCountdown,
@@ -203,10 +205,11 @@ function getConsignmentFulfillment(row: WorkOrder): ConsignmentFulfillmentInfo |
return Object.keys(consignment).length > 0 ? (consignment as ConsignmentFulfillmentInfo) : null return Object.keys(consignment).length > 0 ? (consignment as ConsignmentFulfillmentInfo) : null
} }
/** 公开补资料链接只在「待完善 / 未分配」阶段生成;已进大厅或已接单不允许客户改资料。 */ /** 公开补资料链接只在「待完善 / 待分配」且有平台订单号时生成;已进大厅或已接单不允许客户改资料。 */
function canCopyMaterialLink(order: WorkOrder): boolean { function canCopyMaterialLink(order: WorkOrder): boolean {
const status = String(order.rawStatus || order.status || '') const status = String(order.rawStatus || order.status || '')
return status === 'pending_material' || status === 'unassigned' const platformOrderId = String(order.platformOrderId || '').trim()
return (status === 'pending_material' || status === 'unassigned') && Boolean(platformOrderId)
} }
/** 剪贴板 API 在 HTTP + IP 下可能不可用,补一个 textarea 兜底。 */ /** 剪贴板 API 在 HTTP + IP 下可能不可用,补一个 textarea 兜底。 */
@@ -1491,7 +1494,7 @@ export default function WorkOrdersPanel() {
modal.confirm({ modal.confirm({
title: `确认删除订单 ${getDisplayOrderNo(row)}?`, title: `确认删除订单 ${getDisplayOrderNo(row)}?`,
content: content:
'删除后工单将从列表中移除,且不可恢复。仅未分配、待完善或已取消且无拼单参与的工单可删除。', '删除后工单将从列表中移除,且不可恢复。仅待分配、待完善或已取消且无拼单参与的工单可删除。',
okText: '确认删除', okText: '确认删除',
okButtonProps: { danger: true }, okButtonProps: { danger: true },
cancelText: '取消', cancelText: '取消',
@@ -1577,6 +1580,22 @@ export default function WorkOrdersPanel() {
}) })
} }
function requestResetMaterial(row: WorkOrder) {
modal.confirm({
title: '重置补资料状态?',
content:
'将把该工单重置为“待完善”,客户可用订单号重新提交一次资料。已填资料会保留,客户重新提交后覆盖;此操作会记录在订单流转记录中。',
okText: '确认重置',
okButtonProps: { type: 'primary' },
cancelText: '取消',
onOk: () =>
runAction(
() => resetAdminWorkOrderMaterialStatus(row.workOrderId),
'已重置为待完善,客户刷新补资料页即可重新提交',
),
})
}
function copyBuyerMaterialInfo(order: WorkOrder) { function copyBuyerMaterialInfo(order: WorkOrder) {
const items = getMaterialDetailItems(order).filter((item) => String(item.value || '').trim()) const items = getMaterialDetailItems(order).filter((item) => String(item.value || '').trim())
if (items.length === 0) { if (items.length === 0) {
@@ -1638,12 +1657,24 @@ export default function WorkOrdersPanel() {
setMaterialLinkLoadingId(order.workOrderId) setMaterialLinkLoadingId(order.workOrderId)
try { try {
const response = await createAdminWorkOrderMaterialLink(order.workOrderId) const response = await createAdminWorkOrderMaterialLink(order.workOrderId)
const url = `${window.location.origin}/supplement/${encodeURIComponent(response.data.token)}` // 新后端返回 platformOrderId;旧后端缺失时回退 token,仅用于前后端滚动发布。
const platformOrderId = String(
response.data.platformOrderId || response.data.token || '',
).trim()
if (!platformOrderId) {
message.error('生成补资料链接失败:缺少平台订单号')
return
}
const url = buildCollectMaterialLinkUrl(window.location.origin, platformOrderId)
if (!url) {
message.error('生成补资料链接失败:链接地址为空')
return
}
const copied = await copyTextToClipboard(url) const copied = await copyTextToClipboard(url)
const expiresText = formatAdminDateTime(response.data.expiresAt) const expiresText = formatAdminDateTime(response.data.expiresAt)
if (copied) { if (copied) {
message.success( message.success(
`${response.data.reused ? '已复制现有链接' : '已生成并复制新链接'},${expiresText} 前有效,仅可提交一次`, `${response.data.reused ? '已复制现有链接' : '已生成并复制链接'}(订单号 ${platformOrderId}),${expiresText} 前有效;该订单号下已生成链接的待补商品会一起显示`,
) )
} else { } else {
setMaterialLinkFallback({ url, expiresAt: response.data.expiresAt }) setMaterialLinkFallback({ url, expiresAt: response.data.expiresAt })
@@ -1914,13 +1945,13 @@ export default function WorkOrdersPanel() {
onClick={() => { onClick={() => {
modal.confirm({ modal.confirm({
title: '确认重新启用该订单?', title: '确认重新启用该订单?',
content: '订单将恢复为未分配状态。请确认资料与金额后,再发布到抢单大厅。', content: '订单将恢复为待分配状态。请确认资料与金额后,再发布到抢单大厅。',
okText: '重新启用', okText: '重新启用',
cancelText: '取消', cancelText: '取消',
onOk: () => onOk: () =>
runAction( runAction(
() => reopenAdminCancelledWorkOrder(row.workOrderId), () => reopenAdminCancelledWorkOrder(row.workOrderId),
'订单已恢复为未分配状态,可编辑后发布', '订单已恢复为待分配状态,可编辑后发布',
), ),
}) })
}} }}
@@ -1969,11 +2000,20 @@ export default function WorkOrdersPanel() {
icon={<LinkOutlined />} icon={<LinkOutlined />}
loading={materialLinkLoadingId === row.workOrderId} loading={materialLinkLoadingId === row.workOrderId}
onClick={() => void copyMaterialLink(row)} onClick={() => void copyMaterialLink(row)}
title="生成一次性补资料链接(有效期内仅可提交一次)" title="生成一次性补资料链接(按平台订单号打开;有效期内每个工单仅可提交一次)"
> >
复制补资料链接 复制补资料链接
</Button> </Button>
) : null} ) : null}
{row.capabilities?.canResetMaterial && canUpdateMaterial ? (
<Button
icon={<RollbackOutlined />}
onClick={() => requestResetMaterial(row)}
title="把已提交的补资料重置为待完善,客户可重新提交一次"
>
重置补资料
</Button>
) : null}
{row.capabilities?.canPublish && canPublishOrder ? ( {row.capabilities?.canPublish && canPublishOrder ? (
<Button <Button
icon={<SendOutlined />} icon={<SendOutlined />}
@@ -2006,11 +2046,11 @@ export default function WorkOrdersPanel() {
onClick={() => { onClick={() => {
modal.confirm({ modal.confirm({
title: '确认下架该订单?', title: '确认下架该订单?',
content: '下架后订单会回到未分配状态,不再在抢单大厅展示。', content: '下架后订单会回到待分配状态,不再在抢单大厅展示。',
okText: '确认下架', okText: '确认下架',
cancelText: '取消', cancelText: '取消',
onOk: () => onOk: () =>
runAction(() => unpublishAdminWorkOrder(row.workOrderId), '订单已撤回到未分配'), runAction(() => unpublishAdminWorkOrder(row.workOrderId), '订单已撤回到待分配'),
}) })
}} }}
> >
@@ -3251,7 +3291,8 @@ export default function WorkOrdersPanel() {
{materialLinkFallback ? ( {materialLinkFallback ? (
<Space direction="vertical" size={10} style={{ width: '100%' }}> <Space direction="vertical" size={10} style={{ width: '100%' }}>
<Typography.Text type="secondary"> <Typography.Text type="secondary">
链接仅可提交一次,{formatAdminDateTime(materialLinkFallback.expiresAt)} 前有效。 同一订单号下已生成链接的多个待补工单会显示在同一个页面,每个工单各自仅可提交一次;
{formatAdminDateTime(materialLinkFallback.expiresAt)} 前有效。
</Typography.Text> </Typography.Text>
<Input.TextArea <Input.TextArea
value={materialLinkFallback.url} value={materialLinkFallback.url}
@@ -205,7 +205,7 @@ export function formatMoney(value: number | undefined) {
export function formatStatus(status: string) { export function formatStatus(status: string) {
const labels: Record<string, string> = { const labels: Record<string, string> = {
pending_material: '待完善', pending_material: '待完善',
unassigned: '未分配', unassigned: '待分配',
open: '待抢单', open: '待抢单',
in_progress: '代练中', in_progress: '代练中',
pending_acceptance: '待验收', pending_acceptance: '待验收',
@@ -0,0 +1,67 @@
import { ArrowRightOutlined } from '@ant-design/icons'
import { App, Button, Card, Form, Input, Space, Typography } from 'antd'
import { useNavigate } from 'react-router'
import { normalizeOrderNoInput } from '@/utils/collect-link'
import { useCollectLinkPageMeta } from './use-collect-link-page-meta'
const { Text, Title } = Typography
/**
* 补资料入口页(`/supplement/`)。
*
* 客户只知道平台订单号时,从这里输入订单号再跳到 `/supplement/<订单号>`;
* 如果客服已经发了完整链接,可以直接打开链接跳过这一步。
*/
export default function CollectMaterialLinkEntryPage() {
const { message } = App.useApp()
const navigate = useNavigate()
useCollectLinkPageMeta('订单资料补充')
function handleFinish(values: { orderNo?: string }) {
const orderNo = normalizeOrderNoInput(values.orderNo)
if (!orderNo) {
message.warning('请输入订单号')
return
}
void navigate(`/supplement/${encodeURIComponent(orderNo)}`)
}
return (
<main className="collect-link-page">
<Card className="collect-link-card" bordered={false}>
<Space direction="vertical" size={16} className="full-width">
<div>
<Title level={3} className="collect-link-title">
订单资料补充
</Title>
<Text type="secondary">请输入下单时使用的订单号,进入补资料页面。</Text>
</div>
<Form layout="vertical" onFinish={handleFinish}>
<Form.Item
name="orderNo"
label="订单号"
rules={[{ required: true, whitespace: true, message: '请输入订单号' }]}
>
<Input autoComplete="off" allowClear placeholder="请输入订单号" size="large" />
</Form.Item>
<Button
type="primary"
size="large"
htmlType="submit"
block
icon={<ArrowRightOutlined />}
>
下一步
</Button>
</Form>
<Text type="secondary" className="collect-link-footnote">
如果客服已经发给你完整链接,直接打开链接即可。
</Text>
</Space>
</Card>
</main>
)
}
@@ -1,4 +1,4 @@
import { CheckCircleOutlined, LoadingOutlined } from '@ant-design/icons' import { LoadingOutlined } from '@ant-design/icons'
import { import {
Alert, Alert,
App, App,
@@ -13,17 +13,23 @@ import {
Tag, Tag,
Typography, Typography,
} from 'antd' } from 'antd'
import { useEffect, useState } from 'react' import { useCallback, useEffect, useRef, useState } from 'react'
import { useParams } from 'react-router' import { Link, useParams } from 'react-router'
import ImageUpload from '@/components/files/ImageUpload' import ImageUpload from '@/components/files/ImageUpload'
import { uploadCollectMaterialLinkFile } from '@/services/files' import { uploadCollectMaterialLinkFile } from '@/services/files'
import { fetchCollectMaterialLink, submitCollectMaterialLink } from '@/services/worker' import { fetchCollectMaterialLink, submitCollectMaterialLink } from '@/services/worker'
import type { CollectMaterialLinkInfo, UploadedFile } from '@/types/worker-platform' import type {
import { formatDateTime } from '@/utils/date-time' CollectMaterialLinkInfo,
CollectMaterialLinkOrder,
UploadedFile,
} from '@/types/worker-platform'
import { useCollectLinkPageMeta } from './use-collect-link-page-meta'
const { Text, Title } = Typography const { Text, Title } = Typography
const NOT_FOUND_MESSAGE = '订单号无效,请确认订单号是否正确'
type LinkLoadError = { type LinkLoadError = {
code: string code: string
message: string message: string
@@ -38,135 +44,140 @@ function resolveErrorMessage(error: unknown): string {
} }
function resolveErrorTitle(code: string): string { function resolveErrorTitle(code: string): string {
if (code === 'material_link_expired') return '链接已过期' if (code === 'material_link_not_found' || code === 'material_link_work_order_invalid') {
if (code === 'material_link_revoked') return '链接已失效' return '订单号无效'
if (code === 'material_link_not_found') return '链接无效' }
if (code === 'material_link_work_order_required') return '请选择要补充的商品'
if (code === 'material_link_order_status_invalid') return '订单状态已变化' if (code === 'material_link_order_status_invalid') return '订单状态已变化'
return '无法打开链接' return '暂时无法打开页面'
}
const STATUS_TAG_COLORS: Record<string, string> = {
pending_material: 'orange',
unassigned: 'blue',
open: 'cyan',
in_progress: 'processing',
pending_acceptance: 'purple',
problem: 'red',
accepted: 'green',
cancelled: 'default',
}
function resolveStatusColor(status: string): string {
return STATUS_TAG_COLORS[status] || 'default'
} }
/** /**
* 客户侧一次性补资料页。 * 客户侧补资料页。
* *
* 只渲染 requirement 里的动态字段与买家主页截图,不展示发单价格、押金、 * 只要知道平台订单号就能打开:一个订单号下可能有多个商品工单,页面按 orders
* 打手、后台备注等任何后台字段;提交成功后链接立即失效。 * 渲染多张卡片。只有「待完善 + 未指派 + 无份额」的工单返回表单,其余工单只展示
* 商品、工单号、状态与客服提示,不暴露已填资料和截图。
* 提交成功后工单进入「待分配」,同一工单不能再提交,需联系客服重置。
*/ */
export default function CollectMaterialLinkPage() { export default function CollectMaterialLinkPage() {
const { message } = App.useApp() const { message } = App.useApp()
const { token: routeToken } = useParams<{ token?: string }>() const { code: routeCode } = useParams<{ code?: string }>()
const token = String(routeToken || '').trim() const code = String(routeCode || '').trim()
useCollectLinkPageMeta('订单资料补充')
const [form] = Form.useForm<Record<string, string>>()
const [loading, setLoading] = useState(true) const [loading, setLoading] = useState(true)
const [info, setInfo] = useState<CollectMaterialLinkInfo | null>(null) const [info, setInfo] = useState<CollectMaterialLinkInfo | null>(null)
const [loadError, setLoadError] = useState<LinkLoadError | null>(null) const [loadError, setLoadError] = useState<LinkLoadError | null>(null)
const [submitting, setSubmitting] = useState(false) const [submittingWorkOrderId, setSubmittingWorkOrderId] = useState(0)
const [submitted, setSubmitted] = useState(false) const submittingRef = useRef(false)
const [screenshots, setScreenshots] = useState<UploadedFile[]>([]) const requestSeqRef = useRef(0)
const [screenshotsByOrder, setScreenshotsByOrder] = useState<Record<number, UploadedFile[]>>({})
useEffect(() => { /**
const previousTitle = document.title * 读取订单资料状态。
document.title = '订单资料补充' *
* silent=true 用于提交后刷新:不切整页 loading,避免页面闪烁丢焦点;
* 同时用请求序号丢弃过期响应,防止快速重试时旧数据覆盖新数据。
*/
const loadInfo = useCallback(
async (options: { silent?: boolean } = {}) => {
const seq = requestSeqRef.current + 1
requestSeqRef.current = seq
function applyMeta(name: string, content: string) { if (!code) {
const existing = document.querySelector<HTMLMetaElement>(`meta[name="${name}"]`) setInfo(null)
const previous = existing?.getAttribute('content') ?? null setLoadError({ code: 'material_link_not_found', message: NOT_FOUND_MESSAGE })
let created: HTMLMetaElement | null = null
if (existing) {
existing.setAttribute('content', content)
} else {
created = document.createElement('meta')
created.setAttribute('name', name)
created.setAttribute('content', content)
document.head.appendChild(created)
}
return () => {
if (created) {
created.remove()
} else if (existing) {
if (previous === null) {
existing.removeAttribute('content')
} else {
existing.setAttribute('content', previous)
}
}
}
}
const restoreRobots = applyMeta('robots', 'noindex,nofollow')
const restoreReferrer = applyMeta('referrer', 'no-referrer')
return () => {
document.title = previousTitle
restoreRobots()
restoreReferrer()
}
}, [])
useEffect(() => {
let cancelled = false
async function load() {
if (!token) {
setLoading(false) setLoading(false)
setLoadError({
code: 'material_link_not_found',
message: '链接无效,请确认链接是否完整',
})
return return
} }
setLoading(true) if (!options.silent) setLoading(true)
setSubmitted(false)
try { try {
const response = await fetchCollectMaterialLink(token) const response = await fetchCollectMaterialLink(code)
if (cancelled) return if (seq !== requestSeqRef.current) return
const orders = response.data.orders || []
if (orders.length === 0) {
setInfo(null)
setLoadError({ code: 'material_link_not_found', message: NOT_FOUND_MESSAGE })
return
}
setInfo(response.data) setInfo(response.data)
setLoadError(null) setLoadError(null)
setScreenshots(response.data.screenshots || []) setScreenshotsByOrder((previous) => {
form.resetFields() // 只保留仍可提交商品的本地截图,避免刷新后覆盖用户刚上传的图片;
form.setFieldsValue(response.data.values || {}) // 不可提交商品不再展示资料,直接丢弃。
const next: Record<number, UploadedFile[]> = {}
for (const order of orders) {
if (!order.canSubmit) continue
next[order.workOrderId] = previous[order.workOrderId] ?? order.screenshots ?? []
}
return next
})
} catch (error) { } catch (error) {
if (cancelled) return if (seq !== requestSeqRef.current) return
setInfo(null) setInfo(null)
setLoadError({ setLoadError({
code: resolveErrorCode(error), code: resolveErrorCode(error),
message: resolveErrorMessage(error), message: resolveErrorMessage(error) || NOT_FOUND_MESSAGE,
}) })
} finally { } finally {
if (!cancelled) setLoading(false) if (seq === requestSeqRef.current && !options.silent) setLoading(false)
} }
} },
[code],
)
void load() useEffect(() => {
return () => { void loadInfo()
cancelled = true }, [loadInfo])
}
}, [form, token])
async function handleSubmit(values: Record<string, string>) { async function handleSubmit(order: CollectMaterialLinkOrder, values: Record<string, string>) {
if (!token) return if (!code) return
setSubmitting(true) // 多工单时用户可能连点不同卡片;前端只允许一个提交在途,避免列表状态互相覆盖。
if (submittingRef.current) return
submittingRef.current = true
setSubmittingWorkOrderId(order.workOrderId)
try { try {
await submitCollectMaterialLink(token, { fields: values, screenshots }) await submitCollectMaterialLink(code, {
setSubmitted(true) workOrderId: order.workOrderId,
fields: values,
screenshots: screenshotsByOrder[order.workOrderId] ?? order.screenshots ?? [],
})
message.success('资料已提交,订单已进入待分配')
await loadInfo({ silent: true })
} catch (error) { } catch (error) {
const code = resolveErrorCode(error) const errorCode = resolveErrorCode(error)
if (
code === 'material_link_used' ||
code === 'material_link_expired' ||
code === 'material_link_revoked' ||
code === 'material_link_not_found' ||
code === 'material_link_order_status_invalid'
) {
setInfo(null)
setLoadError({ code, message: resolveErrorMessage(error) })
return
}
message.error(resolveErrorMessage(error)) message.error(resolveErrorMessage(error))
// 状态类错误说明工单已被并发提交、被客服重置或流转到其他状态:
// 以服务端状态为准静默刷新,页面切换成只读卡片而不是整页报错。
if (
errorCode === 'material_link_already_submitted' ||
errorCode === 'material_link_order_status_invalid' ||
errorCode === 'material_link_work_order_invalid' ||
errorCode === 'material_link_not_found'
) {
await loadInfo({ silent: true })
}
} finally { } finally {
setSubmitting(false) submittingRef.current = false
setSubmittingWorkOrderId(0)
} }
} }
@@ -176,115 +187,106 @@ export default function CollectMaterialLinkPage() {
{loading ? ( {loading ? (
<div className="collect-link-state"> <div className="collect-link-state">
<Spin indicator={<LoadingOutlined spin />} size="large" /> <Spin indicator={<LoadingOutlined spin />} size="large" />
<Text type="secondary">正在读取补资料链接...</Text> <Text type="secondary">正在读取订单资料...</Text>
</div> </div>
) : submitted ? (
<Result
status="success"
title="资料已提交"
subTitle="链接已失效,如需修改资料,请联系客服重新获取。"
/>
) : loadError ? ( ) : loadError ? (
loadError.code === 'material_link_used' ? ( <Result
<Result status="warning"
icon={<CheckCircleOutlined style={{ color: '#16a34a' }} />} title={resolveErrorTitle(loadError.code)}
title="资料已提交" subTitle={loadError.message || NOT_FOUND_MESSAGE}
subTitle="该链接已经使用过;如需再次修改资料,请联系客服重新获取链接。" extra={
/> <Link to="/supplement">
) : ( <Button>重新输入订单号</Button>
<Result </Link>
status="warning" }
title={resolveErrorTitle(loadError.code)} />
subTitle={loadError.message || '请联系客服重新获取链接'}
/>
)
) : info ? ( ) : info ? (
<Space direction="vertical" size={16} className="full-width"> <Space direction="vertical" size={16} className="full-width">
<div> <div>
<Title level={3} className="collect-link-title"> <Title level={3} className="collect-link-title">
订单资料补充 订单资料补充
</Title> </Title>
<Text type="secondary">请补充以下资料,提交后客服会尽快处理。</Text> <Text type="secondary">
{info.pendingCount > 0
? '请补充以下资料,提交后客服会尽快处理。'
: '以下为该订单当前的资料状态,如需修改请联系客服。'}
</Text>
</div> </div>
<div className="collect-link-meta"> {info.pendingCount > 1 ? (
<div> <Alert
<span>商品</span> type="info"
<strong>{info.order.productName || '-'}</strong> showIcon
</div> message={`当前订单有 ${info.pendingCount} 个待完善商品,请逐个提交`}
<div> description="每个商品的资料仅可提交一次,提交成功后该商品进入待分配。"
<span>工单号</span> />
<strong>{info.order.workOrderNo || '-'}</strong> ) : null}
</div>
<div>
<span>订单号</span>
<strong>{info.order.platformOrderId || '-'}</strong>
</div>
<div>
<span>有效期至</span>
<strong>{formatDateTime(info.expiresAt)}</strong>
</div>
</div>
<Alert {info.pendingCount === 0 ? (
type="warning" <Alert type="info" showIcon message="该订单当前不可修改资料,如需修改请联系客服" />
showIcon ) : null}
message="链接仅可提交一次"
description="提交成功后链接立即失效;如需再次修改资料,请联系客服重新获取链接。"
/>
<Form form={form} layout="vertical" onFinish={handleSubmit}> {info.orders.map((order) => (
{info.fields.map((field) => ( <Card
<Form.Item key={order.workOrderId}
key={field.key} className="collect-link-order-card"
name={field.key} size="small"
label={ title={order.productName || '订单商品'}
<Space size={6}> extra={<Tag color={resolveStatusColor(order.status)}>{order.statusLabel}</Tag>}
<span>{field.label}</span> >
{field.required ? <Tag color="orange">必填</Tag> : <Tag>选填</Tag>} <Space direction="vertical" size={12} className="full-width">
</Space> <div className="collect-link-meta">
} <div>
rules={ <span>工单号</span>
field.required <strong>{order.workOrderNo || '-'}</strong>
? [{ required: true, whitespace: true, message: `请填写${field.label}` }] </div>
: undefined <div>
} <span>订单号</span>
> <strong>{order.platformOrderId || '-'}</strong>
{field.type === 'select' && (field.options || []).length > 0 ? ( </div>
<Radio.Group </div>
options={(field.options || []).map((option) => ({
label: option, {order.canSubmit ? (
value: option, <>
}))} {info.pendingCount === 1 ? (
/> <Alert
type="warning"
showIcon
message="该商品资料仅可提交一次"
description="提交成功后该商品进入待分配,不能再修改;如需修改请联系客服。"
/>
) : null}
<MaterialLinkOrderForm
order={order}
code={code}
screenshots={
screenshotsByOrder[order.workOrderId] ?? order.screenshots ?? []
}
submitting={submittingWorkOrderId === order.workOrderId}
disabled={submittingWorkOrderId !== 0}
onScreenshotsChange={(files) =>
setScreenshotsByOrder((previous) => ({
...previous,
[order.workOrderId]: files,
}))
}
onSubmit={(values) => handleSubmit(order, values)}
/>
</>
) : ( ) : (
<Input autoComplete="off" placeholder={`请输入${field.label}`} /> <Alert
type={order.blockedReason === 'already_submitted' ? 'info' : 'warning'}
showIcon
message={order.message || '当前不能修改资料,如需修改请联系客服。'}
/>
)} )}
</Form.Item> </Space>
))} </Card>
))}
<Form.Item label="买家主页截图">
<ImageUpload
scene="collect-material"
scope="collect"
maxCount={5}
showPasteHint
captureGlobalPaste
value={screenshots}
onChange={setScreenshots}
uploader={(file, scene) => uploadCollectMaterialLinkFile(file, scene, token)}
/>
</Form.Item>
<div className="collect-link-actions">
<Button type="primary" size="large" htmlType="submit" loading={submitting}>
提交资料
</Button>
</div>
</Form>
<Text type="secondary" className="collect-link-footnote"> <Text type="secondary" className="collect-link-footnote">
本页面仅用于补充订单资料,请勿将链接转发给他人。 本页面仅用于补充订单资料,请妥善保管订单号。
</Text> </Text>
</Space> </Space>
) : null} ) : null}
@@ -292,3 +294,83 @@ export default function CollectMaterialLinkPage() {
</main> </main>
) )
} }
type MaterialLinkOrderFormProps = {
order: CollectMaterialLinkOrder
code: string
screenshots: UploadedFile[]
submitting: boolean
disabled: boolean
onScreenshotsChange: (files: UploadedFile[]) => void
onSubmit: (values: Record<string, string>) => void
}
function MaterialLinkOrderForm({
order,
code,
screenshots,
submitting,
disabled,
onScreenshotsChange,
onSubmit,
}: MaterialLinkOrderFormProps) {
return (
<Form layout="vertical" initialValues={order.values || {}} onFinish={onSubmit}>
{(order.fields ?? []).map((field) => (
<Form.Item
key={field.key}
name={field.key}
label={
<Space size={6}>
<span>{field.label}</span>
{field.required ? <Tag color="orange">必填</Tag> : <Tag>选填</Tag>}
</Space>
}
rules={
field.required
? [{ required: true, whitespace: true, message: `请填写${field.label}` }]
: undefined
}
>
{field.type === 'select' && (field.options || []).length > 0 ? (
<Radio.Group
options={(field.options || []).map((option) => ({
label: option,
value: option,
}))}
/>
) : (
<Input autoComplete="off" placeholder={`请输入${field.label}`} />
)}
</Form.Item>
))}
<Form.Item label="买家主页截图">
<ImageUpload
scene="collect-material"
scope="collect"
maxCount={5}
showPasteHint
captureGlobalPaste
value={screenshots}
onChange={onScreenshotsChange}
uploader={(file, scene) =>
uploadCollectMaterialLinkFile(file, scene, code, order.workOrderId)
}
/>
</Form.Item>
<div className="collect-link-actions">
<Button
type="primary"
size="large"
htmlType="submit"
loading={submitting}
disabled={disabled}
>
提交资料
</Button>
</div>
</Form>
)
}
@@ -0,0 +1,49 @@
import { useEffect } from 'react'
/**
* 公开补资料页共用的 document.title / robots / referrer 设置。
*
* 入口页和补资料页都是可被直接访问的公开路径,必须禁止搜索引擎收录,
* 并避免平台订单号通过 referrer 泄漏给第三方。
*/
export function useCollectLinkPageMeta(title: string) {
useEffect(() => {
const previousTitle = document.title
document.title = title
function applyMeta(name: string, content: string) {
const existing = document.querySelector<HTMLMetaElement>(`meta[name="${name}"]`)
const previous = existing?.getAttribute('content') ?? null
let created: HTMLMetaElement | null = null
if (existing) {
existing.setAttribute('content', content)
} else {
created = document.createElement('meta')
created.setAttribute('name', name)
created.setAttribute('content', content)
document.head.appendChild(created)
}
return () => {
if (created) {
created.remove()
} else if (existing) {
if (previous === null) {
existing.removeAttribute('content')
} else {
existing.setAttribute('content', previous)
}
}
}
}
const restoreRobots = applyMeta('robots', 'noindex,nofollow')
const restoreReferrer = applyMeta('referrer', 'no-referrer')
return () => {
document.title = previousTitle
restoreRobots()
restoreReferrer()
}
}, [title])
}
@@ -770,8 +770,19 @@ export function submitAdminWorkOrderMaterial(
} }
export function createAdminWorkOrderMaterialLink(workOrderId: number) { export function createAdminWorkOrderMaterialLink(workOrderId: number) {
return apiPost<{ token: string; expiresAt: string; reused: boolean }>( return apiPost<{
`/api/v1/admin/worker-platform/orders/${workOrderId}/material-link`, token: string
/** 公开 URL 使用的平台订单号;旧后端可能没有该字段,前端仅用于滚动发布兜底。 */
platformOrderId?: string
expiresAt: string
reused: boolean
}>(`/api/v1/admin/worker-platform/orders/${workOrderId}/material-link`)
}
/** 客服重置补资料:仅「待分配 + 未指派 + 无份额 + 未发布」可重置回待完善。 */
export function resetAdminWorkOrderMaterialStatus(workOrderId: number) {
return apiPost<{ order: WorkOrder }>(
`/api/v1/admin/worker-platform/orders/${workOrderId}/reset-material`,
) )
} }
+10 -4
View File
@@ -22,16 +22,22 @@ export async function uploadFile(file: File, scene: string, scope: UploadScope)
/** /**
* 一次性补资料链接的截图上传。 * 一次性补资料链接的截图上传。
* *
* 与公开 collect/upload 的区别:先把 token 放在路径里,后端会校验链接 * 与公开 collect/upload 的区别:路径里带平台订单号,多工单时再带 workOrderId;
* 是否仍可用;链接已使用/过期时不会落文件。 * 后端会校验对应链接是否仍可用,链接已使用/过期时不会落文件。
*/ */
export async function uploadCollectMaterialLinkFile(file: File, scene: string, token: string) { export async function uploadCollectMaterialLinkFile(
file: File,
scene: string,
code: string,
workOrderId?: number,
) {
const uploadTarget = await optimizeImageForUpload(file, scene) const uploadTarget = await optimizeImageForUpload(file, scene)
const form = new FormData() const form = new FormData()
form.append('file', uploadTarget) form.append('file', uploadTarget)
form.append('scene', scene) form.append('scene', scene)
const query = workOrderId ? `?workOrderId=${encodeURIComponent(String(workOrderId))}` : ''
const response = await apiPostForm<{ file: UploadedFile }>( const response = await apiPostForm<{ file: UploadedFile }>(
`/api/v1/collect/link/${encodeURIComponent(token)}/upload`, `/api/v1/collect/link/${encodeURIComponent(code)}/upload${query}`,
form, form,
) )
return response.data.file return response.data.file
+5 -4
View File
@@ -381,19 +381,20 @@ export function submitCollectOrder(payload: {
) )
} }
export function fetchCollectMaterialLink(token: string) { export function fetchCollectMaterialLink(code: string) {
return apiGet<CollectMaterialLinkInfo>(`/api/v1/collect/link/${encodeURIComponent(token)}`) return apiGet<CollectMaterialLinkInfo>(`/api/v1/collect/link/${encodeURIComponent(code)}`)
} }
export function submitCollectMaterialLink( export function submitCollectMaterialLink(
token: string, code: string,
payload: { payload: {
workOrderId?: number
fields: Record<string, string> fields: Record<string, string>
screenshots?: UploadedFile[] screenshots?: UploadedFile[]
}, },
) { ) {
return apiPost<CollectMaterialLinkSubmitResult>( return apiPost<CollectMaterialLinkSubmitResult>(
`/api/v1/collect/link/${encodeURIComponent(token)}/submit`, `/api/v1/collect/link/${encodeURIComponent(code)}/submit`,
payload, payload,
) )
} }
+5
View File
@@ -499,6 +499,11 @@
padding: 28px; padding: 28px;
} }
/* 一单多工单时,内层商品卡片比外层容器更紧凑 */
.collect-link-order-card .ant-card-body {
padding: 16px;
}
.collect-link-title { .collect-link-title {
margin: 0 0 4px !important; margin: 0 0 4px !important;
} }
+29 -10
View File
@@ -647,6 +647,8 @@ export type WorkOrder = {
canPin: boolean canPin: boolean
canUnpublish: boolean canUnpublish: boolean
canUpdateMaterial: boolean canUpdateMaterial: boolean
/** 待分配且未指派、无份额、未发布时,客服可以把补资料状态重置回待完善。 */
canResetMaterial?: boolean
canAccept: boolean canAccept: boolean
canMarkProblem: boolean canMarkProblem: boolean
canDelete: boolean canDelete: boolean
@@ -867,22 +869,39 @@ export type CollectLookupResponse = {
pendingCount: number pendingCount: number
} }
/** 一次性补资料链接的公开只读信息(不含价格/押金/打手等后台字段)。 */ export type CollectMaterialLinkBlockedReason =
export type CollectMaterialLinkInfo = { | 'already_submitted'
order: { | 'status'
workOrderNo: string | 'assigned'
platformOrderId: string | 'shares'
productName: string | ''
status: string
} /** 公开补资料页的单个工单;只有 canSubmit=true 时才有字段/已填值/截图。 */
fields: CollectField[] export type CollectMaterialLinkOrder = {
workOrderId: number
workOrderNo: string
platformOrderId: string
productName: string
status: string
statusLabel: string
canSubmit: boolean
blockedReason: CollectMaterialLinkBlockedReason
message: string
fields?: CollectField[]
values?: Record<string, string> values?: Record<string, string>
screenshots?: UploadedFile[] screenshots?: UploadedFile[]
expiresAt: string }
/** 按平台订单号读取到的补资料信息;一单多工单时 orders 会有多条。 */
export type CollectMaterialLinkInfo = {
platformOrderId: string
orders: CollectMaterialLinkOrder[]
pendingCount: number
} }
export type CollectMaterialLinkSubmitResult = { export type CollectMaterialLinkSubmitResult = {
complete: boolean complete: boolean
workOrderId: number
order: { order: {
workOrderNo: string workOrderNo: string
platformOrderId: string platformOrderId: string
+39 -8
View File
@@ -1,9 +1,10 @@
/** /**
* 一次性补资料链接的路径解析。 * 一次性补资料链接的路径解析。
* *
* 公开链接形如:`https://<域名>/supplement/<token>`,与后台 HashRouter 完全隔离。 * 公开链接有两种形态:
* 命名空间判定用于路由分发:`/supplement` 及子路径整段交给公开页, * - `https://<域名>/supplement/`:输入平台订单号;
* 避免落到后台路由或打手端 SPA。 * - `https://<域名>/supplement/<平台订单号>`:直接打开对应订单的补资料页。
* 与后台 HashRouter 完全隔离。
*/ */
export function isCollectMaterialLinkPath(pathname: unknown): boolean { export function isCollectMaterialLinkPath(pathname: unknown): boolean {
@@ -11,14 +12,44 @@ export function isCollectMaterialLinkPath(pathname: unknown): boolean {
} }
/** /**
* 只认 `/supplement/<一段 token>`: * 只认 `/supplement/<一段 code>`:
* - `/supplement/abc` 命中,结尾多余斜杠容忍; * - `/supplement/abc` 命中,结尾多余斜杠容忍;
* - `/supplement`、`/supplement/a/b` 不命中(页面展示链接无效)。 * - `/supplement`、`/supplement/a/b` 不命中(由入口页/页面自己展示无效)。
*/ */
export function resolveCollectMaterialLinkToken(pathname: unknown): string { export function resolveCollectMaterialLinkCode(pathname: unknown): string {
const segments = splitPathSegments(pathname) const segments = splitPathSegments(pathname)
if (segments.length !== 2 || segments[0] !== 'supplement') return '' if (segments.length !== 2 || segments[0] !== 'supplement') return ''
return decodeTokenSegment(segments[1]) return decodePathSegment(segments[1])
}
/** 统一拼补资料链接;origin 结尾多余斜杠会被去掉。 */
export function buildCollectMaterialLinkUrl(origin: unknown, code: unknown): string {
const base = String(origin ?? '')
.trim()
.replace(/\/+$/, '')
const normalized = String(code ?? '').trim()
if (!base || !normalized) return ''
return `${base}/supplement/${encodeURIComponent(normalized)}`
}
/**
* 入口页输入归一化:去空格;如果用户粘贴了完整 `/supplement/<订单号>` 链接,
* 自动提取最后一段,避免把整条 URL 当成订单号。
*/
export function normalizeOrderNoInput(value: unknown): string {
const raw = String(value ?? '').trim()
if (!raw) return ''
const marker = '/supplement/'
const index = raw.indexOf(marker)
if (index < 0) return raw
const segment = raw
.slice(index + marker.length)
.split(/[?#]/)[0]
.replace(/\/+$/, '')
.trim()
return decodePathSegment(segment)
} }
function splitPathSegments(pathname: unknown): string[] { function splitPathSegments(pathname: unknown): string[] {
@@ -28,7 +59,7 @@ function splitPathSegments(pathname: unknown): string[] {
return normalized.split(/[?#]/)[0].replace(/\/+$/, '').split('/').filter(Boolean) return normalized.split(/[?#]/)[0].replace(/\/+$/, '').split('/').filter(Boolean)
} }
function decodeTokenSegment(segment: string): string { function decodePathSegment(segment: string): string {
try { try {
return decodeURIComponent(segment) return decodeURIComponent(segment)
} catch { } catch {
+47 -13
View File
@@ -2,31 +2,65 @@ import assert from 'node:assert/strict'
import test from 'node:test' import test from 'node:test'
import { import {
buildCollectMaterialLinkUrl,
isCollectMaterialLinkPath, isCollectMaterialLinkPath,
resolveCollectMaterialLinkToken, normalizeOrderNoInput,
resolveCollectMaterialLinkCode,
} from '../src/utils/collect-link.ts' } from '../src/utils/collect-link.ts'
test('补资料链接:/supplement/<token> 命中并解析 token', () => { test('补资料链接:/supplement/<订单号> 命中并解析 code', () => {
assert.equal(isCollectMaterialLinkPath('/supplement/abc123'), true) assert.equal(isCollectMaterialLinkPath('/supplement/2630501851236676'), true)
assert.equal(resolveCollectMaterialLinkToken('/supplement/abc123'), 'abc123') assert.equal(resolveCollectMaterialLinkCode('/supplement/2630501851236676'), '2630501851236676')
})
test('补资料链接:入口页 /supplement 命中命名空间但没有 code', () => {
assert.equal(isCollectMaterialLinkPath('/supplement'), true)
assert.equal(isCollectMaterialLinkPath('/supplement/'), true)
assert.equal(resolveCollectMaterialLinkCode('/supplement'), '')
assert.equal(resolveCollectMaterialLinkCode('/supplement/'), '')
}) })
test('补资料链接:容忍结尾斜杠、查询串与 hash', () => { test('补资料链接:容忍结尾斜杠、查询串与 hash', () => {
assert.equal(resolveCollectMaterialLinkToken('/supplement/abc123/'), 'abc123') assert.equal(resolveCollectMaterialLinkCode('/supplement/2630501851236676/'), '2630501851236676')
assert.equal(resolveCollectMaterialLinkToken('/supplement/abc123?from=chat'), 'abc123') assert.equal(
assert.equal(resolveCollectMaterialLinkToken('/supplement/abc123#top'), 'abc123') resolveCollectMaterialLinkCode('/supplement/2630501851236676?from=chat'),
'2630501851236676',
)
assert.equal(
resolveCollectMaterialLinkCode('/supplement/2630501851236676#top'),
'2630501851236676',
)
}) })
test('补资料链接:命名空间命中但缺少 token 时返回空串', () => { test('补资料链接:多段路径不解析 code', () => {
assert.equal(isCollectMaterialLinkPath('/supplement'), true) assert.equal(resolveCollectMaterialLinkCode('/supplement/a/b'), '')
assert.equal(isCollectMaterialLinkPath('/supplement/'), true)
assert.equal(resolveCollectMaterialLinkToken('/supplement'), '')
assert.equal(resolveCollectMaterialLinkToken('/supplement/a/b'), '')
}) })
test('补资料链接:其它路径不命中', () => { test('补资料链接:其它路径不命中', () => {
for (const pathname of ['/', '/claim/abc', '/collect', '/supplementx/abc', '']) { for (const pathname of ['/', '/claim/abc', '/collect', '/supplementx/abc', '']) {
assert.equal(isCollectMaterialLinkPath(pathname), false, pathname) assert.equal(isCollectMaterialLinkPath(pathname), false, pathname)
assert.equal(resolveCollectMaterialLinkToken(pathname), '', pathname) assert.equal(resolveCollectMaterialLinkCode(pathname), '', pathname)
} }
}) })
test('补资料链接:URL 构建去掉 origin 结尾斜杠并编码', () => {
assert.equal(
buildCollectMaterialLinkUrl('https://ks.khhao.com/', '2630501851236676'),
'https://ks.khhao.com/supplement/2630501851236676',
)
assert.equal(
buildCollectMaterialLinkUrl('https://ks.khhao.com', 'abc/def'),
'https://ks.khhao.com/supplement/abc%2Fdef',
)
assert.equal(buildCollectMaterialLinkUrl('', 'abc'), '')
assert.equal(buildCollectMaterialLinkUrl('https://ks.khhao.com', ''), '')
})
test('补资料入口:输入归一化支持订单号与完整链接', () => {
assert.equal(normalizeOrderNoInput(' 2630501851236676 '), '2630501851236676')
assert.equal(
normalizeOrderNoInput('https://ks.khhao.com/supplement/2630501851236676?from=chat#top'),
'2630501851236676',
)
assert.equal(normalizeOrderNoInput(''), '')
})