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

apps/backend/src/services/worker-platform/mappers.ts

@@ -83,6 +83,7 @@ export {
 } from './worker-finance-mappers.js'
 
 export {
+  isWorkerOrderVipEvidencePending,
   mapCollectLookupOrder,
   mapWorkCategory,
   mapWorkOrderAdmin,
@@ -91,6 +92,8 @@ export {
   mapWorkOrderPublic,
   mapWorkOrderShare,
   mapWorkOrderSharingWorkers,
+  pickWorkerRepresentativeShare,
+  resolveWorkerOrderStatusTabs,
   resolveWorkOrderOperationalStatus,
   resolveWorkerShareProductName,
   resolveWorkerShareStatus,

apps/backend/src/services/worker-platform/work-order-display-mappers.test.ts

@@ -0,0 +1,220 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import type { WorkOrderShareRow } from '../../repositories/worker-platform/types.js'
+import {
+  isWorkerOrderVipEvidencePending,
+  pickWorkerRepresentativeShare,
+  resolveWorkerOrderStatusTabs,
+  summarizeWorkerShares,
+} from './work-order-display-mappers.js'
+
+function share(overrides: Record<string, unknown>): WorkOrderShareRow {
+  return {
+    id: 1,
+    work_order_id: 1,
+    worker_id: 1,
+    quantity: 1,
+    unit_reward: 10,
+    share_reward: 10,
+    share_deposit: 0,
+    status: 'joined',
+    deadline_at: null,
+    timeout_minutes: 0,
+    created_at: '2026-10-23T10:00:00.000Z',
+    ...overrides,
+  } as unknown as WorkOrderShareRow
+}
+
+test('同一工单多份份额：数量/奖励/押金按份额求和，已取消份额不计入金额', () => {
+  const summary = summarizeWorkerShares([
+    share({
+      id: 1,
+      quantity: 2,
+      share_reward: 20,
+      share_deposit: 5,
+      status: 'joined',
+      created_at: '2026-10-23T10:00:00.000Z',
+      deadline_at: '2026-10-23T12:00:00.000Z',
+    }),
+    share({
+      id: 2,
+      quantity: 3,
+      share_reward: 30,
+      share_deposit: 5,
+      status: 'joined',
+      created_at: '2026-10-23T10:10:00.000Z',
+      deadline_at: '2026-10-23T11:00:00.000Z',
+    }),
+    share({
+      id: 3,
+      quantity: 9,
+      share_reward: 90,
+      share_deposit: 99,
+      status: 'cancelled',
+      created_at: '2026-10-23T09:00:00.000Z',
+    }),
+  ])
+
+  assert.equal(summary.quantity, 5)
+  assert.equal(summary.rewardAmount, 50)
+  assert.equal(summary.depositAmount, 10)
+  // 有有效份额时，接单时间取第一份有效份额，不取更早的已取消记录。
+  assert.equal(summary.firstJoinedAt, '2026-10-23T10:00:00.000Z')
+  // 父行倒计时取未完成份额中最早的截止时间。
+  assert.equal(summary.earliestActiveDeadlineAt, '2026-10-23T11:00:00.000Z')
+})
+
+test('历史份额没有 deadline_at 时，用份额自己的 timeout_minutes 兜底', () => {
+  const summary = summarizeWorkerShares([
+    share({
+      id: 1,
+      quantity: 2,
+      share_reward: 20,
+      status: 'joined',
+      created_at: '2026-10-23T10:00:00.000Z',
+      deadline_at: null,
+      timeout_minutes: 30,
+    }),
+  ])
+
+  assert.equal(summary.earliestActiveDeadlineAt, '2026-10-23T10:30:00.000Z')
+})
+
+test('只剩已取消份额时，金额归零但保留最早参与时间', () => {
+  const summary = summarizeWorkerShares([
+    share({
+      id: 1,
+      quantity: 2,
+      share_reward: 20,
+      status: 'cancelled',
+      created_at: '2026-10-23T09:00:00.000Z',
+    }),
+    share({
+      id: 2,
+      quantity: 3,
+      share_reward: 30,
+      status: 'cancelled',
+      created_at: '2026-10-23T09:30:00.000Z',
+    }),
+  ])
+
+  assert.equal(summary.quantity, 0)
+  assert.equal(summary.rewardAmount, 0)
+  assert.equal(summary.depositAmount, 0)
+  assert.equal(summary.firstJoinedAt, '2026-10-23T09:00:00.000Z')
+  assert.equal(summary.earliestActiveDeadlineAt, null)
+})
+
+test('代表份额与列表 LATERAL 同序：joined > submitted > accepted > cancelled，再按创建时间/id 倒序', () => {
+  const shares = [
+    share({ id: 1, status: 'cancelled', created_at: '2026-10-23T09:00:00.000Z' }),
+    share({ id: 2, status: 'submitted', created_at: '2026-10-23T09:30:00.000Z' }),
+    share({ id: 3, status: 'joined', created_at: '2026-10-23T10:00:00.000Z' }),
+  ]
+  assert.equal(pickWorkerRepresentativeShare(shares)?.id, 3)
+
+  // 同状态取更晚创建的一份（旧实现取的是「最早一条」，多份额时必然挑错）
+  const sameStatus = [
+    share({ id: 10, status: 'submitted', created_at: '2026-10-23T09:00:00.000Z' }),
+    share({ id: 11, status: 'submitted', created_at: '2026-10-23T10:00:00.000Z' }),
+    share({ id: 12, status: 'submitted', created_at: '2026-10-23T10:00:00.000Z' }),
+  ]
+  assert.equal(pickWorkerRepresentativeShare(sameStatus)?.id, 12)
+})
+
+test('多份额工单（一份进行中 + 一份待验收）必须同时属于两个页签', () => {
+  const tabs = resolveWorkerOrderStatusTabs({
+    workOrderStatus: 'in_progress',
+    isAssignedWorker: false,
+    shares: [share({ id: 1, status: 'joined' }), share({ id: 2, status: 'submitted' })],
+  })
+  assert.deepEqual(tabs.sort(), ['in_progress', 'pending_acceptance'])
+})
+
+test('有待审核取消申请/未处理反馈时，进行中份额归问题单，但待验收份额仍留在待验收', () => {
+  const tabs = resolveWorkerOrderStatusTabs({
+    workOrderStatus: 'in_progress',
+    isAssignedWorker: false,
+    shares: [share({ id: 1, status: 'joined' }), share({ id: 2, status: 'submitted' })],
+    hasPendingHandling: true,
+  })
+  assert.deepEqual(tabs.sort(), ['pending_acceptance', 'problem'])
+})
+
+test('母单进入终态后只按母单状态归类（与 SQL 关闭 anyShare 分支一致）', () => {
+  const tabs = resolveWorkerOrderStatusTabs({
+    workOrderStatus: 'problem',
+    isAssignedWorker: true,
+    shares: [share({ id: 1, status: 'submitted' })],
+  })
+  assert.deepEqual(tabs, ['problem'])
+})
+
+test('份额全部取消时只归已取消，不得混进待验收', () => {
+  const tabs = resolveWorkerOrderStatusTabs({
+    workOrderStatus: 'pending_acceptance',
+    isAssignedWorker: true,
+    shares: [share({ id: 1, status: 'cancelled' })],
+  })
+  assert.deepEqual(tabs, ['cancelled'])
+})
+
+test('没有份额的指派单按母单状态归类；超时退回后归已超时', () => {
+  assert.deepEqual(
+    resolveWorkerOrderStatusTabs({
+      workOrderStatus: 'pending_acceptance',
+      isAssignedWorker: true,
+      shares: [],
+    }),
+    ['pending_acceptance'],
+  )
+  assert.deepEqual(
+    resolveWorkerOrderStatusTabs({
+      workOrderStatus: 'pending_acceptance',
+      isAssignedWorker: false,
+      shares: [share({ id: 1, status: 'cancelled' })],
+      hasTimeoutForMe: true,
+    }),
+    ['open'],
+  )
+})
+
+test('VIP 免审核待补图：只有已验收 + vip_auto + 待补图 + 未到期才归入该页签', () => {
+  const now = Date.parse('2026-10-23T10:00:00.000Z')
+  const base = {
+    status: 'accepted',
+    acceptance_json: {
+      reviewMode: 'vip_auto',
+      evidenceStatus: 'pending',
+      evidenceDueAt: '2026-10-24T10:00:00.000Z',
+    },
+  }
+  assert.equal(isWorkerOrderVipEvidencePending(base, now), true)
+  assert.equal(
+    isWorkerOrderVipEvidencePending(
+      { ...base, acceptance_json: { ...base.acceptance_json, evidenceStatus: 'submitted' } },
+      now,
+    ),
+    false,
+  )
+  assert.equal(
+    isWorkerOrderVipEvidencePending(
+      {
+        ...base,
+        acceptance_json: { ...base.acceptance_json, evidenceDueAt: '2026-10-22T10:00:00.000Z' },
+      },
+      now,
+    ),
+    false,
+  )
+  assert.deepEqual(
+    resolveWorkerOrderStatusTabs({
+      workOrderStatus: 'accepted',
+      isAssignedWorker: true,
+      shares: [share({ id: 1, status: 'accepted' })],
+      vipEvidencePending: true,
+    }).sort(),
+    ['accepted', 'vip_evidence_pending'],
+  )
+})

apps/backend/src/services/worker-platform/work-order-display-mappers.ts

@@ -597,6 +597,147 @@ export function resolveWorkerShareStatus(workOrderStatus: string, shareStatus: u
   return workOrderStatus
 }
 
+/** 打手端「我的订单」状态页签键，与 buildWorkOrderWhere 的打手状态筛选同口径。 */
+export type WorkerOrderStatusTab =
+  | 'in_progress'
+  | 'pending_acceptance'
+  | 'problem'
+  | 'open'
+  | 'accepted'
+  | 'cancelled'
+  | 'vip_evidence_pending'
+
+/** 母单进入终态后，列表只按母单状态归类（任一命中分支会被 wo.status NOT IN (...) 关掉）。 */
+const TERMINAL_WORK_ORDER_STATUSES = new Set(['accepted', 'cancelled', 'problem'])
+
+/** 代表份额优先级，与 SQL LATERAL 的 CASE 顺序一致：joined > submitted > accepted > cancelled。 */
+const WORKER_SHARE_STATUS_PRIORITY: Record<string, number> = {
+  joined: 0,
+  submitted: 1,
+  accepted: 2,
+  cancelled: 3,
+}
+
+type WorkerShareLike = {
+  status?: unknown
+  created_at?: unknown
+  id?: unknown
+}
+
+/**
+ * 同一打手在一个工单里的「代表份额」。
+ *
+ * 实时广播过去用 `shares.find(worker_id === ...)`（= 最早一条），同一打手多次拼单时会挑到
+ * 已取消/进行中的那份，进而把快照算成「不在可见范围」或错误的个人状态，导致打手端某个
+ * 状态页签的行被实时补丁删掉（表现为「待验收有时候没有数据」）。
+ * 这里与 `work-order-query-repo` 的 LATERAL 排序完全一致：
+ *   status 优先级 ASC, created_at DESC, id DESC
+ */
+export function pickWorkerRepresentativeShare<T extends WorkerShareLike>(
+  shares: readonly T[],
+): T | null {
+  let representative: T | null = null
+  for (const share of shares) {
+    if (!representative) {
+      representative = share
+      continue
+    }
+    const priority = WORKER_SHARE_STATUS_PRIORITY[String(share.status || '')] ?? 4
+    const representativePriority =
+      WORKER_SHARE_STATUS_PRIORITY[String(representative.status || '')] ?? 4
+    if (priority !== representativePriority) {
+      if (priority < representativePriority) representative = share
+      continue
+    }
+    const createdMs = Date.parse(String(share.created_at || ''))
+    const representativeCreatedMs = Date.parse(String(representative.created_at || ''))
+    if (Number.isFinite(createdMs) && Number.isFinite(representativeCreatedMs)) {
+      if (createdMs !== representativeCreatedMs) {
+        if (createdMs > representativeCreatedMs) representative = share
+        continue
+      }
+    }
+    if (Number(share.id || 0) > Number(representative.id || 0)) representative = share
+  }
+  return representative
+}
+
+/**
+ * 一个工单在该打手「我的订单」里会出现在哪些状态页签。
+ *
+ * 为什么需要它：多份额工单可以同时属于「代练中」和「待验收」（一份 joined + 一份 submitted），
+ * 但实时快照只能带一个 `status` 字段。前端旧逻辑只要「快照状态 ≠ 当前页签」就把行从缓存删掉，
+ * 于是同一张单在其中一个页签凭空消失。广播里带上完整页签集合后，前端按集合判归属即可。
+ *
+ * 口径逐条对齐 `buildWorkOrderWhere`（打手状态筛选）：
+ *   - 母单 accepted/cancelled/problem：只看代表状态（母单状态）；
+ *   - 其余：代表状态 + 「任一有效份额命中」（joined 需无待处理申请，submitted/accepted 直接命中）；
+ *   - 有该打手的超时事件且他已不持有订单：代表状态记 open。
+ */
+export function resolveWorkerOrderStatusTabs(input: {
+  workOrderStatus: string
+  isAssignedWorker: boolean
+  /** 该打手在该工单的全部份额（含已取消），用于还原代表份额。 */
+  shares?: readonly WorkerShareLike[]
+  /** 存在待审核取消申请或未处理反馈（进行中的份额会归入问题单）。 */
+  hasPendingHandling?: boolean
+  /** 该打手在这张单上有超时事件。 */
+  hasTimeoutForMe?: boolean
+  /** 命中「VIP 免审核待补图」筛选（列表里它是独立筛选，不参与 status 参数）。 */
+  vipEvidencePending?: boolean
+}): WorkerOrderStatusTab[] {
+  const tabs = new Set<WorkerOrderStatusTab>()
+  const workOrderStatus = String(input.workOrderStatus || '')
+  if (input.vipEvidencePending) tabs.add('vip_evidence_pending')
+
+  if (TERMINAL_WORK_ORDER_STATUSES.has(workOrderStatus)) {
+    tabs.add(workOrderStatus as WorkerOrderStatusTab)
+    return [...tabs]
+  }
+
+  const shares = input.shares || []
+  const activeShares = shares.filter(
+    (share) =>
+      share.status === 'joined' || share.status === 'submitted' || share.status === 'accepted',
+  )
+  const representative = pickWorkerRepresentativeShare(shares)
+  let representativeStatus = representative
+    ? resolveWorkerShareStatus(workOrderStatus, representative.status)
+    : workOrderStatus
+  if (input.hasTimeoutForMe && !input.isAssignedWorker && activeShares.length === 0) {
+    representativeStatus = WORK_ORDER_STATUS.OPEN
+  } else if (representativeStatus === WORK_ORDER_STATUS.IN_PROGRESS && input.hasPendingHandling) {
+    representativeStatus = WORK_ORDER_STATUS.PROBLEM
+  }
+  if (representativeStatus) tabs.add(representativeStatus as WorkerOrderStatusTab)
+
+  for (const share of activeShares) {
+    if (share.status === 'joined') {
+      // 挂待处理申请/反馈的进行中份额归问题单，不再计入代练中（与 SQL 的 anyShare 分支一致）。
+      if (!input.hasPendingHandling) tabs.add('in_progress')
+    } else if (share.status === 'submitted') {
+      tabs.add('pending_acceptance')
+    } else if (share.status === 'accepted') {
+      tabs.add('accepted')
+    }
+  }
+
+  return [...tabs]
+}
+
+/** 「VIP 免审核，待补图」判定，口径同 `buildWorkOrderWhere` 的 vipEvidencePendingWhere。 */
+export function isWorkerOrderVipEvidencePending(
+  workOrder: Pick<WorkOrderRow, 'status' | 'acceptance_json'>,
+  nowMs = Date.now(),
+): boolean {
+  if (String(workOrder.status || '') !== WORK_ORDER_STATUS.ACCEPTED) return false
+  const acceptance = mapAcceptanceForResponse(workOrder.acceptance_json) as Record<string, unknown>
+  if (String(acceptance.reviewMode || '') !== 'vip_auto') return false
+  if (String(acceptance.evidenceStatus || '') !== 'pending') return false
+  const dueAtMs = Date.parse(String(acceptance.evidenceDueAt || ''))
+  return Number.isFinite(dueAtMs) && dueAtMs > nowMs
+}
+
 export function mapWorkOrderShare(share: WorkOrderShareRow) {
   return {
     shareId: Number(share.id),

apps/backend/src/services/worker-platform/worker-my-order-service.ts

@@ -245,25 +245,31 @@ export async function getWorkerMyOrderOverview(session: WorkerSession) {
     buildMyOrderCacheKey(worker.id, 'overview', 0),
     () => getWorkerOrderOverview(worker.id),
   )
-  const items = rows.map((row) => ({
+  const statusRows = rows.filter((row) => row.status !== 'all')
+  const items = statusRows.map((row) => ({
     status: row.status,
     orderCount: row.orderCount,
     settlementAmount: row.settlementAmount,
   }))
-  const vipEvidencePending = rows.reduce(
+  const vipEvidencePending = statusRows.reduce(
     (summary, row) => ({
       orderCount: summary.orderCount + row.vipEvidencePendingCount,
       settlementAmount: summary.settlementAmount + row.vipEvidencePendingSettlementAmount,
     }),
     { orderCount: 0, settlementAmount: 0 },
   )
-  const all = items.reduce(
-    (summary, item) => ({
-      orderCount: summary.orderCount + item.orderCount,
-      settlementAmount: summary.settlementAmount + item.settlementAmount,
-    }),
-    { orderCount: 0, settlementAmount: 0 },
-  )
+  // 混合状态的多份额工单会同时出现在多个页签，不能再用各页签相加当「全部订单」，
+  // 否则同一工单会被重复计数；优先使用 SQL 里按 distinct 工单算好的 all 行。
+  const allRow = rows.find((row) => row.status === 'all')
+  const all = allRow
+    ? { orderCount: allRow.orderCount, settlementAmount: allRow.settlementAmount }
+    : items.reduce(
+        (summary, item) => ({
+          orderCount: summary.orderCount + item.orderCount,
+          settlementAmount: summary.settlementAmount + item.settlementAmount,
+        }),
+        { orderCount: 0, settlementAmount: 0 },
+      )
   return {
     items: [
       ...items,