Merge branch 'dev1023' into dev

解决 9 个冲突文件,并修复合并后遗留问题:

- 大厅候选集:采用 FIFO 窗口 + 全部置顶单 UNION(列表与抢单/拼单复核同源)
- 拼单份额:采用多次参与模型(每次参与 INSERT 新份额、requestId 幂等),
  取消后可重新参与;移除 HEAD 已废弃的单行 rejoin 逻辑与对应测试
- 工单迁移与成本中心 103–108 编号撞车:合并重写为
  109_work_order_share_participation / 110_work_order_hall_and_shop_indexes;
  临时库全量执行与重跑幂等验证通过(10 列、唯一键已删、7 个索引)
- 实时补丁:保留个性化字段、置顶重排、分页总数同步;补回 orderTimelineVisible 类型
- 打手大厅:保留 memo 组件化,移植「再拼一次」多份额按钮逻辑
- 全项目表格统一 PercentTable:WorkerOrderShareTable 改造

验证:backend typecheck/lint/check:sql/test(833 pass)、
frontend typecheck/lint/test(172 pass)/build 全绿。
This commit is contained in:
yml2213
2026-10-26 12:10:53 +08:00
94 changed files with 8991 additions and 744 deletions
@@ -3,9 +3,13 @@ import type { Response } from 'express'
import { WORK_ORDER_STATUS } from '../../domain/work-order-status.js'
import {
getLatestMaterialEventAtByOrderIds,
getPendingCancelRequestOrderIds,
getPendingFeedbackOrderIds,
getWorkerFinanceRequestById,
getWorkerUserById,
getWorkOrderById,
listWorkerTimeoutEventsByOrderIds,
listWorkerWorkOrderNotes,
listWorkerWorkOrderViews,
listWorkOrderShares,
@@ -23,11 +27,14 @@ import { mapAdminOrderListItem } from '../admin/admin-order-read-helpers.js'
import { mapAdminTaskListItem } from '../admin/admin-task-read-helpers.js'
import {
isWorkOrderSharingFilled,
isWorkerOrderVipEvidencePending,
mapFinanceRequest,
mapWorkOrderAdmin,
mapWorkOrderForHall,
mapWorkOrderForWorker,
mapWorkerUser,
pickWorkerRepresentativeShare,
resolveWorkerOrderStatusTabs,
resolveWorkerPermissions,
} from '../worker-platform/mappers.js'
import { invalidateWorkerMyOrderCaches } from '../worker-platform/worker-my-order-cache.js'
@@ -79,6 +86,24 @@ let nextSubscriberId = 1
let heartbeatTimer: NodeJS.Timeout | null = null
let publishQueue: Promise<void> = Promise.resolve()
/**
* 单次补发的事件上限,与 realtime_events 表保留的条数一致
* (见 realtime-event-repo 的清理策略:只保留最近 500 条)。
*/
export const REALTIME_REPLAY_EVENT_LIMIT = 500
/**
* 是否应该补发历史事件。
*
* 只有断线重连带上了 Last-Event-ID(游标 > 0)才补发。新连接(游标 = 0)**不补发**:
* 补发的每一条都携带「事件发生那一刻」的工单快照,直接打进刚由列表接口加载好的缓存,
* 会把已涨价/已拼满的订单覆盖回旧值(表现为「进大厅显示旧单价旧进度,点一次刷新才对」)。
*/
export function shouldReplayRealtimeEvents(lastEventId: number): boolean {
const normalized = Number(lastEventId)
return Number.isFinite(normalized) && normalized > 0
}
/** 建立后台实时事件流,事件快照用于前端定点更新缓存。 */
export function openAdminRealtimeStream(response: Response, lastEventId = 0) {
return openRealtimeStream(response, null, lastEventId)
@@ -249,6 +274,9 @@ async function publishWorkOrderSnapshots(input: {
hallChanged?: boolean
}) {
const workOrderId = Math.max(0, Number(input.workOrderId) || 0)
// 调用方显式给出的受影响打手必须同步失效:下面的快照生成要先查库,
// 若等都查完再失效,紧接着到达的「我的订单」请求会命中旧缓存(30s TTL)。
invalidateWorkerMyOrderCaches(input.workerIds || [])
const workOrder = await getWorkOrderById(workOrderId)
if (!workOrder) {
// 工单已不存在(删除):调用方传入的打手集合仍需失效缓存,
@@ -338,33 +366,124 @@ async function publishWorkOrderSnapshots(input: {
})
}
// 资料更新时间只与工单有关,提到循环外只查一次(参与人数多时省掉 N 次查询)。
const materialEventAt =
(await getLatestMaterialEventAtByOrderIds([workOrderId])).get(workOrderId) || ''
for (const workerId of new Set(
(input.workerIds || []).map((item) => Number(item)).filter(Boolean),
)) {
const worker = await getWorkerUserById(workerId)
if (!worker) continue
const [notes, views] = await Promise.all([
listWorkerWorkOrderNotes(workerId, [workOrderId]),
listWorkerWorkOrderViews(workerId, [workOrderId]),
])
const note = notes.find((item) => Number(item.work_order_id) === workOrderId)?.note || ''
const viewedAt =
views.find((item) => Number(item.work_order_id) === workOrderId)?.viewed_at || null
const share = shares.find((item) => Number(item.worker_id) === workerId)
// 同一打手在同一工单可能有多份份额(多次拼单),必须按「全部份额」还原这一行:
// 旧实现用 shares.find(...) 只取最早一条,多份额时会把可见性、个人状态、金额都算错,
// 还会让实时补丁把行从错误的页签删掉(打手端偶发「页签里没有数据」)。
const isAssignedWorker = Number(workOrder.assigned_worker_id || 0) === workerId
const workerOrderVisible = isAssignedWorker || Boolean(share && share.status !== 'cancelled')
const workerShares = shares.filter((item) => Number(item.worker_id) === workerId)
const activeWorkerShares = workerShares.filter((item) => item.status !== 'cancelled')
const representativeShare = pickWorkerRepresentativeShare(
activeWorkerShares.length > 0 ? activeWorkerShares : workerShares,
)
const cancelledShare = workerShares
.filter((item) => item.status === 'cancelled')
.sort((left, right) => Number(right.id) - Number(left.id))[0]
const isOwnerCurrently = isAssignedWorker || activeWorkerShares.length > 0
const workerOrderVisible = isOwnerCurrently
// 只有「已不持有该单」时才需要判断超时归属,避免给正常在办的单多打一次查询。
const needsTimeoutCheck = !isOwnerCurrently
const [notes, views, pendingCancelOrderIds, pendingFeedbackOrderIds, timeoutEventsByOrderId] =
await Promise.all([
listWorkerWorkOrderNotes(workerId, [workOrderId]),
listWorkerWorkOrderViews(workerId, [workOrderId]),
getPendingCancelRequestOrderIds(workerId, [workOrderId]),
getPendingFeedbackOrderIds(workerId, [workOrderId]),
needsTimeoutCheck
? listWorkerTimeoutEventsByOrderIds(workerId, [workOrderId])
: Promise.resolve(new Map<number, { createdAt: string }>()),
])
const note = notes.find((item) => Number(item.work_order_id) === workOrderId)?.note || ''
const view = views.find((item) => Number(item.work_order_id) === workOrderId)
const viewedAt = view?.viewed_at || null
const timeoutEvent = timeoutEventsByOrderId.get(workOrderId)
const isTimedOutForMe =
!isOwnerCurrently && Boolean(timeoutEvent || (cancelledShare && workOrder.sharing_enabled))
const timeoutNotice = isTimedOutForMe
? {
isTimedOut: true,
timedOutAt:
timeoutEvent?.createdAt ||
(workOrder.deadline_at ? String(workOrder.deadline_at) : null) ||
workOrder.updated_at,
warningMessage:
(workOrder.assigned_worker_id != null &&
Number(workOrder.assigned_worker_id) !== workerId) ||
['in_progress', 'submitted', 'pending_acceptance', 'accepted'].includes(
workOrder.status,
)
? '该订单已超时返回大厅并被其他打手接手,请勿继续在游戏内赠送!若私自继续赠送,造成的财产损失平台概不负责。'
: '该订单已超时退回抢单大厅,您已失去接单资格,请勿在游戏内赠送!若私自继续赠送,造成的财产损失平台概不负责。',
isTakenByOther:
(workOrder.assigned_worker_id != null &&
Number(workOrder.assigned_worker_id) !== workerId) ||
['in_progress', 'submitted', 'pending_acceptance', 'accepted'].includes(
workOrder.status,
),
}
: undefined
const hasPendingHandling =
pendingCancelOrderIds.has(workOrderId) || pendingFeedbackOrderIds.has(workOrderId)
const materialSeenAt = view?.material_seen_at || ''
const vipEvidencePending = isWorkerOrderVipEvidencePending(workOrder)
publishRealtimeEvent({
type: 'work_order.changed',
entityId: workOrderId,
scopes: ['worker_my_orders'],
operation: workerOrderVisible ? 'upsert' : 'remove',
data: mapWorkOrderForWorker(
workOrder,
resolveWorkerPermissions(worker),
share,
note,
viewedAt,
),
data: {
...mapWorkOrderForWorker(
workOrder,
resolveWorkerPermissions(worker),
representativeShare,
note,
viewedAt,
{
isTimedOutForMe,
...(timeoutNotice ? { timeoutNotice } : {}),
// 与列表一致:只带未取消份额,按 id DESC(参与先后倒序)
myShares: [...activeWorkerShares].sort(
(left, right) => Number(right.id) - Number(left.id),
),
},
),
/**
* 这张单在该打手「我的订单」里属于哪些状态页签。
* 多份额工单可同时属于代练中/待验收,单个 status 字段表达不了,前端据此判归属。
*/
workerStatuses: resolveWorkerOrderStatusTabs({
workOrderStatus: workOrder.status,
isAssignedWorker,
shares: workerShares,
hasPendingHandling,
hasTimeoutForMe: Boolean(timeoutEvent),
vipEvidencePending,
}),
problemMarked:
!isTimedOutForMe &&
(workOrder.status === WORK_ORDER_STATUS.PROBLEM ||
activeWorkerShares.some((share) => Boolean(share.problem_marked_at))),
pendingCancelRequest: !isTimedOutForMe && pendingCancelOrderIds.has(workOrderId),
pendingFeedback: !isTimedOutForMe && pendingFeedbackOrderIds.has(workOrderId),
materialUpdated:
!isTimedOutForMe &&
Boolean(materialEventAt) &&
(!materialSeenAt ||
new Date(materialEventAt).getTime() > new Date(materialSeenAt).getTime()),
},
workerIds: [workerId],
})
}
@@ -429,7 +548,10 @@ function openRealtimeStream(response: Response, workerId: number | null, lastEve
connectedAt: new Date().toISOString(),
lastEventId: Math.max(0, Number(lastEventId) || 0),
})
void replayEvents(subscriber, Math.max(0, Number(lastEventId) || 0))
// 新连接不补发历史事件,只有断线重连(带游标)才回放缺失的增量。
if (shouldReplayRealtimeEvents(lastEventId)) {
void replayEvents(subscriber, Number(lastEventId))
}
ensureHeartbeat()
response.on('close', () => {
@@ -439,7 +561,16 @@ function openRealtimeStream(response: Response, workerId: number | null, lastEve
}
async function replayEvents(subscriber: RealtimeSubscriber, lastEventId: number) {
const events = await listRealtimeEventsAfter(lastEventId)
const events = await listRealtimeEventsAfter(lastEventId, REALTIME_REPLAY_EVENT_LIMIT)
// 补发窗口被拿满 = 更早的事件已经从事件表里滚掉(断线太久)。
// 这时逐条套用旧快照只会把列表写回旧值,直接让客户端整体重拉一次。
if (events.length >= REALTIME_REPLAY_EVENT_LIMIT) {
writeEvent(subscriber, 'resync', {
headEventId: Number(events[events.length - 1]?.id || 0),
reason: 'replay_window_overflow',
})
return
}
for (const row of events) {
const event = mapStoredEvent(row)
if (event.eventId <= lastEventId || !isEventVisibleToSubscriber(event, subscriber)) continue
@@ -0,0 +1,56 @@
import assert from 'node:assert/strict'
import fs from 'node:fs'
import test from 'node:test'
import { shouldReplayRealtimeEvents } from './realtime-event-service.js'
/**
* 回归:整页刷新后大厅列表重复、可抢订单数越刷越多。
*
* 根因是新连接(lastEventId=0)也会补发最近 500 条历史事件。大厅 upsert 广播带的是
* 当时的工单快照,被重新打进刚加载的列表后,已抢走/已出队的订单会复活并被插到第 1 页,
* 前端还会按「插入行」把 pagination.total 加一。
*/
test('新连接(lastEventId=0)不补发历史事件,避免旧大厅快照复活订单', () => {
assert.equal(shouldReplayRealtimeEvents(0), false)
assert.equal(shouldReplayRealtimeEvents(Number.NaN), false)
assert.equal(shouldReplayRealtimeEvents(-1), false)
})
test('断线重连(带 Last-Event-ID)才补发事件', () => {
assert.equal(shouldReplayRealtimeEvents(1), true)
assert.equal(shouldReplayRealtimeEvents(3993659), true)
})
test('补发窗口取最新的一段,而不是最旧的一段', () => {
const source = fs.readFileSync(
new URL('../../repositories/realtime-event-repo.ts', import.meta.url),
'utf8',
)
const block = source.slice(
source.indexOf('export async function listRealtimeEventsAfter('),
source.indexOf('\n}', source.indexOf('export async function listRealtimeEventsAfter(')),
)
assert.ok(block.length > 0, 'listRealtimeEventsAfter 片段必须存在')
assert.ok(
/ORDER BY id DESC\s+LIMIT \$2\s+\)\s*replay_window\s+ORDER BY id ASC/s.test(block),
'补发必须「内层 id DESC 取最新 N 条、外层 id ASC 回放」;否则断线久了窗口会停在旧事件上',
)
})
test('补发窗口溢出时改为让客户端整体重拉', () => {
const source = fs.readFileSync(new URL('./realtime-event-service.ts', import.meta.url), 'utf8')
const replayBlock = source.slice(
source.indexOf('async function replayEvents('),
source.indexOf('function mapStoredEvent('),
)
assert.ok(replayBlock.length > 0, 'replayEvents 片段必须存在')
assert.ok(
replayBlock.includes('events.length >= REALTIME_REPLAY_EVENT_LIMIT'),
'补发窗口被拿满时必须判定为溢出,不能继续逐条套用旧快照',
)
assert.ok(
replayBlock.includes("'resync'"),
'溢出时要给客户端发 resync,让列表整体重拉(接口才是权威数据源)',
)
})