Merge branch 'main' into dev

apps/backend/src/services/worker-platform/admin-work-order-acceptance-service.ts

@@ -196,7 +196,8 @@ export async function cancelAdminWorkOrderShare(
  * 后台按份数撤销某个打手的部分份额。
  *
  * 减少的份数会随「大厅余量 = 总份数 − Σ有效份额数量」自动回到大厅；押金保持原冻结额，
- * 母单状态与验收资料都不动（之后仍可对该份额「单独验收」）。
+ * 母单状态按剩余份额重算（可能从待验收回到待抢单，保留原大厅队列位置），
+ * 该份额的验收资料不动（之后仍可对该份额「单独验收」）。
  */
 export async function reduceAdminWorkOrderShareQuantity(
   workOrderId: number | string,

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

@@ -198,12 +198,14 @@ export function resolveWorkOrderOperationalStatus(workOrder: WorkOrderRow): stri
   const activeShareQuantity = Math.max(0, Number(workOrder.active_share_quantity || 0))
   const pendingShareCount = Math.max(0, Number(workOrder.pending_share_count || 0))
   const sharingTotalQuantity = Math.max(1, Number(workOrder.sharing_total_quantity || 1))
-  const hasActiveShares = activeShareQuantity > 0
   const sharingFilled =
     workOrder.sharing_enabled === true && activeShareQuantity >= sharingTotalQuantity
 
-  if (workOrder.status === WORK_ORDER_STATUS.OPEN && workOrder.sharing_enabled && hasActiveShares) {
-    return sharingFilled && pendingShareCount === 0
+  if (workOrder.status === WORK_ORDER_STATUS.OPEN && workOrder.sharing_enabled) {
+    // 有份额回到大厅（未满额）时，母单先回到「待抢单」：空位还在，就还没到按份额状态推进的时候。
+    // 满额后才按份额状态收敛：仍有 joined → 代练中；全部已提交 → 待验收。
+    if (!sharingFilled) return WORK_ORDER_STATUS.OPEN
+    return pendingShareCount === 0
       ? WORK_ORDER_STATUS.PENDING_ACCEPTANCE
       : WORK_ORDER_STATUS.IN_PROGRESS
   }

apps/backend/src/services/worker-platform/worker-platform-service.test.ts

@@ -2046,6 +2046,7 @@ test('后台拼单聚合状态同时收敛筛选语义和操作能力', () => {
   assert.equal(waitingForClaim.status, 'open')
   assert.equal(waitingForClaim.capabilities.canUpdateMaterial, true)
 
+  // 有份额回到大厅（未满额）：空位还在，母单必须先显示「待抢单」。
   const partial = mapWorkOrderAdmin(
     buildWorkOrderRow({
       status: 'open',
@@ -2055,7 +2056,7 @@ test('后台拼单聚合状态同时收敛筛选语义和操作能力', () => {
       pending_share_count: 1,
     }),
   )
-  assert.equal(partial.status, 'in_progress')
+  assert.equal(partial.status, 'open')
   assert.equal(partial.rawStatus, 'open')
   assert.equal(partial.hallAvailable, true)
   assert.equal(partial.capabilities.canEdit, false)
@@ -2063,6 +2064,25 @@ test('后台拼单聚合状态同时收敛筛选语义和操作能力', () => {
   assert.equal(partial.capabilities.canAssign, false)
   assert.equal(partial.capabilities.canUpdateMaterial, true)
   assert.equal(partial.capabilities.canCancelSharing, true)
+  // 整单验收 / 整单标记问题单都要求满额且所有份额满足，不满额时不能走整单动作。
+  assert.equal(partial.capabilities.canAccept, false)
+  assert.equal(partial.capabilities.canMarkProblem, false)
+
+  // 满额但还有份额没提交：母单代练中，整单验收同样不可用。
+  const filledInProgress = mapWorkOrderAdmin(
+    buildWorkOrderRow({
+      status: 'open',
+      sharing_enabled: true,
+      sharing_total_quantity: 15,
+      active_share_quantity: 15,
+      pending_share_count: 1,
+    }),
+  )
+  assert.equal(filledInProgress.status, 'in_progress')
+  assert.equal(filledInProgress.rawStatus, 'open')
+  assert.equal(filledInProgress.hallAvailable, false)
+  assert.equal(filledInProgress.capabilities.canAccept, false)
+  assert.equal(filledInProgress.capabilities.canMarkProblem, true)
 
   const filled = mapWorkOrderAdmin(
     buildWorkOrderRow({
@@ -2080,6 +2100,38 @@ test('后台拼单聚合状态同时收敛筛选语义和操作能力', () => {
   assert.equal(filled.capabilities.canCancelSharing, true)
 })
 
+test('后台运营态先判空位：不满额必须显示待抢单，满额后才按份额推进', async () => {
+  const { readFile } = await import('node:fs/promises')
+  const queryRepo = await readFile(
+    new URL('../../repositories/worker-platform/work-order-query-repo.ts', import.meta.url),
+    'utf8',
+  )
+  const start = queryRepo.indexOf('function adminOperationalStatusExpression')
+  assert.ok(start >= 0, '缺少 adminOperationalStatusExpression')
+  const end = queryRepo.indexOf('/** 工单统一搜索字段', start)
+  const block = queryRepo.slice(start, end > start ? end : start + 4000)
+
+  // 两个分支（带 share summary 别名 / 不带别名）都必须先判「有效份数 < 总份数」。
+  assert.equal(
+    (block.match(/< \$\{alias\}\.sharing_total_quantity/g) || []).length,
+    2,
+    '空位判定必须在两版运营态表达式里都存在',
+  )
+  assert.ok(
+    block.indexOf("THEN 'open'") < block.indexOf("THEN 'pending_acceptance'"),
+    '空位分支必须排在待验收之前，否则不满额拼单会被误判为待验收',
+  )
+  assert.ok(
+    block.indexOf("THEN 'open'") < block.indexOf("ELSE 'in_progress'"),
+    '空位分支必须排在代练中之前，否则不满额拼单会被误判为代练中',
+  )
+  assert.equal(
+    (block.match(/THEN 'open'/g) || []).length,
+    2,
+    '空位分支必须在两版运营态表达式里都以待抢单收口',
+  )
+})
+
 test('已取消工单可重新启用，恢复未分配后可编辑和发布', () => {
   const cancelled = mapWorkOrderAdmin(buildWorkOrderRow({ status: 'cancelled' }))
   assert.equal(cancelled.capabilities.canReopen, true)
@@ -3510,13 +3562,21 @@ type ShareAggregate = {
 async function runRecompute(
   workOrder: Partial<WorkOrderRow>,
   aggregate: ShareAggregate,
-): Promise<{ status: string | null; updates: unknown[][]; shareQueries: number }> {
+  options: { preserveHallQueue?: boolean } = {},
+): Promise<{
+  status: string | null
+  updates: unknown[][]
+  shareQueries: number
+  updateSqls: string[]
+}> {
   const updates: unknown[][] = []
+  const updateSqls: string[] = []
   let shareQueries = 0
   const client = {
     query: async (sql: string, params: unknown[] = []) => {
       if (sql.includes('UPDATE work_orders')) {
         updates.push(params)
+        updateSqls.push(sql)
         return { rows: [{ ...buildWorkOrderRow(workOrder), status: params[0] }] }
       }
       if (sql.includes('FROM work_orders')) {
@@ -3534,8 +3594,9 @@ async function runRecompute(
     client,
     1,
     '2026-10-23T12:00:00.000Z',
+    options,
   )
-  return { status: updated ? String(updated.status) : null, updates, shareQueries }
+  return { status: updated ? String(updated.status) : null, updates, shareQueries, updateSqls }
 }
 
 test('拼单母单状态由份额集合唯一推导：满额且无待履约份额才转待验收', async () => {
@@ -3574,7 +3635,7 @@ test('拼单母单已验收或已取消时 recompute 不回头改状态', async
   }
 })
 
-test('后台单人撤单不改母单状态；份额超时仍交给 recompute 收敛', async () => {
+test('后台单人撤单重算母单状态，空出份额回大厅并保留原队列位置', async () => {
   const src = fs.readFileSync(
     new URL('../../repositories/worker-platform/work-order-settlement-repo.ts', import.meta.url),
     'utf8',
@@ -3585,14 +3646,18 @@ test('后台单人撤单不改母单状态；份额超时仍交给 recompute 收
   )
   assert.ok(cancelBlock.length > 0, 'cancelWorkOrderShare 片段必须存在')
   assert.ok(
-    !cancelBlock.includes('recomputeWorkOrderSharingStatusWithClient('),
-    '后台单人撤单不得重算母单状态（撤一份会把待验收的母单踢回大厅）',
+    cancelBlock.includes('recomputeWorkOrderSharingStatusWithClient('),
+    '后台单人撤单必须重算母单状态，空出的份数才能回到大厅',
   )
+  assert.ok(cancelBlock.includes('preserveHallQueue: true'), '后台单人撤单回大厅必须保留原队列位置')
   assert.ok(
     !/UPDATE\s+work_orders\s+SET[\s\S]{0,80}?status\s*=/i.test(cancelBlock),
     '后台单人撤单不得自己写母单 status',
   )
-  assert.ok(cancelBlock.includes('toStatus: workOrder.status'), '撤单事件不得记录母单状态迁移')
+  assert.ok(
+    cancelBlock.includes('toStatus: updatedOrder?.status || workOrder.status'),
+    '撤单事件必须记录母单重算后的状态',
+  )
 
   const timeoutBlock = src.slice(
     src.indexOf('export async function settleOverdueWorkOrderShare('),
@@ -3603,6 +3668,7 @@ test('后台单人撤单不改母单状态；份额超时仍交给 recompute 收
     timeoutBlock.includes('recomputeWorkOrderSharingStatusWithClient('),
     '份额超时必须用 recompute 收敛母单状态',
   )
+  assert.ok(timeoutBlock.includes('preserveHallQueue: true'), '份额超时回大厅必须保留原队列位置')
   assert.ok(
     !/UPDATE\s+work_orders\s+SET[\s\S]{0,80}?status\s*=/i.test(timeoutBlock),
     '份额超时不得自己写母单 status（只能由 recompute 推导）',
@@ -3642,6 +3708,11 @@ test('撤份额与单人撤单都把原因和份数写进份额行，列表才
     shareSrc.indexOf('export async function submitWorkOrderShareAcceptance('),
   )
   assert.ok(reduceBlock.length > 0, 'reduceWorkOrderShareQuantity 片段必须存在')
+  assert.ok(
+    reduceBlock.includes('recomputeWorkOrderSharingStatusWithClient('),
+    '撤份额必须重算母单状态，减少的份数才能回大厅',
+  )
+  assert.ok(reduceBlock.includes('preserveHallQueue: true'), '撤份额回大厅必须保留原队列位置')
   assert.ok(reduceBlock.includes('cancel_note = $'), '撤份额必须把原因写进 cancel_note')
   assert.ok(
     reduceBlock.includes('String(share.cancel_note'),