add:新增同一个工单同一人可以多次拼单

This commit is contained in:
2026-10-23 15:14:07 +08:00
parent bfd2325ac5
commit 1d5615f1ae
18 changed files with 2996 additions and 128 deletions
@@ -66,8 +66,25 @@ test('大厅候选集(buildHallCandidateIdsSql)不再聚合整表拼单', as
test('全仓库只允许保留一处「整表拼单聚合」,且必须是无打手范围的全表统计分支', async () => {
const raw = await readRepoSource()
const source = stripComments(raw)
// 我的订单概览里按「工单 + 份额状态」聚合金额,必须限定到当前打手;
// 它不是整表聚合,先单独摘出来校验,避免被下面的全表聚合守卫误判。
const shareStatusStart = source.indexOf('share_status_rows AS (')
const shareStatusEnd = source.indexOf('order_status_rows AS (')
const workerShareAggregation =
shareStatusStart >= 0 && shareStatusEnd > shareStatusStart
? source.slice(shareStatusStart, shareStatusEnd)
: ''
assert.ok(workerShareAggregation, '缺少我的订单概览的份额状态聚合')
const sourceWithoutWorkerShareAggregation =
shareStatusStart >= 0 && shareStatusEnd > shareStatusStart
? source.slice(0, shareStatusStart) + source.slice(shareStatusEnd)
: source
const globalAggregations = [
...source.matchAll(/GROUP BY\s+wos\.work_order_id|GROUP BY\s+work_order_id/g),
...sourceWithoutWorkerShareAggregation.matchAll(
/GROUP BY\s+wos\.work_order_id|GROUP BY\s+work_order_id/g,
),
]
assert.equal(
@@ -78,15 +95,28 @@ test('全仓库只允许保留一处「整表拼单聚合」,且必须是无
)
const onlyRemaining = globalAggregations[0]!
const around = source.slice(Math.max(0, onlyRemaining.index - 900), onlyRemaining.index + 200)
const around = sourceWithoutWorkerShareAggregation.slice(
Math.max(0, (onlyRemaining.index ?? 0) - 900),
(onlyRemaining.index ?? 0) + 200,
)
assert.ok(
around.includes('operational_share_summary'),
'保留的那处整表聚合不在 operational_share_summary 分支里,需要确认是否有意为之',
)
// 注释在 stripComments 里被去掉了,所以断言理由时用原文
const rawIndex = raw.indexOf('GROUP BY wos.work_order_id')
const rawAround = raw.slice(Math.max(0, rawIndex - 1200), rawIndex + 200)
// 注释在 stripComments 里被去掉了,所以断言理由时用原文。
// 注意:raw 里前面还有 share_status_rows 的工单内聚合,必须找 operational 那一处。
const rawMatches = [...raw.matchAll(/GROUP BY\s+wos\.work_order_id/g)]
const operationalRaw = rawMatches.find((match) =>
raw
.slice(Math.max(0, (match.index ?? 0) - 1200), (match.index ?? 0) + 200)
.includes('operational_share_summary'),
)
assert.ok(operationalRaw, '找不到 operational_share_summary 的整表聚合')
const rawAround = raw.slice(
Math.max(0, (operationalRaw.index ?? 0) - 1200),
(operationalRaw.index ?? 0) + 200,
)
assert.ok(
rawAround.includes('无打手范围时一次聚合全部拼单'),
'保留理由(无打手范围时一次聚合优于逐行关联)必须写在注释里,避免被误删',
@@ -105,18 +135,67 @@ test('我的订单的份额关联按工单取一条,避免多份额把列表
test('我的订单概览按工单计数,金额仍按份额求和', async () => {
const source = stripComments(await readRepoSource())
const start = source.indexOf('worker_base AS (')
assert.ok(start >= 0, '缺少我的订单概览的 worker_base CTE')
const start = source.indexOf('order_flags AS (')
assert.ok(start >= 0, '缺少我的订单概览的 order_flags CTE')
const block = source.slice(start, start + 2200)
assert.match(block, /LEFT JOIN LATERAL \(/, '概览的份额关联没有按工单取一条')
assert.match(block, /share_reward_total/, '概览没有汇总多份份额的奖励金额')
const block = source.slice(start, start + 4200)
assert.match(block, /share_status_rows AS \(/, '概览没有按份额状态拆分金额')
assert.match(block, /order_status_rows AS \(/, '概览没有聚合成工单状态行')
assert.match(block, /SUM\(wos\.share_reward\)/, '概览没有汇总份额奖励')
assert.match(
block,
/GROUP BY wos\.work_order_id, wos\.status/,
'份额金额没有按「工单 + 份额状态」聚合',
)
assert.ok(
!block.includes('LEFT JOIN work_order_shares wos'),
'概览仍在直接 JOIN 份额表:同一工单 3 份会被统计成 3 单',
)
})
test('多份额混合状态:任一状态命中即可出现在对应页签', async () => {
const source = stripComments(await readRepoSource())
assert.ok(source.includes("ws_filter.status = 'submitted'"), '待验收筛选没有检查任一份额')
assert.ok(source.includes("'pending_acceptance' = ANY"), '待验收状态没有参与任一份额匹配')
})
/**
* 概览与列表必须是同一把尺子:列表里「待审核取消申请/未处理反馈」只把进行中的份额
* 归入问题单,已提交待验收的份额照旧留在待验收。
* 概览旧写法把这类工单的份额整体排除、再由第二分支记成问题单,于是出现
* 「问题单卡片有数字、点进去列表是空的」「待验收列表有单、卡片不计数」。
*/
test('概览与列表同口径:待处理申请只把进行中份额归问题单', async () => {
const source = stripComments(await readRepoSource())
const shareStart = source.indexOf('share_status_rows AS (')
assert.ok(shareStart >= 0, '缺少 share_status_rows CTE')
const shareBlock = source.slice(shareStart, shareStart + 1600)
assert.match(
shareBlock,
/WHEN wos\.status = 'joined' AND f\.has_pending_handling THEN 'problem'/,
'待处理申请只应把进行中的份额归问题单',
)
assert.ok(
!shareBlock.includes('AND NOT f.has_pending_handling'),
'概览不能整体排除有待处理申请的份额,否则已提交待验收会从页签里消失',
)
const orderStart = source.indexOf('order_status_rows AS (', shareStart)
assert.ok(orderStart > shareStart, '缺少 order_status_rows CTE')
const orderBlock = source.slice(orderStart, orderStart + 1600)
assert.ok(
!/OR f\.has_pending_handling\b/.test(orderBlock),
'第二分支不能无条件把有待处理申请的工单塞进问题单(会产生重复/错页签计数)',
)
assert.match(
orderBlock,
/WHEN f\.has_pending_handling AND f\.wo_status = 'in_progress'/,
'无份额的指派单也要按「进行中才归问题单」判定',
)
})
test('超时统计按工单去重,不按份额/事件行数累加', async () => {
const source = stripComments(await readRepoSource())
@@ -223,25 +223,29 @@ export function workerOrderBaseStatusExpression(workerShareAlias = 'worker_share
* 传入 workerId 时,代练中但存在待审核取消申请或未处理反馈的订单归入问题单,
* 客服驳回/解决后自动回到代练中(计算型归类,无状态迁移)。
*/
export function workerOrderStatusExpression(workerId = 0, workerShareAlias = 'worker_share') {
const baseExpression = workerOrderBaseStatusExpression(workerShareAlias)
const normalizedWorkerId = Math.max(0, Math.floor(Number(workerId) || 0))
if (normalizedWorkerId <= 0) return baseExpression
const pendingHandlingExists = `(
function workerPendingHandlingExistsExpression(workerId: number): string {
return `(
EXISTS (
SELECT 1
FROM worker_order_cancel_requests wcr
WHERE wcr.work_order_id = wo.id
AND wcr.worker_id = ${normalizedWorkerId}
AND wcr.worker_id = ${workerId}
AND wcr.status = 'pending'
) OR EXISTS (
SELECT 1
FROM worker_order_feedbacks wf
WHERE wf.work_order_id = wo.id
AND wf.worker_id = ${normalizedWorkerId}
AND wf.worker_id = ${workerId}
AND wf.status = 'pending'
)
)`
}
export function workerOrderStatusExpression(workerId = 0, workerShareAlias = 'worker_share') {
const baseExpression = workerOrderBaseStatusExpression(workerShareAlias)
const normalizedWorkerId = Math.max(0, Math.floor(Number(workerId) || 0))
if (normalizedWorkerId <= 0) return baseExpression
const pendingHandlingExists = workerPendingHandlingExistsExpression(normalizedWorkerId)
const isTimeoutForMe = `(
(wo.assigned_worker_id IS DISTINCT FROM ${normalizedWorkerId})
AND COALESCE(${workerShareAlias}.status, '') NOT IN ('joined', 'submitted', 'accepted')
@@ -638,12 +642,12 @@ export async function getWorkerOrderOverview(workerId: number | string): Promise
WHERE timeout_ev.event_type LIKE 'timeout_%'
AND timeout_ev.payload_json->>'workerId' = $1::text
),
worker_base AS (
order_flags AS (
SELECT
wo.id,
wo.status AS wo_status,
wos.status AS wos_status,
wos.status IS NOT NULL AS is_worker_share,
wo.reward_amount,
wo.acceptance_json,
wo.assigned_worker_id = $1 AS is_assigned_to_me,
EXISTS (
SELECT 1 FROM work_order_events we
@@ -651,88 +655,92 @@ export async function getWorkerOrderOverview(workerId: number | string): Promise
AND we.event_type LIKE 'timeout_%'
AND we.payload_json->>'workerId' = $1::text
) AS has_timeout_for_me,
CASE
WHEN wos.status IS NOT NULL THEN wos.share_reward_total
WHEN wo.assigned_worker_id = $1 THEN wo.reward_amount
ELSE 0
END AS worker_settlement_amount,
wo.acceptance_json
(
EXISTS (
SELECT 1 FROM worker_order_cancel_requests wcr
WHERE wcr.work_order_id = wo.id
AND wcr.worker_id = $1
AND wcr.status = 'pending'
) OR EXISTS (
SELECT 1 FROM worker_order_feedbacks wf
WHERE wf.work_order_id = wo.id
AND wf.worker_id = $1
AND wf.status = 'pending'
)
) AS has_pending_handling,
COALESCE((
SELECT SUM(wos.share_reward)
FROM work_order_shares wos
WHERE wos.work_order_id = wo.id
AND wos.worker_id = $1
AND wos.status != 'cancelled'
), 0)::int AS share_reward_total,
EXISTS (
SELECT 1 FROM work_order_shares wos
WHERE wos.work_order_id = wo.id
AND wos.worker_id = $1
AND wos.status != 'cancelled'
) AS is_worker_share
FROM work_orders wo
INNER JOIN visible_orders vo ON vo.work_order_id = wo.id
LEFT JOIN LATERAL (
SELECT
(
SELECT w2.status
FROM work_order_shares w2
WHERE w2.work_order_id = wo.id
AND w2.worker_id = $1
AND w2.status != 'cancelled'
ORDER BY
CASE w2.status
WHEN 'joined' THEN 0
WHEN 'submitted' THEN 1
WHEN 'accepted' THEN 2
ELSE 3
END,
w2.created_at DESC,
w2.id DESC
LIMIT 1
) AS status,
COALESCE(SUM(wos.share_reward), 0)::int AS share_reward_total
FROM work_order_shares wos
WHERE wos.work_order_id = wo.id
AND wos.worker_id = $1
AND wos.status != 'cancelled'
) wos ON true
),
worker_orders AS (
share_status_rows AS (
SELECT
wos.work_order_id,
CASE
WHEN NOT is_assigned_to_me AND (NOT is_worker_share OR wos_status = 'cancelled' OR wos_status IS NULL) AND has_timeout_for_me
THEN 'open'
WHEN (
CASE
WHEN is_worker_share AND wo_status NOT IN ('accepted', 'cancelled', 'problem')
THEN CASE wos_status
WHEN 'joined' THEN 'in_progress'
WHEN 'submitted' THEN 'pending_acceptance'
WHEN 'accepted' THEN 'accepted'
WHEN 'cancelled' THEN 'cancelled'
ELSE wo_status
END
ELSE wo_status
END
) = 'in_progress' AND (
EXISTS (
SELECT 1
FROM worker_order_cancel_requests wcr
WHERE wcr.work_order_id = worker_base.id
AND wcr.worker_id = $1
AND wcr.status = 'pending'
) OR EXISTS (
SELECT 1
FROM worker_order_feedbacks wf
WHERE wf.work_order_id = worker_base.id
AND wf.worker_id = $1
AND wf.status = 'pending'
)
) THEN 'problem'
ELSE CASE
WHEN is_worker_share AND wo_status NOT IN ('accepted', 'cancelled', 'problem')
THEN CASE wos_status
WHEN 'joined' THEN 'in_progress'
WHEN 'submitted' THEN 'pending_acceptance'
WHEN 'accepted' THEN 'accepted'
WHEN 'cancelled' THEN 'cancelled'
ELSE wo_status
END
ELSE wo_status
END
-- 待审核取消申请/未处理反馈只把「进行中」的份额归入问题单;
-- 已提交待验收的份额必须留在待验收(列表筛选就是这么判的,
-- 这里若整体排除会出现「问题单有数字、点进去空列表」)。
WHEN wos.status = 'joined' AND f.has_pending_handling THEN 'problem'
WHEN wos.status = 'joined' THEN 'in_progress'
WHEN wos.status = 'submitted' THEN 'pending_acceptance'
WHEN wos.status = 'accepted' THEN 'accepted'
END AS status,
SUM(wos.share_reward)::int AS amount,
(ARRAY_AGG(wos.acceptance_json ORDER BY wos.id DESC))[1] AS acceptance_json
FROM work_order_shares wos
INNER JOIN order_flags f ON f.id = wos.work_order_id
WHERE wos.worker_id = $1
AND wos.status IN ('joined', 'submitted', 'accepted')
AND f.wo_status NOT IN ('accepted', 'cancelled', 'problem')
GROUP BY wos.work_order_id, wos.status, f.has_pending_handling
),
order_status_rows AS (
SELECT
work_order_id,
status,
amount,
acceptance_json,
is_worker_share,
worker_settlement_amount
FROM worker_base
TRUE AS is_worker_share
FROM share_status_rows
UNION ALL
SELECT
f.id AS work_order_id,
CASE
WHEN f.has_timeout_for_me
AND NOT f.is_assigned_to_me
AND NOT f.is_worker_share
THEN 'open'
WHEN f.wo_status IN ('accepted', 'cancelled', 'problem')
THEN f.wo_status
WHEN f.has_pending_handling AND f.wo_status = 'in_progress'
THEN 'problem'
ELSE f.wo_status
END AS status,
CASE
WHEN f.is_worker_share THEN f.share_reward_total
WHEN f.is_assigned_to_me THEN f.reward_amount
ELSE 0
END AS amount,
f.acceptance_json,
f.is_worker_share
FROM order_flags f
WHERE
f.wo_status IN ('accepted', 'cancelled', 'problem')
OR (f.has_timeout_for_me AND NOT f.is_assigned_to_me AND NOT f.is_worker_share)
OR NOT f.is_worker_share
)
SELECT
status,
@@ -742,7 +750,7 @@ export async function getWorkerOrderOverview(workerId: number | string): Promise
CASE
WHEN status IN ('in_progress', 'pending_acceptance', 'problem', 'accepted')
OR (status = 'open' AND is_worker_share)
THEN worker_settlement_amount
THEN amount
ELSE 0
END
),
@@ -755,7 +763,7 @@ export async function getWorkerOrderOverview(workerId: number | string): Promise
AND NULLIF(acceptance_json->>'evidenceDueAt', '')::timestamptz > NOW()
)::int AS vip_evidence_pending_count,
COALESCE(
SUM(worker_settlement_amount) FILTER (
SUM(amount) FILTER (
WHERE status = 'accepted'
AND acceptance_json->>'reviewMode' = 'vip_auto'
AND acceptance_json->>'evidenceStatus' = 'pending'
@@ -763,8 +771,41 @@ export async function getWorkerOrderOverview(workerId: number | string): Promise
),
0
)::int AS vip_evidence_pending_settlement_amount
FROM worker_orders
FROM order_status_rows
GROUP BY status
UNION ALL
SELECT
'all' AS status,
COUNT(DISTINCT work_order_id)::int AS order_count,
COALESCE(
SUM(
CASE
WHEN status IN ('in_progress', 'pending_acceptance', 'problem', 'accepted')
OR (status = 'open' AND is_worker_share)
THEN amount
ELSE 0
END
),
0
)::int AS settlement_amount,
COUNT(*) FILTER (
WHERE status = 'accepted'
AND acceptance_json->>'reviewMode' = 'vip_auto'
AND acceptance_json->>'evidenceStatus' = 'pending'
AND NULLIF(acceptance_json->>'evidenceDueAt', '')::timestamptz > NOW()
)::int AS vip_evidence_pending_count,
COALESCE(
SUM(amount) FILTER (
WHERE status = 'accepted'
AND acceptance_json->>'reviewMode' = 'vip_auto'
AND acceptance_json->>'evidenceStatus' = 'pending'
AND NULLIF(acceptance_json->>'evidenceDueAt', '')::timestamptz > NOW()
),
0
)::int AS vip_evidence_pending_settlement_amount
FROM order_status_rows
`,
[normalizedWorkerId],
)
@@ -1277,9 +1318,35 @@ export function buildWorkOrderWhere({
params.push(normalizedStatuses)
const statusesPlaceholder = `$${params.length}`
if (workerSharingId) {
filters.push(
`${workerOrderStatusExpression(workerSharingId)} = ANY(${statusesPlaceholder}::text[])`,
)
const representativeStatus = `${workerOrderStatusExpression(workerSharingId)} = ANY(${statusesPlaceholder}::text[])`
// 一个工单可能同时有「进行中 + 待验收」等多份不同状态的份额。
// 只看代表份额会让其中一种状态在页签里完全消失,所以只要任一份额命中就展示。
const anyShareStatus = `(
wo.status NOT IN ('accepted', 'cancelled', 'problem')
AND EXISTS (
SELECT 1
FROM work_order_shares ws_filter
WHERE ws_filter.work_order_id = wo.id
AND ws_filter.worker_id = ${workerSharingId}
AND ws_filter.status IN ('joined', 'submitted', 'accepted')
AND (
(
ws_filter.status = 'joined'
AND 'in_progress' = ANY(${statusesPlaceholder}::text[])
AND NOT ${workerPendingHandlingExistsExpression(workerSharingId)}
)
OR (
ws_filter.status = 'submitted'
AND 'pending_acceptance' = ANY(${statusesPlaceholder}::text[])
)
OR (
ws_filter.status = 'accepted'
AND 'accepted' = ANY(${statusesPlaceholder}::text[])
)
)
)
)`
filters.push(`(${representativeStatus} OR ${anyShareStatus})`)
} else {
filters.push(
`${useOperationalStatus ? adminOperationalStatusExpression('wo', 'operational_share_summary') : 'wo.status'} = ANY(${statusesPlaceholder}::text[])`,
@@ -0,0 +1,49 @@
import assert from 'node:assert/strict'
import { readFile } from 'node:fs/promises'
import test from 'node:test'
/**
* 回归:同一打手在同一拼单工单里有多份份额时,活跃接单数只应计 1 单。
*
* 之前 countWorkerActiveOrders 仍是「指派单数 + 拼单份额行数」直接相加,
* 打手资料页、抢普通单和后台指派会把同工单的多份拼单算成多单,提前撞接单上限。
* 事务内版本已经去重,这里把「事务内外共用同一段计数 SQL」钉死,防止再次分裂。
*/
async function readRepoSource() {
return readFile(new URL('./work-order-query-repo.ts', import.meta.url), 'utf8')
}
/** 去掉 SQL 行注释与 TS 行注释,避免注释里的旧写法被误判成代码。 */
function stripComments(source: string) {
return source
.split('\n')
.map((line) => line.replace(/--.*$/, '').replace(/\/\/.*$/, ''))
.join('\n')
}
test('活跃接单数按工单去重,同一工单多份拼单只占 1 个名额', async () => {
const source = stripComments(await readRepoSource())
const start = source.indexOf('const COUNT_WORKER_ACTIVE_ORDERS_SQL')
assert.ok(start >= 0, '缺少共享的活跃单计数 SQL 常量')
const sql = source.slice(start, start + 800)
assert.match(sql, /UNION/, '活跃单计数必须用 UNION 按工单去重')
assert.match(sql, /work_order_shares/, '活跃单计数必须包含拼单份额')
assert.match(sql, /swo\.status = 'open'/, '只统计母单仍在大厅的拼单份额')
})
test('事务内外共用同一段活跃单计数 SQL,避免口径分裂', async () => {
const source = stripComments(await readRepoSource())
for (const fn of ['countWorkerActiveOrders', 'countWorkerActiveOrdersWithClient']) {
const start = source.indexOf(`export async function ${fn}`)
assert.ok(start >= 0, `缺少函数 ${fn}`)
const block = source.slice(start, start + 700)
assert.ok(
block.includes('COUNT_WORKER_ACTIVE_ORDERS_SQL'),
`${fn} 没有复用共享的活跃单计数 SQL`,
)
assert.ok(!block.includes(') + ('), `${fn} 仍在把「指派单数 + 拼单份额行数」直接相加`)
}
})