Compare commits

...

27 Commits

Author SHA1 Message Date
2c49df3ff7 Merge pull request 'perf(mkh-bom): 页面不再每次打开都等分钟级冷查' (#99) 2026-11-17 10:31:25 +08:00
2defbe9192 perf(mkh-bom): 把订单全表扫挪出请求路径,页面不再每次打开都等分钟级冷查
现象:MKH-BOM 每次打开 / F5 / 每 2 分钟轮询都要等 2 分钟以上,导出明细也卡,
且页面长期处于 pendingOrderDegraded(待发 SKU = 0、订单驱动预警 = 0)。

2026-11-17 生产容器实测:rpt.jst_Orders 158 万行光 COUNT(*) 需 152.8s(≈1 万行/秒),
loadOrderIndex 单跑 408.5s 后降级;首屏冷查 126.9s,而缓存命中只要 4.2s。

四处根因与对应修复:

1) `{ requestTimeout: 180000 }` 在 query() 上不生效(只写请求级 request.timeout,
   mssql 12.x 无效)→ 实际按共享池 60s 掐断 → 每次加载都降级。
   cloudDatabase.query 新增 `freshConnection: true`:委派到既有 queryWithFreshConnection
   (独立连接,池级超时随 connectRequestTimeoutMs 放大);不传时行为不变。
   订单两表 + 出库校验改走该路径,分别 300s / 180s,maxAttempts 1(慢库重试只是把等待翻倍)。
2) 降级缓存 60s → 5 分钟:降级态每次重试都是一次全表扫,60s 等于「刚失败就重打」的自残循环。
3) 订单索引 TTL 10 → 30 分钟,并改为 stale-while-revalidate:过期后先返回旧快照、
   后台补新值(后台失败则保留旧索引并压 60 秒再试,不再把缓存清成 null 让待发货量显示 0)。
   新增 jobs/mkhBomPrewarmJob:启动 20s 后 + 每 20 分钟后台预热(间隔可用环境变量调)。
4) 前端首屏 / 轮询不再发 fresh=1(它会让后端清缓存 → 必冷查);
   强制重读只保留「同步最新数据 / 刷新数据」按钮一个入口。
5) 待发货分支补 order_date >= 近 180 天下界,不再让历史僵尸单参与扫描与累计
   (order_date 为空照旧纳入,宁可多算不漏算)。

验证:backend syntax 197 文件通过;backend test 526/524 pass(2 个既有环境失败:
13333 隧道未起、Windows chmod);mkhBomService 61/61,含新增 5 条针对本次改动的用例;
frontend eslint 无告警、npm run build 通过。

口径提示:第 5 条会改变「待发货订单量」的统计范围(只算近 180 天下单),需业务确认;
若半年以上确有待发单,改 PENDING_ORDER_MAX_AGE_DAYS 一行即可。
2026-11-17 10:24:36 +08:00
9924c8d1c9 Merge pull request 'fix(wle): 超时参数真正生效 —— 售后拦截 20s 不重试、表级探测走 querySlow' (#98) 2026-11-14 09:51:28 +08:00
936d391142 Merge pull request 'fix(wle): 正文写明物流快照是否覆盖核验时刻 / 是否过旧' (#97) 2026-11-14 09:51:25 +08:00
2f44cdce82 Merge pull request 'fix(wle): 钉钉推送失败后自动重试,不再「一天只有一次机会」' (#96) 2026-11-14 09:51:21 +08:00
3062182417 fix(wle): 超时参数真正生效 —— 售后拦截 20s 不重试、表级探测走 querySlow
11-13 09:10 那轮钉钉推送 300s 超时没发出去。除了业务库本身变慢,代码里还有两笔白等:

1. `{ timeoutMs: 240000 }` 是无效参数
   cloudDatabase 只读 connectRequestTimeoutMs / requestTimeout。mssql 12.x 上请求级
   request.timeout 不生效,超时只能靠池配置级 requestTimeout,而共享池(query())的
   池级超时在 pool 创建时就定死 —— 所以「给足 4 分钟」从来没生效过,实际一路按
   60s(普通 query)/ 300s(querySlow)掐断。
   → cloudDatabase 两个查询入口加 warnLegacyTimeoutOption():再传 timeoutMs 就告警,
     不再静默当没看见。

2. 售后拦截子查询:名义 240s → 真 20s,且不重试
   两张售后表在 rpt 副本里是堆表,实测 4.5s / 8.5s。原来超时后 query() 还把它当
   可重试错误 resetPool + 重查一次,白等 60s(11-13 日志里约 2 分钟)。
   改成 querySlow + connectRequestTimeoutMs=20000 + maxAttempts=1:超了就按既有
   catch 降级「不剔除」,不为一个补充判据把整批核验拖进超时窗口。

3. 空窗口的表级 MAX(query_time) 探测改走 querySlow(180s,maxAttempts=1)
   全表 MAX 实测已跑不进 60s,用共享池等于永远探测不到 → sourceLastUpdate 恒空,
   「0 单是没发货还是没同步」又分不清了。探测失败只需退回「不知道」,不值得重试。

顺带修一个时间炸弹测试:用例「窗口 0 行但数据源是新的」硬编码 sourceMaxQueryTime
为 2026-11-02 09:58,而服务层算 ageMinutes 用的是真实时钟(registry.beijingNow)——
隔一天就变成「停更 24h」,该用例在 origin/main 上从 11-03 起一直是红的。
改成相对当前时间。

测试:warehouseLogisticsException 36/36 通过(新增 2 条「超时参数必须真生效」断言)。
2026-11-14 09:28:27 +08:00
9a7215a46c fix(wle): 正文写明物流快照是否覆盖核验时刻 / 是否过旧
11-11 09:10 那批:物流镜像表停在 11-10 11:53,算出 990 单**全部异常**,
钉钉正文却只有「已发货 990 单,异常 990 个包裹(100%)」。群里没法分辨
这是真异常还是数据没更新 —— 而这恰恰决定当天要不要去催快递。

PR #94 只修了「0 单」这一种(emptyWindow),有异常但快照降级的情形仍然是哑的。

- 新增 `buildFreshnessWarning`:`coversDeadline === false` 或 `stale === true`
  时,在数字行下面插一条 ⚠️ 告警,写明快照最新时刻、本轮核验时刻、未刷新时长,
  并明确「请以聚水潭实时物流为准,别按这个数去催快递」。
- 新增 `formatSnapshotMoment`:快照时刻**跨天必须带 MM-DD**。
  11-11 那批的 snapshotAt 是前一天的,只写「11:53」会被读成当天上午的新鲜数据
  (与 WST「历史单审核时间必须带 MM-DD」是同一个坑)。
- 只在「算出异常」时告警;0 单走原有 emptyWindow 分支,不叠加两条。
- 字段缺失(老缓存 / 接口未返回)静默跳过,不能把推送搞崩,也不能瞎报警。

测试:新增 5 条(未覆盖核验时刻含跨天日期 / 同日不写日期 / stale 带时长 /
正常批次无告警 / 字段缺失不崩),26/26 通过。
2026-11-11 11:14:31 +08:00
6c4f36f9fd fix(wle): 钉钉推送失败后自动重试,不再「一天只有一次机会」
11-11 09:10 那次推送撞上业务库连不上(状态里 `Failed to connect to
218.93.9.21:1433`)。老逻辑用 `chinaHourMinute(now) === config.sendTime`
严格相等判定,只给这一分钟一次机会:失败后当天彻底不推,群里一整天
没有任何消息,也没人知道任务其实跑过。

改成「推送时刻 + 重试窗口」模型:

- 新增纯函数 `resolveScheduledPushDecision`,每分钟 tick 只需问它一次;
  窗口 = sendTime ~ sendTime+30min,窗口内每 5 分钟重试一次,成功即停
  (`lastSentDate` 落库后后续 tick 走 already_sent_today)。
- 状态新增 `attemptDate` / `attemptCount` / `lastAttemptAt`:既做节流
  (避免每分钟重跑 240s 的全量核验),也做跨天归零。
- 窗口不跨日(sendTime+window 超过 23:59 截到当天最后一分钟),
  否则 pushDate 换天会把去重键带歪、同一天可能推两遍。
- 窗口关闭且当天始终未成功时打一条 error 日志,明确「今天不会再自己来了」。
- 窗口 / 间隔支持 `WLE_NOTIFY_RETRY_WINDOW_MINUTES`、
  `WLE_NOTIFY_RETRY_INTERVAL_MINUTES` 环境变量覆盖,现网调整不用发版。

测试:`test/warehouseLogisticsExceptionNotify.test.js` 新增 10 条边界用例
(到点首轮 / 未到点 / 已推过 / 间隔内节流 / 间隔到点 / 窗口边界含端点 /
窗口关闭 / 跨天归零 / 窗口不跨日 / 状态残缺不卡死 / sendTime 非法),
30/30 通过。
2026-11-11 11:12:26 +08:00
f8b99151b5 Merge pull request 'fix(mkh): 在途加工单换用聚水潭原生三表(po_id 关联),修「页面 9 单 vs 聚水潭 18 单」' (#94) from yanhui-mkh-workorder-1111 into main 2026-11-11 10:17:59 +08:00
c5a8b592a1 fix(mkh): 在途加工单换用聚水潭原生三表(po_id 关联),修「页面 9 单 vs 聚水潭 18 单」
## 问题
页面「在途加工单 / 已排产」只显示 9 个,且全是 2026-11-03 的僵尸单;
业务在聚水潭看到的是 18 个,且那 9 个早已加工入库完成。

## 根因
旧数据源是链接服务器快照表
`LS_JS_DMP(192.168.1.209).JSDataMiddlePlatform.dbo.bi_processing_work_orders`:
- 表内**无任何时间列**,实测按加工日期自 2026-11-03 10:49 起 **8 天 0 行**
  (1,370 行 / MAX(Id)=1370 不再增长,而此前每天都有 5~34 行);
- 且**数据陈旧不会报错** —— `workOrderDegraded` 只反映「查询失败」,
  停更期间恒为 false,页面完全无告警。
结果:9 行残留「已确认/未入库」把对应成品永久锁成「已排产」压住补货预警,
而 11-04 之后新开的加工单一条都没进库(在途量按 0 算,缺货会被误报)。

## 改动
数据源改为聚水潭原生加工单三表(业务库本实例,随主库小时级刷新),主键 `po_id` 关联:
- `rpt.jst_manufactureInfo`  单头:status / wms_co_id(加工仓) / receipt_wms_co_id(收货仓)
- `rpt.jst_manufactureItem`  成品明细:sku_id / qty / io_qty(已入库) / delivery_date
- `rpt.jst_manufactureRaw`   原料明细(本次不参与在途核算,配件占用仍走 BOM 单台用量)

口径保持业务确认的语义,只换算字段:
- 加工仓:中文名 `加工仓储方` → `wms_co_id = 15718196`(ID 比名称稳定)
- 作废:`'作废'` → `'Cancelled'`
- 完成:`'全部入库'` → `'Finished'`
- 剩余量:`数量 − 已入库数量` → `qty − io_qty`
- ETA:`预计加工完成时间` → `delivery_date`(实测 18 单全能解析)
- 查询从 `getPool()` 四段名改为 `cloudDatabase.query()`(表名已带 rpt. 前缀,不受 dbo→rpt 重写影响)

## 验证
- 真实库实跑(生产 13333 隧道)SQL 与服务层 `loadPendingWorkOrderIndex()`:
  命中 **18 个 SKU / 18 单 / 在途 175 件**,`degraded=false`,ETA 2026-11-24 ~ 11-25;
  热态耗时 **0.7~1.5s**(冷启动 5s,结果进 10 分钟缓存)。
- 状态一致性:`Finished` 1,149 单的 1,173 行明细**零剩余**;`Cancelled` 178 单 io_qty 全 0;
  `Confirmed` 18 单 io_qty 全 0 → 剩余量判据自身即可区分完成,状态只用来剔作废。
- `node --test test/mkhBomService.test.js` **56/56 通过**;全量 505 项 502 通过,
  3 项失败均为既有环境问题(secretStore Windows 权限、cloudDatabase 负缓存 TTL、
  WST 用例在并发下的时序抖动,单独跑均通过)。
- `check-syntax` 196 文件通过。

## 风险与回退
- 只换数据源、不动预警优先级与结余口径,接口字段名全部保持不变(`pendingWorkOrderQty/Count/Eta/No`),
  前端零改动。
- 回退:单文件还原 `mkhBomService.js` 即可,无数据迁移、无 DDL。
2026-11-11 10:05:43 +08:00
54ad6aad89 Merge pull request 'fix(wle): 0 单不再冒充「全部正常」——窗口空时查数据源是否停更' (#94) from yanhui-wle-emptydata-1102 into main 2026-11-02 13:32:49 +08:00
555ac6b116 fix(wle): 0 单不再冒充「全部正常」——窗口空时查数据源是否停更
11-02 09:00 那批推到钉钉群的是「已发货 0 单 / 0 个包裹,异常 0 个包裹(0%)」,
业务问「怎么可能 0 单」。查库确认:物流镜像表 jst_order_express_details
最后灌库停在 2026-11-01 07:55,11-01 当天 12 个发货仓一条发货记录都没有
(订单表 jst_Orders 同日有 4601 单发货,说明货是真发了,只是物流没进库)。

根因不是口径,是「0 单没有告警」这个设计缺陷:freshness 只用本批窗口内行的
query_time 算,窗口一行都没有时 snapshotAt 为空串 → stale=false、hint='',
于是「上游没同步」和「当天真没发货」在页面和钉钉里长得完全一样,还写「全部正常」。

改动
- service:窗口 0 行时补查一次表级 MAX(query_time)(全表 13.5s,只在空窗口付这笔钱,
  随主结果进 5 分钟缓存),新增 freshness.emptyWindow / sourceLastUpdate /
  sourceAgeMinutes / sourceStale,并按「真停更 / 表新但当天无记录 / 取不到时间」
  三种情况给不同 hint。
- 钉钉正文:0 条时不再无脑写「本批无转运异常,全部正常」;真停更写
  「⚠️ 物流数据未同步:镜像表最后更新 …(已 N 小时未同步)… 0 单不代表当天没发货」,
  表新但当天无记录则说明「库里 0 条发货记录(数据源正常),请到聚水潭核对」。
- 前端:emptyWindow 走红条(原来只判 coversDeadline/stale,空窗口不告警),
  发货卡片副标改为「数据未同步,见上方红条」。
- 前端顺带修:钉钉消息链接带 ?date=YYYY-MM-DD,但页面从不读这个参数,
  点进去永远显示「今天这批」;现按 URL 初始化核验日。

验证
- npm --prefix backend run check:505 tests / 503 pass;新增 5 个用例
  (停更 hint、表新但 0 条、有行时不付全表 MAX、推送文案两态)全过。
  既有失败 2 个与本任务无关:cloudDatabaseConfigCache 负缓存 TTL、
  resilientSecretStore 的 Windows 0600 权限断言。
- 生产库实跑(本地 4002,直连 JSReportReplica):
  date=2026-11-02 → emptyWindow=true、sourceLastUpdate=2026-11-01 07:55:04、
  sourceAgeMinutes≈1590、hint 正确;date=2026-11-01 → 4390 单 / 9 异常、
  emptyWindow=false,原有「未覆盖核验时刻」提示不变。
- 钉钉 dryRun 正文实测:前 3 行即带「⚠️ 物流数据未同步 … 0 单不代表当天没发货」。
- Playwright 真渲染(5173):
  ?date=2026-11-02 → 红条 + 「数据未同步,见上方红条」,0 pageerror;
  ?date=2026-11-01 → 4,390 单 / 9 异常正常出表,且 URL 参数已生效。
- 前端 eslint 干净,vite build 通过。

风险与回退
- 只增字段与提示,不改任何统计口径;packageCount/shippedOrders 计算逻辑未动。
- 空窗口多一条全表 MAX 查询(13.5s),已用 5 分钟缓存兜住,且只在异常路径触发。
- 回退:单文件 revert 本提交即可,无数据结构变更。
2026-11-02 10:31:11 +08:00
b955e78ba2 Merge pull request 'fix(wst): 用聚水潭状态终态 + 销售出库单判作废/已发' (#93) from yanhui-wst-void-1029 into main 2026-10-29 15:38:51 +08:00
54518ab4d3 fix(wst): 把销售出库单纳入作废判据与停更监控
业务 14:34 点名 9992097 / 9992098 / 9992924 / 9992925 / 9992926 /
9993284 / 9993285 / 9995464 / 9995465「洛宁仓 16 单都是作废订单,为啥还在
考核之内」,并指明「在聚水潭的销售出库单里面找一下这个作废单据」。

## 查出来的事实

这 9 单在库里**三处全部显示「还在发货」**:

  订单表 qmcust      status=Delivering、send_date 空
  销售出库单         status=WaitConfirm(待出库)
  状态镜像表         order_status_name=发货中、logistics=无物流单

不是判据漏了,是**三条数据源全停在作废动作之前**(2026-10-29 15:13 实测):

  jst_Orders             14:45  正常
  qmcust                 13:25  滞后 1.8h
  状态镜像表              11:52  滞后 3.4h
  出库单(聚水潭/奇门)      03:10  滞后 12.0h  ← 作废就落在这张表上

聚水潭的作废落在**出库单** `status='Delete'` 上,而这张表今天凌晨 3 点后
零写入,所以上午作的废一条都没进来

## 改动

1. 新增 `loadOrderIoStatus()`:按 o_id 批量取出库单状态(两表、
   分批 500 / 并发 3),判据是 **「该 o_id 下没有任何非 Delete 的出库单」**。
   - 只对「发货中」生效:全库「出库单全 Delete」的候选单里 127/131
     状态表是「异常」,那批还挂着待处理,删出库单更可能是重开单,
     当成作废剔会让业务在「不计考核」里也看不到 → 丢可见性比漏剔更糟
   - 拆包/重开的单有多张出库单,删一张不算作废(实测 51 单里 7 单是这种)
   - **「没有出库单」绝不判作废**:近 3 天未发单 82%(1467/1790)本来就没出库单
2. 两张出库单表纳入 `loadSourceFreshness()`(用 local_updated / updateTime
   灌库时刻,**不能用 modified**,否则没变更时天天误报)
3. 新增 `freshness.voidJudgeReliable` + hint 明说「作废单/取消单可能判不出来」,
   告诉业务去聚水潭「销售出库单」核对
4. 明细加「销售出库单」列(已作废/待出库/已出库/未建单),导出同步加列

## 验证

- WST 单测 27/27(新增:出库单全删必剔 / 拆包重开不剔 / 异常单不剔 /
  无出库单不剔 / 停更时提示作废判不出来 / 源正常时不误报)
- 后端全量 498/500(2 个既有失败:负缓存 TTL、Windows 文件权限)
- 真实数据:ioVoidSkipped=11(发货中 + 出库单全删),overdue 仍 16 单
- 本地真渲染:表头有「销售出库单」、首行显示「待出库」、
  红条列出 5 个数据源停更状态、**pageerror 0**

## 没解决(已在页面明说,不掩盖)

这 9 单今天仍然判不出作废 —— 数据没进来,判据再准也没用。
根子在 ETL:出库单表停 12 小时。ETL 恢复后判据立即生效,
但那 9 单是否作废仍需 IT 修同步或业务在聚水潭复核。
2026-10-29 15:16:25 +08:00
1139e4c364 fix(wst): 用聚水潭状态终态判作废/已发,修「作废单已发单还在考核里」
业务 2026-10-29 第三次报同一件事:13:00 轮里作废的单、已经发货的单还在考核。
根因不是判定写错,而是**订单两表各自停更**,停更期间聚水潭做的「取消 / 发货」
订单表完全看不到 —— status 仍是 Delivering、send_date 仍是空。

## 现场证据(2026-10-29 13:00 轮)

- 当天 qmcust 停在 07:25(6 小时),13:00 轮 159 单**全部**来自它
- 订单表侧:159 单 status 全 Delivering、send_date 全空、labels 里**没有**
  「发货前售后」⟹ 原来的 `presaleVoid` 判据(订单表 labels 含关键词)完全失效
- 状态镜像表(停在 11:52,比订单表新鲜 4 小时):
  `order_status_name='已取消'` **11 单**,`order_labels` 里才有「发货前售后」
  「已打印被取消」;其余 145 单「发货中」

qmcust 13:25 补数后重算,误判量比想象大得多:
**overdue 159 → 16,作废剔除 195 单、已发剔除 17 单。**

## 改动

判据(新增,排在窗口判断与「不计考核」之前):

| 判据 | 处理 |
|---|---|
| `order_status_name='已取消'` | 作废,剔除(计 `stateVoidSkipped`) |
| `send_time` 有值 | 已发,剔除 |
| `order_status_name='已发货'` | 已发,剔除 |
| `logistic_status_name` ∈ 已揽收/运输中/派送中/已签收/拒收 | 已发,剔除 |

- `loadOaConfirmInfo` → `loadStateInfo`,同一次 IN 多取 4 个语义列,**不增加往返**
- ⚠️ **判据只用 `order_status_name`**:`aftersale_status_name='已作废'` 是「售后单被撤销、
  订单照常发货」,近 2 天 1387 单全是这种,混为一谈会把该考核的单全放跑
- ⚠️ `未揽收` / `无物流单` **不算已发**(后者是连快递单都没录,当天 39/159 单是这种)
- 状态镜像表纳入 `dataSources` 停更监控(它停了,「取消了吗」的依据就过期了)
- 明细/导出新增「聚水潭状态」「物流状态(聚水潭)」「状态表抓取时间」;
  页面「发货状态」列改优先显示聚水潭终态,与订单表不一致时打 ⚠

## 验证

- 后端 `npm run check` 496/498(2 个失败是老问题:负缓存 TTL、Windows 文件权限)
- WST 单测 **25/25**,新增两组:终态剔除(含「售后已作废不能误剔」的反向保护)、
  状态表纳入新鲜度监控
- 真实数据(本地直连生产 MSSQL,2026-10-29 13:00 轮):
  `overdue=16 / stateVoidSkipped=195 / stateShippedSkipped=17`,
  明细里「已取消」残留 **0**;剩余 16 单全是河南洛宁仓「发货中 + 无物流单」的真积压
- 作废证据交叉核对:状态表近 2 天「已取消」59263 单,94% 带「发货前售后」标签,
  与业务口径一致
2026-10-29 13:45:41 +08:00
c0e48688c1 Merge pull request 'feat(wst): 数据源停更熔断——订单表停更时醒目标注,别把「没同步」当「没发货」' (#92) from yanhui-wst-stale-1029 into main 2026-10-29 09:13:26 +08:00
cb7d06c20c feat(wst): 数据源停更熔断——订单表停更时醒目标注,别把「没同步」当「没发货」
## 业务问题

10-28 18:00 轮页面核验出 546 单超时未发,业务核对「基本都发了,怎么会核验出未发」。

## 根因(不是判定写错,是数据源停更)

`jst_Orders` 当时**从 14:40 就停止同步了**(停了 4 小时),停更之后发出的单
`send_date` 一直是空,因此全被判成「未发货」:

| 来源表 | 超时单数 | 该表状态 |
|---|---|---|
| `jst_Orders` | 540 | 最后更新 14:40(停 4 小时) |
| `jst_qmcust_orderlist` | 6 | 17:30 正常 |

两个订单表**各自独立同步**,同一天完全可能一个正常一个停更。原来只拿候选行的
`MAX(updated_at)` 判快照滞后,会被「碰巧新」的行掩盖 —— 必须直接问源表。

## 改动

后端 `warehouseShipTimelinessService.js`:

- 新增 `loadSourceFreshness()`:分别直接查 `jst_Orders.MAX(updateTime)` 与
  `jst_qmcust_orderlist.MAX(local_updated)`(限轮次窗口起 30 天,避免全表扫描),
  两源并行;按 `CANGKU_WST_SOURCE_STALE_MINUTES`(默认 60 分钟)判停更
  - 查询失败或取不到更新时间 → **不判停更**(宁可漏报,不谎报为停更)
- 明细行新增 `src` / `srcLabel` / `sourceStale`;`summary` 新增 `sourceStaleUnshipped`
- `freshness.stale` 改为「候选行滞后 **OR** 任一源停更」;`hint` 说清停更源、
  停更时刻、以及各源各贡献多少单(不能只写「这张表」)
- 导出数据带 `dataSources`,Excel 脱离页面也有上下文
- 响应新增 `dataSources` 数组(每源 label / lastUpdate / lagMinutes / stale)

前端 `WarehouseShipTimeliness/index.jsx`:

- 红条 Alert:「N 单所在订单表已停止同步,这些单很可能已经发货」(error 级),
  描述里逐源列出「最后同步 14:40:05(已 3.9 小时)」
- 超时统计卡下方小字:「其中 N 单数据未同步」(悬停有说明)
- 明细「内部单号」旁「未同步」红标签 + tooltip,一眼看出哪几行不可信
- 导出新增「数据源 / 数据源是否停更」两列(`是(该单可能已发)`)

## 验证

- 后端 `npm run check`:**494/496**,2 个失败是既有环境问题(负缓存 TTL 计时、
  Windows 文件权限 0o600),改动前同样失败
- `warehouseShipTimeliness.test.js` **23/23** 通过(含新增「停更表超时单必须打标
  并计入 sourceStaleUnshipped」用例)
- 本地真渲染(Playwright + 手签 token,localhost:5173):
  - 真数据:13:00 前 `notStarted` 正常展示「—」,无 pageerror
  - mock 停更数据:红条 / 逐源行 / 统计小字 / 3 行「未同步」标签全部渲染,无 pageerror
- 真实接口 10-28 13:00 轮:`dataSources` 正确识别 `jst_Orders` 停更(滞后 96 分钟)
  而 qmcust 正常;`sourceStaleUnshipped=1146` 与明细逐行打标同源同口径

## 风险与回退

- 只新增字段与展示,**不改动分轮、起算点、候选池口径** —— 超时单量本身不变
- 阈值可用 `CANGKU_WST_SOURCE_STALE_MINUTES` 调;不配默认 60 分钟
- 低峰期(凌晨)可能出现「1 小时无新单」被判停更,但页面只在 13:00 / 18:00
  核验时刻展示超时数据,这两个时点 1 小时不同步即属异常
- 回退:revert 本提交即可,无数据迁移、无新表、无新依赖
2026-10-29 08:25:41 +08:00
6b6dfdd1da Merge pull request 'fix(wst): 起算点改为「审核时间 / 订单 modified 取较晚者」,修 13:00 轮 65 单假超时' (#91) from yanhui-wst-modified-1028 into main 2026-10-28 17:07:11 +08:00
983fee0d8a fix(wst): 起算点改为「审核时间 / 订单 modified 取较晚者」,修 13:00 轮 65 单假超时
## 业务问题

业务举证:13:00 轮不该有那么多单 —— 「9 点前的单 13:00 前已经发完了」。
线上实测 65 单,逐单核对全部不该在 13:00 轮。

## 根因(两个,都指向「起算点取错」)

### ① 状态表的审核时间会严重滞后

业务给的举证单 9978643:

| 字段 | 值 |
|---|---|
| `qmcust.modified` | **2026-10-28 14:52:29** |
| 聚水潭页面真实审核时间 | **2026-10-28 14:52:28**(秒级吻合) |
| 状态表 `last_oa_confirm_time` | 2026-10-27 17:08:43(旧了一天) |
| 状态表 `query_time` | 2026-10-28 10:29:11(10:29 后没再抓) |

只信状态表 → 这单被当成「10-27 就审核了」,混进 13:00 轮超时,冤枉仓库。

### ② 审核时间为空的单回退 created,把今天的单按历史单算

65 单里 57 单状态表审核时间为 NULL。回退 `created` 后:

| o_id | created | modified | 回退后算成 | 真实 |
|---|---|---|---|---|
| 9964841 | 10-26 17:22 | **10-28 13:40** | 10-26 审核 → 进 13:00 轮 | 今天下午才审核 |
| 9949424 | 10-25 17:03 | **10-28 13:50** | 同上 | 同上 |
| 9983773 | 10-27 23:23 | **10-28 13:59** | 同上 | 同上 |

57 单的 `modified` 全部落在今天 13:40~15:03 —— 都是今天下午批量审核的。

## 改动

- **起算点** = `max(状态表 last_oa_confirm_time, 订单表 modified, 订单表 created)`
  - 取较晚者:修状态表滞后
  - 纳入 created:个别单 `modified` 早于 `created`(脏数据),起算点不该早于下单时刻
  - `benchmarkSource` 透出 `oa_confirm` / `modified` / `created`,页面 tooltip 说明来源
- **新增 `laterOf()`**:同格式 `YYYY-MM-DD HH:mm:ss` 直接字典序比较,不转 Date(避开时区坑)
- **主查询 SQL 增加 `x.modified`** 列(订单两表都有,无需额外查询)

## 性能修复(同批,线上 /list 曾 300s 超时)

上版状态表查询**串行 9 批实测 135s**,叠加主查询 63~105s 直接把接口顶过 300s,
页面打不开(实测 curl `--max-time 300` 超时)。改为**并发 6**:

| 方式 | 耗时 |
|---|---|
| 串行 9 批 | 135s |
| 并发 3 | 28.8s |
| **并发 6(本版)** | **10~15s** |

并发 6 是生产实测的安全值(单批约 15s,不至于把 402 万行视图的连接池打爆)。

## 改后效果(10-28 17:00 真实库)

| 轮次 | 改前 | 改后 |
|---|---|---|
| 13:00 轮 | 65 单 | **0 单** |
| 18:00 轮 | — | 927 单(全部今天 07:59~16:00 审核,无历史单) |

- `fallbackToCreated` 从 57 → **0**(不再有回退单)
- 9978643 ✅ 已剔除
- 两个轮次都验证「今天窗口上界之后起算的 = 0」

## 验证

- 后端 `npm run check`:**493/495**(2 个失败是既有环境问题:TTL 计时、Windows 权限,改动前同样失败)
- 新增 2 个测试锁定该口径:
  - `modified` 晚于窗口 → 必须剔除(9978643 那类单)
  - 状态表审核时间晚于 `modified` → 以状态表为准
  - `modified` 早于 `created` → 取 `created`,不倒退
- 前端 lint + build 通过(35.2s)
- 真实库双轮验证通过

## 风险与回退

- **`modified` 被客服改单/改备注刷新**时起算点会推后 → 少报超时(放行方向,不冤枉仓库)。
  业务已知悉并接受;这是当前唯一能拿到「今天真实审核时间」的可靠字段。
- 回退方式:`git revert <merge commit>` 即回到只认状态表审核时间的版本。
2026-10-28 17:02:54 +08:00
85c48ebe77 Merge pull request 'fix(wst): 起算点改回「最后审核时间」,并剔除订单表漏回写的已发单' (#90) 2026-10-28 15:40:56 +08:00
e7e0b96b46 fix(wst): 起算点改回「最后审核时间」,并剔除订单表漏回写的已发单
业务 2026-10-28 下午拿 9837824 指出:页面「创建时间」显示 10-19 23:44,
而该单实际是 10-28 09:58:42 才审核。逐字段核对确认起算点口径错了 ——
上午那版按 jst_Orders.created 算,等于把客服审核积压算到仓库头上。

- 起算点 = 状态表 last_oa_confirm_time(业务选「最后审核时间」);
  取不到审核时间的单回退 created,页面 / 导出 / 钉钉该列打 *
- 已发判定补一条兜底:订单表 send_date 空、但状态表 send_time 有值的按已发剔除
  (实测 144 单里 6 单属此类,且有揽收轨迹)
- 明细与导出列改为「审核时间 / 下单时间 / 发货时间」并列,去掉旧「创建时间」列
- 钉钉明细第五段由「创建」改回「审核」;抬头「核验 XX 前创建」改「前审核」
- 回归测试同步改断言;stub 增加审核时间查询分支(默认空 = 全量回退 created)

实测(10-28 13:00 轮):599 → 144(按审核时间分轮)→ 138(剔除漏回写已发单)。
599 单里 376 单是当天 08:10~10:30 才批量审核的积压单,491 单其实已有运单号。

验收:后端 check 491/493(2 个失败为既有 Windows 权限 / TTL 用例,改动前同样失败);
前端 eslint 通过、build 23.92s 通过;本地真渲染 138 单、表头含「审核时间 / 下单时间」、
回退单带 *、无 pageerror。
2026-10-28 15:34:29 +08:00
6a5f6e8ae0 refactor(wst): 页面名去掉「24 小时」,改为「发货时效(到点未发即超时)」
规则完全不动,只改名字,消除误导。

## 为什么改

页面原名「仓储中心 24 小时发货时效」,但判定规则是「到 13:00 / 18:00
核验时刻仍未发货即超时」,**没有满 24 小时的门槛**(业务 2026-10-20 已三次纠偏定版)。
名字和规则打架,导致看的人以为「不满 24 小时不该算超时」。

实测例子:10-27 16:00 创建的单,今天 13:00 核验时只等了 **21 小时**就被判超时;
13:00 轮 599 单里有 416 单属于 10-27 16 点后创建。业务看到就问「创建时间都在 7 点后,
为什么算超时」—— 其实是名字里的「24 小时」在误导(那些是**昨天**晚上的单,
不是今天的)。

## 改了什么

用户可见(2 处):
- 侧栏菜单:`仓储中心24小时发货时效` → `仓储中心发货时效`
  (不加括号:侧栏现有最长 label 12 字,加了会到 18 字溢出)
- 页面标题:`仓储中心 24 小时发货时效` → `仓储中心发货时效(到点未发即超时)`

其余为注释同步(8 个文件),代码逻辑与判定口径**零改动**:
`warehouseShipTimelinessRegistry/Service/NotifyJob/NotifySettings`、
`warehouseLogisticsExceptionRegistry`、`frontend/api/warehouseShipTimeliness`、`backend/index`。

## 不变的部分

- 核验时点、窗口上界(07:00 / 16:00)、仓级例外(山东 15:00、洛宁 13:00)
- 数据源与起算点(订单两表 + `created`)
- 钉钉推送抬头本来就是「【仓储中心发货时效】」,不用改

## 验证

- 前端 eslint 通过、`npm run build` 通过(31.86s)
- 浏览器真渲染(本地 5173,等足 75 秒数据返回):
  - 标题 = `仓储中心发货时效(到点未发即超时)`
  - 侧栏项 = `仓储中心发货时效`,全页 `body` 内已无「24小时」字样
  - 数据正常渲染:超时未发 599 单 / 不计考核 849 / 涉及仓库 8 个 / 最久未发 13 天
  - 明细「创建时间」列完整显示 `2026-10-27 19:xx` 这类日期,不存在时区错位
  - 无 pageerror
- 后端 `npm run check`:本次只动注释,不影响
2026-10-28 14:30:54 +08:00
6c2686784d Merge pull request #88: 发货时效改用订单两表 + 起算点改为订单创建时间 2026-10-28 13:08:28 +08:00
776a2cbde2 feat(wst): 发货时效改用订单两表 + 起算点改为订单创建时间
业务 2026-10-28 定版:「核验抓取的销售订单表是错误的,应该在数据库抓
jst_Orders(订单)+ jst_OrderItem(明细),审核时间就是 jst_Orders 里的创建时间」。

## 为什么换数据源(状态镜像表的硬伤,均有实测)

1. `send_time` 漏回写:近 7 天「状态表说发货中+未发」的 4157 单里,
   订单表已有 `send_date` 的 563 单、status 已是 Sent 的 492 单 —— 发了还算超时。
2. 被合并 / 拆单父单不回写:89 + 755 单被冤枉。
3. 会整批停更:2026-10-27 11:54:59 之后 6.8 小时零写入,18:00 轮推出的
   34 单里混着已发货的。
4. 两张表发货时间其实同源:27387 单逐条比对**零偏差** ⟹ 订单表才是权威。

## 改了什么

后端
- 主查询改打 `rpt.jst_Orders` + `rpt.jst_qmcust_orderlist`(店铺互斥,UNION ALL,
  按 o_id 去重),SQL 侧过滤 `send_date IS NULL` + `status IN (Delivering/WaitConfirm/Question)`。
- 起算点由状态表 `last_oa_confirm_time` 改为订单表 `created`;
  实测 created 100% 早于审核时间,正常单差 7~40 分钟,夜间下单次日审的单差 6~9 小时
  —— 换口径后单量与「已等时长」都会变大,业务已知悉。
- 仓库归属:主查询只回 `wms_co_id`,Node 侧用仓表缓存换仓名再走 `resolveCenter()`
  (实测 SQL 里 LEFT JOIN 仓表会把查询从 28s 拖到 61~105s)。
- `OPTION (RECOMPILE)` + 时间字面量:qmcust 不加 RECOMPILE 实测 33~50s,加上 0.4s。
- 删除 `backfillOrderFacts()` 与 `mapLimit()`(起算点/状态/仓名已由主查询一次取全)。
- 不再按 `is_split / is_merge` 过滤 —— 实测 `is_split=1` 恰是拆单**子单**
  (同一 so_id 多行、各自要发货,近 30 天 1096 行),老逻辑 `is_split=0` 会把它们全排掉。
- 钉钉明细第 5 段「审核 HH:mm」→「创建 HH:mm」,无值文案「未审核」→「无创建时间」。

前端
- 明细/挂起清单/导出列「审核时间」→「创建时间」,Tooltip 与说明文案同步改写;
- 顶部说明补「数据源 = 订单两表」「已发未发取 send_date」;
- 「已支付待审核」统一为「待审核」(新数据源里就是 WaitConfirm)。

测试
- 两个测试文件的桩改成「订单两表 UNION」的返回形状,断言改为
  created 起算、候选状态白名单、SQL 必须带 RECOMPILE / 不含状态镜像表 / 不 JOIN 仓表。

## 验证

- `npm --prefix backend run check`:491/493 通过。2 项失败是既有环境问题:
  `resilientSecretStore`(Windows 文件权限 0o666≠0o600)、
  `cloudDatabaseConfigCache` 负缓存 TTL(依赖隧道状态),均与本改动无关,单独跑同样失败。
- 前端 eslint + build 通过。
- 真实库:NOON 1553 单 / AFTERNOON 1866 单(本地 2026-10-28),
  数据质量:无仓名 0 / 时间异常 0 / 含 undefined|null|NaN 0;
  单次查询耗时 35~38s(30 天护栏,冷缓存)。
- 浏览器真渲染(playwright,强制 round=NOON):
  表头 `…发货时间 / 创建时间 / 付款时间…`、轮次提示「核验今天 07:00 前创建的订单」、
  「导出明细」导出 CSV 表头含「创建时间」共 1551 行数据 + 1 行表头,无 pageerror。

## 风险与回退

- 口径变化是可感知的:单量上升,夜间下单/次日审核的单「已等时长」增加 6~9 小时,
  属业务确认后的预期结果。
- 状态表「售后已作废」判据随换源放弃(实测在「发货中+未发」里只命中 4 单),
  这类单现在按正常单算超时;如业务反馈,可单独补查。
- 回退:单文件回滚本提交即可,无数据迁移、无配置变更。
2026-10-28 11:34:45 +08:00
913827000a Merge pull request 'feat(wst): 超时未发加「导出明细」+ 武进安能不考核 + 钉钉明细带快递;修复推送时区' (#87) from yanhui-wst-export-20261027 into main 2026-10-27 16:33:03 +08:00
f749bcc03c feat(wst): 超时未发加「导出明细」+ 武进安能不考核 + 钉钉明细带快递;修复推送时区
① 导出明细(业务要求:超时未发要能导出核对)
  · 新增 GET /api/warehouse-ship-timeliness/export:不分页、不截断,返回本轮全部行
  · 页面「超时未发货订单」卡片右上角加「导出明细」下拉(Excel / CSV)
  · 选中某个仓时只导该仓(前端按 centerKey 过滤,与后端主仓归属同一套)
  · 导出列比页面多「快递公司 / 运单号」(追单要看有没有打单),单号一律转字符串
    避免 Excel 显示成科学计数法

② 缓存改成「存全量、出口截断」
  · 缓存键去掉 limit(原为企业级教训:WLE 核验缓存早就这么改了)
  · 页面 limit=1000、导出要全量,旧实现两边永不命中 → 每点一次导出重查一遍视图
  · 实测:首次查询 86.3s,导出命中缓存 5ms
  · 顺带修 detailTotal / heldTotal:明细被截断时页面仍显示真实总数,
    不再把「只显示前 1000 条」写成「一共就这么点」

③ 不考核快递追加「武进安能」(业务 2026-10-27)
  · 包含匹配,同时覆盖「武进安能大件」
  · ⚠️ 严格不泛化成「安能」:实测库里带「安能」的有 8 个写法,
    常州安能新 4207 单 / 安能物流 110 单等仍照旧考核(与
    warehouseLogisticsExceptionRegistry 同一口径,那里也写着这句)

④ 钉钉推送明细行在「线上单号」后加「快递」
  · 一行 = 仓|内部单号|线上单号|快递|审核 时间|已等 X 小时
  · 群里直接能判断是哪家快递、要不要走站点,不用回页面逐单点开
  · 「已剔除 N 单不考核快递」的快递清单改成读服务层,别再各写一份

⑤ 修复推送任务时区(生产容器 /etc/timezone = Etc/UTC)
  · 症状:pushShipTimelinessNotify 把裸 new Date() 传给 getShipTimeliness,
    而 service / registry 内部用 getDate()/getHours() 直读 →
    北京 13:05 = UTC 05:05,被判「未到 13:00 核验时间」→ 两轮推送永不触发
  · 改法:rawNow(真实时刻,给 Intl / toISOString)+ bjNow(平移后,
    给本地 getter 与 service 调用)双轨,与 2026-10-21 那次同源问题的修法一致
2026-10-27 16:29:08 +08:00
33bfc7eacc Merge pull request 'feat(wst): 发货时效两轮核验完成后各推一次钉钉群' (#86) from yanhui-wst-notify-20261027 into main 2026-10-27 15:45:40 +08:00
23 changed files with 3409 additions and 996 deletions

View File

@ -1,7 +1,7 @@
'use strict'; 'use strict';
/** /**
* 仓储中心 24 小时发货时效 —— HTTP 路由(2026-10-20 新增) * 仓储中心发货时效 —— HTTP 路由(2026-10-20 新增)
* ──────────────────────────────────────────────────────────────────────────── * ────────────────────────────────────────────────────────────────────────────
* GET /api/warehouse-ship-timeliness/list * GET /api/warehouse-ship-timeliness/list
* query: * query:
@ -11,6 +11,10 @@
* GET /api/warehouse-ship-timeliness/rounds * GET /api/warehouse-ship-timeliness/rounds
* 只返回今日两轮的描述(页面顶部提示用,不打订单表,秒回) * 只返回今日两轮的描述(页面顶部提示用,不打订单表,秒回)
* *
* GET /api/warehouse-ship-timeliness/export (2026-10-27 新增)
* 「超时未发」明细导出:不分页、不截断,返回本轮全部行(与 /list 同一份缓存)
* query: round / force
*
* ── 两轮核验完成后推钉钉群(2026-10-27 新增)──────────────────────────────── * ── 两轮核验完成后推钉钉群(2026-10-27 新增)────────────────────────────────
* GET /api/warehouse-ship-timeliness/notify/settings 读配置(加签密钥只回掩码) * GET /api/warehouse-ship-timeliness/notify/settings 读配置(加签密钥只回掩码)
* PUT /api/warehouse-ship-timeliness/notify/settings 保存配置(加签密钥留空 = 不变) * PUT /api/warehouse-ship-timeliness/notify/settings 保存配置(加签密钥留空 = 不变)
@ -21,7 +25,10 @@
*/ */
const express = require('express'); const express = require('express');
const { getShipTimeliness } = require('../services/warehouseShipTimelinessService'); const {
getShipTimeliness,
listShipTimelinessExportRows,
} = require('../services/warehouseShipTimelinessService');
const { describeRounds, CENTERS } = require('../services/warehouseShipTimelinessRegistry'); const { describeRounds, CENTERS } = require('../services/warehouseShipTimelinessRegistry');
const { const {
getShipTimelinessNotifyAdminConfig, getShipTimelinessNotifyAdminConfig,
@ -73,6 +80,23 @@ router.get('/rounds', async (_req, res) => {
} }
}); });
/**
* 导出「超时未发」明细:**不分页、不截断**,返回本轮考核口径内的全部行。
*
* query: round(同 /list)、force=1(绕过缓存重查)
*
* 与 /list 共用 getShipTimeliness(同一份缓存),所以页面刚刷过时这里是秒回。
* 前端拿到 rows 后按选中的仓在前端过滤 —— 口径与页面完全一致,不需要第二套 filter。
*/
router.get('/export', async (req, res) => {
try {
const data = await listShipTimelinessExportRows(req.query || {});
res.json({ success: true, data });
} catch (error) {
sendError(res, error, '导出超时未发明细失败');
}
});
// ── 两轮核验完成后推钉钉群 ────────────────────────────────────────────────── // ── 两轮核验完成后推钉钉群 ──────────────────────────────────────────────────
// 读配置:加签密钥只回掩码 + 是否已配置,明文永不出后端 // 读配置:加签密钥只回掩码 + 是否已配置,明文永不出后端

View File

@ -76,6 +76,24 @@ function isTransientError(error) {
); );
} }
/**
* ⚠️ `options.timeoutMs` 是个「看着能用、其实没人读」的参数 —— 历史踩坑,留个告警别再犯。
*
* 根因:mssql 12.x 上请求级 `request.timeout` 不生效,超时只能靠**池配置级** requestTimeout,
* 而共享池(query())的池级超时在 pool 创建时就定死了,调用方改不了。想放宽只有两条路:
* · querySlow(sql, params, { connectRequestTimeoutMs }) —— 临时独立连接,可任意放宽;
* · query(sql, params, { requestTimeout }) —— 只对独立连接路径(queryWithFreshConnection)有意义。
* 2026-11-14 实况:WLE 服务层两处 `{ timeoutMs: 240000 }` 想着「给足 4 分钟」,
* 实际一路按 60s/300s 跑,11-13 那轮钉钉推送就因此超时没推出去。
*/
function warnLegacyTimeoutOption(options, caller) {
if (!options || options.timeoutMs === undefined) return;
console.warn(
`[CloudDB] ${caller} 收到无效参数 timeoutMs=${options.timeoutMs}(已被忽略,不会放宽超时);`
+ '需要更长超时请改用 querySlow + connectRequestTimeoutMs'
);
}
function isTruthy(value) { function isTruthy(value) {
return value === true || value === 1 || String(value || '').toLowerCase() === 'true' || String(value || '') === '1'; return value === true || value === 1 || String(value || '').toLowerCase() === 'true' || String(value || '') === '1';
} }
@ -1036,6 +1054,16 @@ const resetPool = async () => {
* @param {object} params - 命名参数对象 * @param {object} params - 命名参数对象
*/ */
const query = async (sqlText, params = {}, options = {}) => { const query = async (sqlText, params = {}, options = {}) => {
warnLegacyTimeoutOption(options, 'query()');
// 🔥 2026-11-17:`requestTimeout` 只写 request.timeout(**请求级**),mssql 12.x 上不生效,
// 实际仍按共享池创建时定死的池级 requestTimeout(默认 60s)掐断 —— MKH-BOM 的订单大表
// 查询就是因此「代码里写 180s、实际 60s 必超时并降级」,页面待发订单量长期为 0。
// 需要真正放宽超时的调用方,显式传 `freshConnection: true` 走临时独立连接
// (池级超时随 connectRequestTimeoutMs 任意放大),比让调用方各自调用 querySlow 更好维护,
// 也让单测只需 mock query() 一个入口。
if (options && options.freshConnection === true) {
return queryWithFreshConnection(sqlText, params, options);
}
const maxAttempts = parsePositiveInt(options.maxAttempts, 2); const maxAttempts = parsePositiveInt(options.maxAttempts, 2);
for (let attempt = 1; attempt <= maxAttempts; attempt += 1) { for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
@ -1072,6 +1100,7 @@ const query = async (sqlText, params = {}, options = {}) => {
}; };
const queryWithFreshConnection = async (sqlText, params = {}, options = {}) => { const queryWithFreshConnection = async (sqlText, params = {}, options = {}) => {
warnLegacyTimeoutOption(options, 'queryWithFreshConnection()');
const maxAttempts = parsePositiveInt(options.maxAttempts, 2); const maxAttempts = parsePositiveInt(options.maxAttempts, 2);
for (let attempt = 1; attempt <= maxAttempts; attempt += 1) { for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {

View File

@ -69,6 +69,9 @@ const {
const { const {
startMkhReplenishAlertScheduler, startMkhReplenishAlertScheduler,
} = require('./jobs/mkhReplenishAlertJob'); } = require('./jobs/mkhReplenishAlertJob');
const {
startMkhBomPrewarmScheduler,
} = require('./jobs/mkhBomPrewarmJob');
const { const {
startWarehouseLogisticsExceptionNotifyScheduler, startWarehouseLogisticsExceptionNotifyScheduler,
} = require('./jobs/warehouseLogisticsExceptionNotifyJob'); } = require('./jobs/warehouseLogisticsExceptionNotifyJob');
@ -681,7 +684,7 @@ async function startServer(options = {}) {
cubejsApp.use('/api/product-monitoring', authMiddleware, productMonitoringRoutes); cubejsApp.use('/api/product-monitoring', authMiddleware, productMonitoringRoutes);
cubejsApp.use('/api/modular-stock-monitor', authMiddleware, modularStockMonitorRoutes); cubejsApp.use('/api/modular-stock-monitor', authMiddleware, modularStockMonitorRoutes);
cubejsApp.use('/api/mkh-bom', authMiddleware, mkhBomRoutes); cubejsApp.use('/api/mkh-bom', authMiddleware, mkhBomRoutes);
// 仓储中心 24 小时发货时效(2026-10-20 新增):列表左侧侧栏,11 个主仓超时未发 // 仓储中心发货时效(2026-10-20 新增):列表左侧侧栏,11 个主仓超时未发
cubejsApp.use('/api/warehouse-ship-timeliness', authMiddleware, warehouseShipTimelinessRoutes); cubejsApp.use('/api/warehouse-ship-timeliness', authMiddleware, warehouseShipTimelinessRoutes);
// 仓储中心物流转运异常(2026-10-21 新增):每日 09:00 核验前一日已发货单的物流记录 // 仓储中心物流转运异常(2026-10-21 新增):每日 09:00 核验前一日已发货单的物流记录
cubejsApp.use('/api/warehouse-logistics-exception', authMiddleware, warehouseLogisticsExceptionRoutes); cubejsApp.use('/api/warehouse-logistics-exception', authMiddleware, warehouseLogisticsExceptionRoutes);
@ -800,6 +803,9 @@ async function startServer(options = {}) {
startGoodsFirstSeenScheduler(); startGoodsFirstSeenScheduler();
startAlibaba1688ImageSearchExpiryScheduler(); startAlibaba1688ImageSearchExpiryScheduler();
startMkhReplenishAlertScheduler(); startMkhReplenishAlertScheduler();
// MKH-BOM 页面索引预热:订单两表全表扫很贵(冷查分钟级),必须由后台保持热态,
// 不能让「打开页面 / F5」的用户去等(见 jobs/mkhBomPrewarmJob.js 文件头)
startMkhBomPrewarmScheduler();
startWarehouseLogisticsExceptionNotifyScheduler(); startWarehouseLogisticsExceptionNotifyScheduler();
startShipTimelinessNotifyScheduler(); startShipTimelinessNotifyScheduler();
startDailyInventorySnapshotScheduler(); startDailyInventorySnapshotScheduler();

View File

@ -0,0 +1,90 @@
'use strict';
/**
* MKH-BOM 页面索引后台预热。
*
* 背景(2026-11-17 排查结论):
* 这个页面除了「订单两表」之外,全部数据都在内存里算。而订单查询是
* `skus LIKE '%MKH%'` 前导通配 → 必然全表扫;副本库又慢到
* `rpt.jst_Orders` 158 万行**光 COUNT(*)** 要 152.8s(≈1 万行/秒)。
* 于是「谁把缓存打穿,谁就等 2~8 分钟」。
*
* 旧行为之所以每次打开都慢:
* 前端「首屏 + 每 2 分钟」都带 `fresh=1` → 后端清运营缓存 → 必冷查。
*
* 现在的分工:
* · 请求路径只读缓存(过期了也先返回旧值,见 loadOrderIndex 的 stale-while-revalidate);
* · 只有「同步最新数据」按钮会清缓存强制重读;
* · **索引新鲜度由这个任务负责**:启动 20 秒后跑一次,之后每 20 分钟跑一次,
* 始终赶在 30 分钟 TTL 到期之前把订单索引换掉。
*
* 配置(都不用发版):
* · MKH_BOM_PREWARM_INTERVAL_MINUTES 预热间隔,默认 20
* · MKH_BOM_PREWARM_DISABLED=true 关闭(排查 / 本地开发时用)
*/
const cron = require('node-cron');
const { prewarmMkhBomIndex } = require('../services/mkhBomService');
const TIMEZONE = 'Asia/Shanghai';
const DEFAULT_INTERVAL_MINUTES = 20;
// 启动后等一会儿再跑:别和数据库连接自检、其它启动预热抢业务库
const STARTUP_DELAY_MS = 20 * 1000;
// 单飞:上一轮没跑完(冷查可能好几分钟)就不叠加下一轮
let running = false;
async function runMkhBomPrewarm(source = 'scheduled') {
if (running) return { skipped: true, reason: 'running' };
running = true;
try {
const result = await prewarmMkhBomIndex();
console.log(
`[MkhBomPrewarm] ${source} 完成,耗时 ${Math.round(result.elapsedMs / 1000)}s (${result.steps.join(', ')})`
);
return result;
} catch (error) {
// 预热失败不影响功能:下一次请求会自己撞冷查(只是慢一点)
console.warn(`[MkhBomPrewarm] ${source} 失败:`, error.message || error);
return { error: error.message || String(error) };
} finally {
running = false;
}
}
function resolveIntervalMinutes() {
const raw = Number.parseInt(process.env.MKH_BOM_PREWARM_INTERVAL_MINUTES, 10);
if (!Number.isFinite(raw) || raw < 5 || raw > 59) return DEFAULT_INTERVAL_MINUTES;
return raw;
}
function startMkhBomPrewarmScheduler() {
const disabled = String(process.env.MKH_BOM_PREWARM_DISABLED || '').trim().toLowerCase() === 'true';
if (disabled) {
console.log('[Scheduler] MKH-BOM 索引预热已禁用');
return;
}
const minutes = resolveIntervalMinutes();
// node-cron 的 */n 在 n 不整除 60 时会在跨小时处多跑一次,20 分钟整除,没问题
const expression = `*/${minutes} * * * *`;
cron.schedule(expression, () => {
runMkhBomPrewarm('interval').catch(() => {});
}, { timezone: TIMEZONE });
const startupTimer = setTimeout(() => {
runMkhBomPrewarm('startup').catch(() => {});
}, STARTUP_DELAY_MS);
if (typeof startupTimer.unref === 'function') startupTimer.unref();
console.log(`[Scheduler] MKH-BOM 索引预热已注册: 启动后 ${STARTUP_DELAY_MS / 1000}s 跑一次,之后 ${expression} (${TIMEZONE})`);
}
module.exports = {
DEFAULT_INTERVAL_MINUTES,
STARTUP_DELAY_MS,
TIMEZONE,
resolveIntervalMinutes,
runMkhBomPrewarm,
startMkhBomPrewarmScheduler,
};

View File

@ -6,6 +6,8 @@
* 业务口径(2026-10-22 定稿): * 业务口径(2026-10-22 定稿):
* ① 每天 09:10(核验 09:00 之后)把**当天核验批次**的异常情况发到指定钉钉群; * ① 每天 09:10(核验 09:00 之后)把**当天核验批次**的异常情况发到指定钉钉群;
* **0 条也推**(群里看到「本批 0 异常」= 任务没挂)。 * **0 条也推**(群里看到「本批 0 异常」= 任务没挂)。
* ⚠️ 失败必须重试(2026-11-11 加):09:10 起 30 分钟内每 5 分钟再试一次,成功即停;
* 窗口过了不再补推(上午的数据下午才发会误导业务)。见 `resolveScheduledPushDecision`。
* ② 不发 .xlsx 附件 —— 群机器人 webhook 发不了文件,业务也确认群里看文本就够。 * ② 不发 .xlsx 附件 —— 群机器人 webhook 发不了文件,业务也确认群里看文本就够。
* 内容 = 汇总(发货/异常/异常率/分类型/分仓)+ 前 N 条明细 + 页面链接。 * 内容 = 汇总(发货/异常/异常率/分类型/分仓)+ 前 N 条明细 + 页面链接。
* N 由页面配置(默认 30,上限 50);要全部明细就点链接去页面导出 Excel。 * N 由页面配置(默认 30,上限 50);要全部明细就点链接去页面导出 Excel。
@ -20,6 +22,9 @@
* 关键词一般是「异常」,缺了会被拒(errcode 310000)。 * 关键词一般是「异常」,缺了会被拒(errcode 310000)。
* ④ 一天只推一次:状态存 system_config,按「推送日(北京时间)」去重, * ④ 一天只推一次:状态存 system_config,按「推送日(北京时间)」去重,
* 服务重启不会重复轰炸;手动「立即推送」才强制重发。 * 服务重启不会重复轰炸;手动「立即推送」才强制重发。
* ⑤ 数据新鲜度必须进正文(2026-11-11 加):只要算出异常,就要说明物流快照
* 是否覆盖本轮核验时刻、是否过旧 —— 否则「990 单 100% 异常」到底是真异常
* 还是镜像表停在昨天,群里看不出来。见 `buildFreshnessWarning`。
* *
* 时区:生产容器是 UTC,核验批次和「到点没有」全部用 Asia/Shanghai 判断。 * 时区:生产容器是 UTC,核验批次和「到点没有」全部用 Asia/Shanghai 判断。
*/ */
@ -42,6 +47,32 @@ const DEFAULT_TICK_CRON = '* * * * *';
// 钉钉 text 上限 20000 字节;留 300 字节给「已精简」尾巴,避免临界失败 // 钉钉 text 上限 20000 字节;留 300 字节给「已精简」尾巴,避免临界失败
const SAFE_CONTENT_BYTES = MAX_CONTENT_BYTES - 300; const SAFE_CONTENT_BYTES = MAX_CONTENT_BYTES - 300;
// 🔥 2026-11-11 加:推送失败要重试,不能「一天只有一次机会」。
// 实况:11-11 09:10 那次撞上业务库连不上(状态里 `Failed to connect to 218.93.9.21:1433`),
// 老逻辑只在 `HH:mm === sendTime` 这一分钟内跑一次,失败后当天彻底不推 —— 群里一整天没消息。
// 现在改成:从推送时刻起 `RETRY_WINDOW_MINUTES` 分钟内,每隔 `RETRY_INTERVAL_MINUTES` 分钟再试,
// 成功即停(`lastSentDate` 落库后后续 tick 自动 skip),窗口过了就不再补(避免上午的数据下午才发)。
// 两个值都可用环境变量覆盖,现网想调不用改前端配置、也不用发版。
const DEFAULT_RETRY_WINDOW_MINUTES = 30;
const DEFAULT_RETRY_INTERVAL_MINUTES = 5;
function readPositiveMinutes(value, fallback, max) {
const num = Number(value);
if (!Number.isFinite(num) || num <= 0) return fallback;
return Math.min(Math.round(num), max);
}
const RETRY_WINDOW_MINUTES = readPositiveMinutes(
process.env.WLE_NOTIFY_RETRY_WINDOW_MINUTES,
DEFAULT_RETRY_WINDOW_MINUTES,
12 * 60
);
const RETRY_INTERVAL_MINUTES = readPositiveMinutes(
process.env.WLE_NOTIFY_RETRY_INTERVAL_MINUTES,
DEFAULT_RETRY_INTERVAL_MINUTES,
RETRY_WINDOW_MINUTES
);
let tickRunning = false; let tickRunning = false;
function pad2(value) { function pad2(value) {
@ -72,6 +103,66 @@ function chinaHourMinute(date = new Date()) {
}).format(base); }).format(base);
} }
/** 'HH:mm' → 当天第几分钟(09:10 → 550)。非法输入返回 null,调用方按「不跑」处理 */
function minuteOfDay(hhmm) {
const match = /^([01]\d|2[0-3]):([0-5]\d)$/.exec(String(hhmm || '').trim());
if (!match) return null;
return Number(match[1]) * 60 + Number(match[2]);
}
/**
* 定时器每一分钟问一次「现在该不该推」。纯函数,便于把时间窗口/节流的边界钉死在单测里。
*
* 返回 `{ run, reason, pushDate, attempt }`:
* · `already_sent_today` 今天已推成功 → 不再动(重试自然也停)
* · `before_time` 还没到配置的推送时刻
* · `window_closed` 已过「推送时刻 + 重试窗口」,不再补推(避免 10 点失败、下午才发出去)
* · `wait_interval` 上一轮失败距现在不到重试间隔,等着
* · `first_round` 到点第一次跑
* · `retry` 上一轮失败后的第 N 次重试
*
* ⚠️ 窗口**不跨日**:`sendTime + window` 超过 23:59 就截到当天最后一分钟。
* 跨日会让 `pushDate` 换天,去重键(`lastSentDate`)跟着变,容易出现同一天推两遍。
*/
function resolveScheduledPushDecision(options = {}) {
const now = options.now instanceof Date ? options.now : new Date(options.now ?? Date.now());
const pushDate = chinaDateKey(now);
const state = options.state && typeof options.state === 'object' ? options.state : {};
const windowMinutes = readPositiveMinutes(options.retryWindowMinutes, RETRY_WINDOW_MINUTES, 12 * 60);
const intervalMinutes = readPositiveMinutes(options.retryIntervalMinutes, RETRY_INTERVAL_MINUTES, windowMinutes);
if (state.lastSentDate === pushDate) {
return { run: false, reason: 'already_sent_today', pushDate, attempt: 0 };
}
const nowMinute = minuteOfDay(chinaHourMinute(now));
const startMinute = minuteOfDay(options.sendTime);
if (nowMinute === null || startMinute === null) {
return { run: false, reason: 'bad_send_time', pushDate, attempt: 0 };
}
if (nowMinute < startMinute) {
return { run: false, reason: 'before_time', pushDate, attempt: 0 };
}
const endMinute = Math.min(startMinute + windowMinutes, 23 * 60 + 59);
if (nowMinute > endMinute) {
return { run: false, reason: 'window_closed', pushDate, attempt: 0 };
}
// 当天的尝试次数:跨天或没有记录都归零,避免沿用昨天的计数把节流算歪
const attempt = state.attemptDate === pushDate ? Number(state.attemptCount) || 0 : 0;
if (attempt > 0) {
const lastAttemptMs = Date.parse(String(state.lastAttemptAt || ''));
if (Number.isFinite(lastAttemptMs)) {
const gapMinutes = (now.getTime() - lastAttemptMs) / 60000;
if (gapMinutes < intervalMinutes) {
return { run: false, reason: 'wait_interval', pushDate, attempt };
}
}
}
return { run: true, reason: attempt > 0 ? 'retry' : 'first_round', pushDate, attempt: attempt + 1 };
}
/** /**
* 字段清洗:换行/连续空白压成单空格。 * 字段清洗:换行/连续空白压成单空格。
* ⚠️ 物流描述里常有 `\n`,直接拼进 text 消息会把一条明细劈成两行,看着像两条异常。 * ⚠️ 物流描述里常有 `\n`,直接拼进 text 消息会把一条明细劈成两行,看着像两条异常。
@ -208,6 +299,51 @@ function buildTypeLine(data = {}) {
.join(' · '); .join(' · ');
} }
/**
* 快照时刻的展示形式:`2026-11-11 09:05:00` → `09:05`;**跨天则带 `MM-DD`**。
* ⚠️ 只显示 HH:mm 会把「昨天 11:53」读成「今天 11:53」。11-11 那批的 `snapshotAt`
* 其实是前一天的(镜像表停在 11-10 11:53),群里看到「快照最新只到 11:53」会误以为
* 当天上午的数据很新鲜 —— 与 WST「历史单审核时间必须带 MM-DD」是同一个坑。
*/
function formatSnapshotMoment(value, referenceDate = '') {
const text = String(value || '').trim();
if (text.length < 16) return text;
const datePart = text.slice(0, 10);
const timePart = text.slice(11, 16);
const refDate = String(referenceDate || '').trim().slice(0, 10);
if (refDate && datePart === refDate) return timePart;
return `${datePart.slice(5)} ${timePart}`;
}
/**
* 快照新鲜度告警 —— **有异常数据时才用**(0 单的情形由 `buildNotifyText` 里的 emptyWindow 分支处理)。
*
* 🔥 2026-11-11 实况:物流镜像表停在 11-10 11:53,09:10 那批算出 990 单**全部异常**,
* 正文却只有一句「异常 990 个(100%)」。群里没法分辨这是真异常还是数据没更新,
* 而这恰恰决定当天要不要去催快递。所以「没覆盖核验时刻」「快照过旧」必须写进正文,
* 不能只留在页面 hint 里 —— 群里干活的人看不到页面。
*/
function buildFreshnessWarning(freshness = {}, batch = {}) {
const info = freshness && typeof freshness === 'object' ? freshness : {};
const snapshotAt = formatSnapshotMoment(info.snapshotAt, batch.verifyDate);
if (info.coversDeadline === false) {
const deadline = formatSnapshotMoment(batch.deadline, batch.verifyDate);
return `⚠️ 数据未覆盖核验时刻:物流快照最新只到 ${snapshotAt || '未知'}`
+ `${deadline ? `,本轮核验 ${deadline}` : ''} —— 之后的揽收/中转轨迹没进库,异常量会偏大。`
+ '请以聚水潭实时物流为准,别按这个数去催快递。';
}
if (info.stale === true) {
const ageMinutes = Number(info.ageMinutes);
const hours = Number.isFinite(ageMinutes) && ageMinutes > 0
? `(已 ${Math.round((ageMinutes / 60) * 10) / 10} 小时未刷新)`
: '';
return `⚠️ 物流快照偏旧:最新只到 ${snapshotAt || '未知'}${hours} —— 状态可能滞后,`
+ '异常量仅供参考,请以聚水潭实时物流为准。';
}
return '';
}
function buildPageLink(pageUrl, verifyDate) { function buildPageLink(pageUrl, verifyDate) {
const base = String(pageUrl || DEFAULT_PAGE_URL); const base = String(pageUrl || DEFAULT_PAGE_URL);
if (!verifyDate) return base; if (!verifyDate) return base;
@ -245,8 +381,31 @@ function buildNotifyText(data = {}, options = {}) {
const typeLine = buildTypeLine(data); const typeLine = buildTypeLine(data);
if (typeLine) head.push(`类型:${typeLine}`); if (typeLine) head.push(`类型:${typeLine}`);
// 快照新鲜度告警:只对「算出了异常」的批次有意义 —— 11-11 那批 990 单全部异常,
// 正文却完全看不出数据停在昨天,业务只能凭印象判断要不要催快递。
const freshness = data.freshness || {};
const freshnessWarning = totalPackages > 0 ? buildFreshnessWarning(freshness, batch) : '';
if (freshnessWarning) head.push(freshnessWarning);
// 🔥 2026-11-02 修:0 单有两种完全不同的含义,不能都写「全部正常」——
// ① 数据源没同步(镜像表窗口 0 行)→ 0 单是假的,写「全部正常」等于给群里发假绿;
// ② 当天确实没发货 → 0 单是真的,那也不叫「正常」,叫「无发货可核」。
if (totalPackages === 0) { if (totalPackages === 0) {
head.push('本批无转运异常,全部正常。'); if (freshness.emptyWindow && freshness.sourceStale) {
const hours = Number(freshness.sourceAgeMinutes) > 0
? `(已 ${Math.round((Number(freshness.sourceAgeMinutes) / 60) * 10) / 10} 小时未同步)`
: '';
head.push(`⚠️ 物流数据未同步:镜像表最后更新 ${freshness.sourceLastUpdate || '未知'}${hours},`
+ `${batch.shipDate || '该日'} 的发货记录一条都没进库 —— 上面 0 单不代表当天没发货,请先到聚水潭核对。`);
} else if (freshness.emptyWindow) {
head.push(`${batch.shipDate || '该日'} 在物流镜像表里 0 条发货记录`
+ `(表最后更新 ${freshness.sourceLastUpdate || '未知'},数据源本身正常)——`
+ ' 若当天确有发货,说明上游漏同步了这一天,请到聚水潭核对。');
} else if (shipped === 0) {
head.push('本批发货 0 单,无异常可核。');
} else {
head.push('本批无转运异常,全部正常。');
}
} }
const excludedCount = (Number(exclusions.carrierPackages) || 0) const excludedCount = (Number(exclusions.carrierPackages) || 0)
@ -461,8 +620,9 @@ async function runWarehouseLogisticsExceptionNotifyJob(source = 'scheduled', opt
} }
/** /**
* 调度:每分钟比对「北京时间 HH:mm == 配置的 sendTime」。 * 调度:每分钟问一次 `resolveScheduledPushDecision`。
* 之所以不用固定 cron 表达式:业务在页面上改时间后要立即生效,不能等后端重启。 * 之所以不用固定 cron 表达式:业务在页面上改时间后要立即生效,不能等后端重启。
* 之所以不是「HH:mm 严格相等」:那样只给一次机会,09:10 撞上业务库连不上就整天不推(11-11 实况)。
*/ */
function startWarehouseLogisticsExceptionNotifyScheduler() { function startWarehouseLogisticsExceptionNotifyScheduler() {
const disabled = String(process.env.DISABLE_WLE_NOTIFY || '').trim().toLowerCase() === 'true'; const disabled = String(process.env.DISABLE_WLE_NOTIFY || '').trim().toLowerCase() === 'true';
@ -471,6 +631,7 @@ function startWarehouseLogisticsExceptionNotifyScheduler() {
return; return;
} }
const expression = String(process.env.WLE_NOTIFY_TICK_CRON || DEFAULT_TICK_CRON).trim(); const expression = String(process.env.WLE_NOTIFY_TICK_CRON || DEFAULT_TICK_CRON).trim();
let windowClosedLoggedDate = '';
cron.schedule(expression, () => { cron.schedule(expression, () => {
if (tickRunning) return; if (tickRunning) return;
tickRunning = true; tickRunning = true;
@ -479,8 +640,32 @@ function startWarehouseLogisticsExceptionNotifyScheduler() {
const now = new Date(); const now = new Date();
const config = await getWarehouseLogisticsExceptionNotifyRuntimeConfig(); const config = await getWarehouseLogisticsExceptionNotifyRuntimeConfig();
if (!config.enabled) return; if (!config.enabled) return;
if (chinaHourMinute(now) !== config.sendTime) return; const state = await loadWarehouseLogisticsExceptionNotifyState();
await runWarehouseLogisticsExceptionNotifyJob('daily_schedule', { now }); const decision = resolveScheduledPushDecision({ now, sendTime: config.sendTime, state });
if (!decision.run) {
// 窗口刚过、当天又一直没推成功 → 打一条,明确「今天不会自己来了」,别让人一直等
if (decision.reason === 'window_closed' && windowClosedLoggedDate !== decision.pushDate) {
windowClosedLoggedDate = decision.pushDate;
console.error(
`[WleNotify] 今日推送窗口已关闭(${config.sendTime} 起 ${RETRY_WINDOW_MINUTES} 分钟内重试,`
+ '始终未成功),今天不再自动重试,请人工处理'
);
}
return;
}
// 先落「本轮尝试」:失败后下一分钟的 tick 才能按间隔节流。
// 成功时 push 内部会覆盖 lastSentDate(去重键),此后本函数直接走 already_sent_today。
await saveWarehouseLogisticsExceptionNotifyState({
...state,
attemptDate: decision.pushDate,
attemptCount: decision.attempt,
lastAttemptAt: now.toISOString(),
});
await runWarehouseLogisticsExceptionNotifyJob(
decision.reason === 'retry' ? 'daily_retry' : 'daily_schedule',
{ now }
);
} catch (error) { } catch (error) {
console.error('[WleNotify] 定时检查失败:', error.message || error); console.error('[WleNotify] 定时检查失败:', error.message || error);
} finally { } finally {
@ -489,23 +674,31 @@ function startWarehouseLogisticsExceptionNotifyScheduler() {
})(); })();
}, { timezone: TIMEZONE }); }, { timezone: TIMEZONE });
console.log(`[Scheduler] 物流转运异常钉钉推送已注册: 每分钟检查,到点(默认 09:10)推送 (${TIMEZONE})`); console.log(
`[Scheduler] 物流转运异常钉钉推送已注册: 每分钟检查,到点(默认 09:10)推送,`
+ `失败后每 ${RETRY_INTERVAL_MINUTES} 分钟重试、最多 ${RETRY_WINDOW_MINUTES} 分钟内 (${TIMEZONE})`
);
} }
module.exports = { module.exports = {
DEFAULT_RETRY_INTERVAL_MINUTES,
DEFAULT_RETRY_WINDOW_MINUTES,
DEFAULT_TICK_CRON, DEFAULT_TICK_CRON,
SAFE_CONTENT_BYTES, SAFE_CONTENT_BYTES,
TIMEZONE, TIMEZONE,
buildCenterLines, buildCenterLines,
buildDetailLine, buildDetailLine,
buildFreshnessWarning,
buildNotifyText, buildNotifyText,
buildTypeLine, buildTypeLine,
chinaDateKey, chinaDateKey,
chinaHourMinute, chinaHourMinute,
groupRowsByWarehouse, groupRowsByWarehouse,
minuteOfDay,
pickDetailRows, pickDetailRows,
cleanCell, cleanCell,
pushWarehouseLogisticsExceptionNotify, pushWarehouseLogisticsExceptionNotify,
resolveScheduledPushDecision,
runWarehouseLogisticsExceptionNotifyJob, runWarehouseLogisticsExceptionNotifyJob,
startWarehouseLogisticsExceptionNotifyScheduler, startWarehouseLogisticsExceptionNotifyScheduler,
}; };

View File

@ -1,7 +1,7 @@
'use strict'; 'use strict';
/** /**
* 仓储中心 24 小时发货时效 · 两轮核验完成后把超时未发单推到钉钉群 * 仓储中心发货时效 · 两轮核验完成后把超时未发单推到钉钉群
* ──────────────────────────────────────────────────────────────────────────── * ────────────────────────────────────────────────────────────────────────────
* 业务口径(2026-10-27 原话): * 业务口径(2026-10-27 原话):
* 「发货时效也需要钉钉通知:13 点核验 7 点前的超时单,核验完成后通知; * 「发货时效也需要钉钉通知:13 点核验 7 点前的超时单,核验完成后通知;
@ -9,14 +9,19 @@
* ⟹ **一天两推**,各绑一个核验轮次(轮次定义见 warehouseShipTimelinessRegistry 的 ROUNDS): * ⟹ **一天两推**,各绑一个核验轮次(轮次定义见 warehouseShipTimelinessRegistry 的 ROUNDS):
* NOON 13:00 核验「今天 07:00 前审核」→ 默认 13:05 推 * NOON 13:00 核验「今天 07:00 前审核」→ 默认 13:05 推
* AFTERNOON 18:00 核验「截止 16:00 前审核」→ 默认 18:05 推 * AFTERNOON 18:00 核验「截止 16:00 前审核」→ 默认 18:05 推
* ⚠️ 默认「核验时刻 + 5 分钟」:状态镜像 `query_time` 得晚于核验时刻, * ⚠️ 2026-10-28 起数据源换成订单两表(jst_Orders / jst_qmcust_orderlist),
* 起算点是**审核时间** `last_oa_confirm_time`(不是订单创建时间);
* 取不到审核时间的单回退创建时间,正文里在该时间后加 `*` 提示。
* 推送正文写「审核 HH:mm」(此前一版误写「创建」,已纠正)。
* ⚠️ 默认「核验时刻 + 5 分钟」:订单表 `updateTime` 得晚于核验时刻,
* 整点推容易拿到 `freshness.coversDeadline=false`(数据没覆盖核验点,超时数偏大)。 * 整点推容易拿到 `freshness.coversDeadline=false`(数据没覆盖核验点,超时数偏大)。
* 时刻在页面上可改,改完立即生效(每分钟 tick 比对,不用重启后端)。 * 时刻在页面上可改,改完立即生效(每分钟 tick 比对,不用重启后端)。
* *
* 消息内容: * 消息内容:
* 抬头(含「超时」字样,钉钉关键词安全设置要用)+ 汇总(超时单数 / 涉及仓数 / 最久已等) * 抬头(含「超时」字样,钉钉关键词安全设置要用)+ 汇总(超时单数 / 涉及仓数 / 最久已等)
* + 不计考核(待审核·订单异常,不算仓库责任)+ 按仓超时单数 + 前 N 条明细 + 页面链接。 * + 不计考核(待审核·订单异常,不算仓库责任)+ 按仓超时单数 + 前 N 条明细 + 页面链接。
* 明细一行 = 仓|内部单号|线上单号|审核 HH:mm|已等 X 小时(业务对账用)。 * 明细一行 = 仓|内部单号|线上单号|快递|创建 HH:mm|已等 X 小时(业务对账用)。
* (「快递」是业务 2026-10-27 要求加的,见 buildDetailLine 的说明)
* 0 条也推 —— 群里看到「本轮 0 单超时」就知道任务在跑。 * 0 条也推 —— 群里看到「本轮 0 单超时」就知道任务在跑。
* *
* 去重:状态存 system_config,按 `<北京日期>|<轮次键>` 去重(一天两轮互不影响)。 * 去重:状态存 system_config,按 `<北京日期>|<轮次键>` 去重(一天两轮互不影响)。
@ -26,8 +31,12 @@
*/ */
const cron = require('node-cron'); const cron = require('node-cron');
const { getShipTimeliness, DEFAULT_DETAIL_LIMIT } = require('../services/warehouseShipTimelinessService'); const {
const { ROUNDS, describeRounds } = require('../services/warehouseShipTimelinessRegistry'); getShipTimeliness,
DEFAULT_DETAIL_LIMIT,
EXCLUDED_CARRIERS,
} = require('../services/warehouseShipTimelinessService');
const { ROUNDS, beijingNow, describeRounds } = require('../services/warehouseShipTimelinessRegistry');
const { sendTextToWebhook, MAX_CONTENT_BYTES } = require('../services/dingtalkRobotWebhookSender'); const { sendTextToWebhook, MAX_CONTENT_BYTES } = require('../services/dingtalkRobotWebhookSender');
const { const {
DEFAULT_MAX_DETAIL_ROWS, DEFAULT_MAX_DETAIL_ROWS,
@ -113,14 +122,18 @@ function formatOverdue(minutes) {
} }
/** /**
* 审核时间的展示:本轮的日期就只给 HH:mm,跨天(历史未发单)必须带 MM-DD。 * 起算时间(= 审核时间 `last_oa_confirm_time`)的展示:
* 本轮的日期只给 HH:mm,跨天(历史未发单)必须带 MM-DD。
* 🔥 为什么要带日期:13:00 轮窗口上界是 07:00,但口径「含历史未发」, * 🔥 为什么要带日期:13:00 轮窗口上界是 07:00,但口径「含历史未发」,
* 明细里会出现昨天 16:13 审核的单 —— 只写「审核 16:13」会被读成「今天 16:13」, * 明细里会出现昨天 16:13 审核的单 —— 只写「审核 16:13」会被读成「今天 16:13」,
* 看着像「审核时间晚于窗口,不该算超时」,业务会对不上账。 * 看着像「审核时间晚于窗口,不该算超时」,业务会对不上账。
*
* ⚠️ 传进来的 `auditTime` 是服务层的 benchmarkAt:审核时间,取不到时回退订单创建时间
* (此时 row.benchmarkSource === 'created',调用方会给时间加 `*`)。
*/ */
function auditWhen(auditTime, roundDate) { function auditWhen(auditTime, roundDate) {
const text = cleanCell(auditTime); const text = cleanCell(auditTime);
if (!text) return '未审核'; if (!text) return '';
const hit = text.match(/(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2})/); const hit = text.match(/(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2})/);
if (!hit) { if (!hit) {
const clock = text.match(/(\d{2}:\d{2})/); const clock = text.match(/(\d{2}:\d{2})/);
@ -132,17 +145,27 @@ function auditWhen(auditTime, roundDate) {
} }
/** /**
* 明细一行:仓|内部单号|线上单号|审核 时间|已等 X 小时 * 明细一行:仓|内部单号|线上单号|快递|审核 时间|已等 X 小时
* ⚠️ 第二段是**内部单号**(聚水潭 o_id,仓管在系统里按它查单),第三段是线上单号(客服对客户)。 * ⚠️ 第二段是**内部单号**(聚水潭 o_id,仓管在系统里按它查单),第三段是线上单号(客服对客户)。
* 两者业务都要,别只留一个。 * 两者业务都要,别只留一个。
* ⚠️ 审核时间跨天要带日期,见 auditWhen 的说明。 * 🔥 第四段「快递」是业务 2026-10-27 要求加的:群里看到超时单要能直接判断
* 是哪个快递、是不是得走站点(比如安能系、德邦、京东各区网点揽收节奏完全不同),
* 不用再回页面一单单点开确认。
* 🔥 2026-10-28 第五段是「审核」时间(起算点),不是订单创建时间;
* 审核时间缺失、回退订单创建时间的单,时间后面带 `*`。
* ⚠️ 跨天要带日期,见 auditWhen 的说明。
*/ */
function buildDetailLine(row, index, roundDate) { function buildDetailLine(row, index, roundDate) {
const when = auditWhen(row?.auditTime, roundDate);
const auditText = when
? `审核 ${when}${row?.benchmarkSource === 'created' ? '*' : ''}`
: '审核 —';
const parts = [ const parts = [
cleanCell(row?.warehouseName || row?.centerName, '未知仓'), cleanCell(row?.warehouseName || row?.centerName, '未知仓'),
cleanCell(row?.oId, '无单号'), cleanCell(row?.oId, '无单号'),
cleanCell(row?.soId, '—'), cleanCell(row?.soId, '—'),
`审核 ${auditWhen(row?.auditTime, roundDate)}`, cleanCell(row?.logisticCompany, '—'),
auditText,
`已等 ${formatOverdue(row?.overdueMinutes)}`, `已等 ${formatOverdue(row?.overdueMinutes)}`,
]; ];
return `${index}. ${parts.join('|')}`; return `${index}. ${parts.join('|')}`;
@ -266,11 +289,15 @@ function buildNotifyText(data = {}, options = {}) {
head.push('本轮没有超时未发货的订单,全部按时发出。'); head.push('本轮没有超时未发货的订单,全部按时发出。');
} }
if (heldCount > 0) { if (heldCount > 0) {
head.push(`另有 ${heldCount} 单不计考核(已支付待审核 / 订单异常)`); head.push(`另有 ${heldCount} 单不计考核(待审核 / 订单异常)`);
} }
const carrierSkipped = Number(summary.carrierSkipped) || 0; const carrierSkipped = Number(summary.carrierSkipped) || 0;
if (carrierSkipped > 0) { if (carrierSkipped > 0) {
head.push(`已剔除 ${carrierSkipped} 单不考核快递(自提 / 中铁 / 壹米滴答)`); // 快递清单由服务层给(`excludedCarriers`),别在这里写死 ——
// 2026-10-27 加「武进安能」时就吃过一次:写死的文案忘了改,群里口径和页面不一致。
const carriers = (Array.isArray(data.excludedCarriers) ? data.excludedCarriers : EXCLUDED_CARRIERS)
.filter(Boolean);
head.push(`已剔除 ${carrierSkipped} 单不考核快递${carriers.length ? `(${carriers.join(' / ')})` : ''}`);
} }
// 数据没覆盖本轮核验时刻 → 数字必然偏大,必须写在消息里,不能让仓管拿错数去追单 // 数据没覆盖本轮核验时刻 → 数字必然偏大,必须写在消息里,不能让仓管拿错数去追单
if (freshness.coversDeadline === false) { if (freshness.coversDeadline === false) {
@ -390,8 +417,15 @@ function sendTimeForRound(config, roundKey) {
* probe 只发一条通道测试文本(不查库、不依赖业务数据) * probe 只发一条通道测试文本(不查库、不依赖业务数据)
*/ */
async function pushShipTimelinessNotify(options = {}) { async function pushShipTimelinessNotify(options = {}) {
const now = options.now === undefined ? new Date() : new Date(options.now); // 🔥 两个「现在」不能混用(生产容器 /etc/timezone = Etc/UTC):
const pushDate = chinaDateKey(now); // · rawNow —— 真实时刻。凡是走 Intl(Asia/Shanghai) 或 toISOString 的地方用它;
// · bjNow —— 平移成「本地 getter 读出来正好是北京时间」的 Date。
// registry.describeRounds / resolveRoundMeta / getShipTimeliness 内部都用
// `getDate()/getHours()` 直接读,必须喂 bjNow —— 否则北京 00:00~08:00 会取到前一天
// (2026-10-21 生产踩过:13:00 轮算出 3895 单,实际只有 6 单)。
const rawNow = options.now === undefined ? new Date() : new Date(options.now);
const bjNow = beijingNow(rawNow);
const pushDate = chinaDateKey(rawNow);
const config = await getShipTimelinessNotifyRuntimeConfig({ forceRefresh: true }); const config = await getShipTimelinessNotifyRuntimeConfig({ forceRefresh: true });
// 通道测试:只验 webhook,不读业务数据(数据慢不该背「通道坏」的锅) // 通道测试:只验 webhook,不读业务数据(数据慢不该背「通道坏」的锅)
@ -411,7 +445,7 @@ async function pushShipTimelinessNotify(options = {}) {
const explicitRound = String(options.round || '').toUpperCase(); const explicitRound = String(options.round || '').toUpperCase();
let roundKey = explicitRound; let roundKey = explicitRound;
if (!roundKey) { if (!roundKey) {
const minutes = minutesOfDay(now); const minutes = minutesOfDay(rawNow);
let active = null; let active = null;
for (const round of ROUNDS) { for (const round of ROUNDS) {
if (minutes >= round.verifyHour * 60) active = round; if (minutes >= round.verifyHour * 60) active = round;
@ -420,12 +454,12 @@ async function pushShipTimelinessNotify(options = {}) {
roundKey = active.key; roundKey = active.key;
} }
const meta = resolveRoundMeta(roundKey, now); const meta = resolveRoundMeta(roundKey, bjNow);
if (!meta) return { sent: false, reason: 'unknown_round', round: roundKey }; if (!meta) return { sent: false, reason: 'unknown_round', round: roundKey };
// 还没到本轮核验时刻就推 = 推的是半成品,直接跳过(等下一轮 tick) // 还没到本轮核验时刻就推 = 推的是半成品,直接跳过(等下一轮 tick)
const deadlineMinutes = parseSendTime(String(meta.deadline || '').slice(11, 16)); const deadlineMinutes = parseSendTime(String(meta.deadline || '').slice(11, 16));
if (deadlineMinutes != null && minutesOfDay(now) < deadlineMinutes) { if (deadlineMinutes != null && minutesOfDay(rawNow) < deadlineMinutes) {
return { sent: false, reason: 'before_deadline', round: roundKey, deadline: meta.deadline }; return { sent: false, reason: 'before_deadline', round: roundKey, deadline: meta.deadline };
} }
@ -456,7 +490,7 @@ async function pushShipTimelinessNotify(options = {}) {
const data = await getShipTimeliness({ const data = await getShipTimeliness({
round: roundKey, round: roundKey,
limit: DEFAULT_DETAIL_LIMIT, limit: DEFAULT_DETAIL_LIMIT,
now, now: bjNow,
}); });
if (data?.notStarted) { if (data?.notStarted) {
return { sent: false, reason: 'not_started', round: roundKey }; return { sent: false, reason: 'not_started', round: roundKey };
@ -495,7 +529,7 @@ async function pushShipTimelinessNotify(options = {}) {
const nextSent = { const nextSent = {
...sentMap, ...sentMap,
[slot]: { [slot]: {
sentAt: new Date(now).toISOString(), sentAt: rawNow.toISOString(),
rowCount: built.rowCount, rowCount: built.rowCount,
listedCount: built.listedCount, listedCount: built.listedCount,
bytes: built.bytes, bytes: built.bytes,
@ -507,7 +541,7 @@ async function pushShipTimelinessNotify(options = {}) {
await saveShipTimelinessNotifyState({ await saveShipTimelinessNotifyState({
version: 1, version: 1,
sent: trimSentMap(nextSent), sent: trimSentMap(nextSent),
lastSentAt: new Date(now).toISOString(), lastSentAt: rawNow.toISOString(),
lastStatus: 'sent', lastStatus: 'sent',
lastError: '', lastError: '',
lastRound: roundKey, lastRound: roundKey,

View File

@ -240,24 +240,27 @@
// ⚠️ 配件库存**不适用本口径**(配件仍只算 15718196)——新仓一个配件都没有, // ⚠️ 配件库存**不适用本口径**(配件仍只算 15718196)——新仓一个配件都没有,
// 横林三仓/沭阳仓虽有 MKH 配件但归属别的项目,并入会让「配件不足」漏报。 // 横林三仓/沭阳仓虽有 MKH 配件但归属别的项目,并入会让「配件不足」漏报。
// //
// ── ⑧ 在途加工单(2026-09-17 业务确认口径)──────────────────────── // ── ⑧ 在途加工单(2026-09-17 业务确认口径;2026-11-11 换数据源)──────────
// 规则:**只要该 MKH 商品存在未完成的加工单,就不再列入补货预警** // 规则:**只要该 MKH 商品存在未完成的加工单,就不再列入补货预警**
// (工厂已经在做了,不重复提示补货),改标为「已排产」。 // (工厂已经在做了,不重复提示补货),改标为「已排产」。
// · 数据源:业务库同实例的链接服务器 // · 数据源(2026-11-11 起):聚水潭原生加工单三表,主键 `po_id` 关联
// LS_JS_DMP → JSDataMiddlePlatform.dbo.bi_processing_work_orders // rpt.jst_manufactureInfo 加工单单头:status / wms_co_id(加工仓) / receipt_wms_co_id(收货仓) / po_date
// (聚水潭「组装加工」加工单,一张扁平的 加工单 × 商品 明细表) // rpt.jst_manufactureItem 加工单**成品**明细:sku_id / qty(计划数) / io_qty(已入库) / delivery_date
// · 过滤:加工仓储方 = '简尚-崔桥工厂半成品包装项目仓' // rpt.jst_manufactureRaw 加工单**原料**明细:qty(暂未参与在途核算,配件占用走 BOM 单台用量)
// AND 状态 <> '作废' ← 作废单据一律不核算 // · 过滤:i.wms_co_id = 15718196(简尚-崔桥工厂半成品包装项目仓,产出入品牌仓 15870495)
// AND max(数量 − 已入库数量, 0) > 0 ← 只认真实剩余量 // AND i.status <> 'Cancelled' ← 作废单不核算(实测 178 单 7,515 件,不过滤会虚增几十倍)
// · 在途加工量 = Σ max(数量 − 已入库数量, 0),按 商品编码 归集。 // AND it.qty > ISNULL(it.io_qty,0) ← 只认真实剩余量
// 不再依赖「收货状态」文本:上游状态字段延迟时,已入库数量已追平的单据必须立即退出在途。 // · 在途加工量 = Σ(qty − io_qty),按成品编码 sku_id 归集;ETA 取 delivery_date 最小值。
// ⚠️ 为什么走 getPool 而不是 cloudDatabase.query: // 状态值域实测(2026-11-11):Finished 1,149 单 / Cancelled 178 / **Confirmed 18**;
// query() 会经 rewriteReportReplicaSql() 把 `dbo.xxx` 重写成 `rpt.xxx`, // Finished 的 1,173 行明细**零剩余**(io_qty 已追平),Confirmed 的 18 行 io_qty 全 0。
// 跨库四段名 `LS_JS_DMP.JSDataMiddlePlatform.dbo.t` 会被改坏成 // → 无需依赖状态文本判「完成」,剩余量判据自身就够;状态只用来剔作废。
// `LS_JS_DMP.JSDataMiddlePlatform.rpt.t`。getPool() 不经过该重写。 // ⚠️ **换源原因**:旧源是链接服务器 `LS_JS_DMP`(192.168.1.209) 的快照表
// 实测(2026-09-16):全表 679 行,其中 完成 498(全部入库)/ 作废 176 / // `JSDataMiddlePlatform.dbo.bi_processing_work_orders`,自 2026-11-03 10:49 起**停更 8 天**
// 已确认 3 / 待审核 2;属半成品包装仓且未完成且非作废的只有 5 单 40 件。 // (1,370 行 / MAX(Id)=1370 不再增长,而此前每天都有 5~34 行),且**不会报错** ——
// ⚠️ 作废单在半成品包装仓有 79 单 740 件,若不过滤会虚增约 18 倍在途量。 // `workOrderDegraded` 只反映「查询失败」,数据陈旧永远是 false,
// 于是页面长期显示 9 个 11-03 的僵尸单(业务在聚水潭看到的是 18 个新单)。
// 换成本实例内的原生三表后随主库小时级刷新,不再依赖那台内网机器的同步任务。
// 实测(2026-11-11):18 单 / 18 个成品 / 在途 175 件,ETA 全可解析(11-24 ~ 11-25)。
// //
// ── ⑨ 导出(2026-09-17)────────────────────────────────────────── // ── ⑨ 导出(2026-09-17)──────────────────────────────────────────
// 导出与列表**共用同一套筛选/排序口径**(filterRows + sortRows),区别只有两点: // 导出与列表**共用同一套筛选/排序口径**(filterRows + sortRows),区别只有两点:
@ -465,15 +468,25 @@ const WARNING_LEVEL = Object.freeze({
}); });
// ── 在途加工单参数(见文件头 ⑧)────────────────────────────────── // ── 在途加工单参数(见文件头 ⑧)──────────────────────────────────
// 加工仓储方:加工单的加工地,即半成品包装项目仓(产出入品牌仓) // 加工仓储方:加工单的加工地,即半成品包装项目仓(产出入品牌仓)。仅用于文案展示。
const WORK_ORDER_WAREHOUSE = '简尚-崔桥工厂半成品包装项目仓'; const WORK_ORDER_WAREHOUSE = '简尚-崔桥工厂半成品包装项目仓';
// 作废状态:作废单据不参与在途量核算 // 加工仓 wms_co_id(半成品包装项目仓):SQL 侧按它过滤。
const WORK_ORDER_VOID_STATUS = '作废'; // ⚠️ 用 ID 而不是中文名 —— 名称可能被上游改写,ID 稳定;实测该仓加工单收货仓恒为品牌仓 15870495。
// 收货状态:该值表示已全部入库,等价于「已完成」 const WORK_ORDER_WMS_CO_ID = 15718196;
const WORK_ORDER_RECEIVED_STATUS = '全部入库'; // 作废状态:作废单据不参与在途量核算(聚水潭加工单 status 值域 Confirmed / Finished / Cancelled)
// 加工单表位于同一实例的链接服务器上,四段名必须走 getPool 查询(原因见文件头 ⑧) const WORK_ORDER_VOID_STATUS = 'Cancelled';
const WORK_ORDER_TABLE = 'LS_JS_DMP.JSDataMiddlePlatform.dbo.bi_processing_work_orders'; // 完成状态:已全部入库
// 链接服务器不可用时的降级缓存时长:短一点,避免长时间带着错误在途量 const WORK_ORDER_RECEIVED_STATUS = 'Finished';
// 聚水潭原生加工单三表(rpt schema 视图,主键 po_id):
// Info = 单头(status / wms_co_id / po_date)
// Item = 成品明细(sku_id / qty / io_qty 已入库 / delivery_date 预计到货)
// Raw = 原料明细(暂未参与在途核算,配件占用走 BOM 单台用量)
// ⚠️ 2026-11-11 换源:旧的链接服务器 LS_JS_DMP 快照表自 11-03 起停更 8 天且**不会报错**
// (`workOrderDegraded` 只反映查询失败),导致页面 9 个僵尸单 + 新单全丢。
// 这三张表在业务库本实例内,可走 cloudDatabase.query()(表名已带 rpt.,不会被重写坏)。
const WORK_ORDER_INFO_TABLE = 'rpt.jst_manufactureInfo';
const WORK_ORDER_ITEM_TABLE = 'rpt.jst_manufactureItem';
// 加工单不可用时的降级缓存时长:短一点,避免长时间带着错误在途量
const WORK_ORDER_DEGRADED_TTL_MS = 60 * 1000; const WORK_ORDER_DEGRADED_TTL_MS = 60 * 1000;
// ── 订单参数(见文件头 ⑩ 待发货 / ⑦-a 近15天已发货)────────────── // ── 订单参数(见文件头 ⑩ 待发货 / ⑦-a 近15天已发货)──────────────
@ -488,10 +501,40 @@ const ORDER_TABLES = Object.freeze([
]); ]);
// 不计入需求的订单状态:Cancelled 已取消 / Merged 已合并进别的单 // 不计入需求的订单状态:Cancelled 已取消 / Merged 已合并进别的单
const PENDING_ORDER_EXCLUDED_STATUS = Object.freeze(['Cancelled', 'Merged']); const PENDING_ORDER_EXCLUDED_STATUS = Object.freeze(['Cancelled', 'Merged']);
// 只捞含 MKH 的订单,避免全表扫描(实测 1.18M 行 + 4.91M 行,合并查询约 1.25s) // 只捞含 MKH 的订单,避免把结果集全拉回来。
// ⚠️ 注意:这是**前导通配**(`LIKE '%MKH%'`),索引完全用不上 → SQL Server 必然全表扫。
// 2026-11-17 实测副本库 `rpt.jst_Orders` 158 万行光 COUNT(*) 就要 152.8s(≈1 万行/秒),
// 所以这条查询必须走独立连接 + 长超时,并且不能放在用户请求路径上(见 loadOrderIndex)。
const PENDING_ORDER_SKU_LIKE = '%MKH%'; const PENDING_ORDER_SKU_LIKE = '%MKH%';
// 订单数据源异常时的降级缓存时长 // 订单数据源异常时的降级缓存时长。
const PENDING_ORDER_DEGRADED_TTL_MS = 60 * 1000; // 🔥 2026-11-17:60 秒 → 5 分钟。降级态下每次重试都是一次**全表扫描**(实测单次 60~130s,
// 慢的时候 400s+),60 秒 TTL 等于「刚失败就重打」,库越慢越打、越打越慢 —— 自残循环。
// 5 分钟仍然够快恢复,但不会把本来就慢的副本库打穿。
const PENDING_ORDER_DEGRADED_TTL_MS = 5 * 60 * 1000;
// 订单查询超时(毫秒)。**必须走独立连接**(`freshConnection: true`):
// 共享池的池级超时在 pool 创建时就定死了(默认 60s),`requestTimeout` 只是请求级设置、
// 在 mssql 12.x 上不生效。2026-11-17 实测:rpt.jst_Orders 158 万行**光 COUNT(*)** 就要
// 152.8s(≈1 万行/秒),而 `skus LIKE '%MKH%'` 前导通配必然全表扫 → 60s 无解。
// 可用 CANGKU_MKH_ORDER_QUERY_TIMEOUT_MS 覆盖(默认 5 分钟)。
const ORDER_QUERY_TIMEOUT_MS = Number(process.env.CANGKU_MKH_ORDER_QUERY_TIMEOUT_MS) || 300000;
// 不重连重试:这类失败是「库慢」而不是瞬时抖动,重试只会把等待翻倍(60s → 120s → …)。
const ORDER_QUERY_MAX_ATTEMPTS = 1;
// 待发货分支的订单日期下界(天)。原 SQL 只有 `send_date IS NULL`、**没有任何时间下界**,
// 历史僵尸单全部参与扫描与累计。180 天足够覆盖真实待发(聚水潭超过半年的未发单
// 基本已人工作废),同时把扫描量从「全表」压到「近半年」。
// order_date 为空的单照旧纳入(宁可多算,不可漏算真实待发)。
const PENDING_ORDER_MAX_AGE_DAYS = 180;
// 订单索引缓存时长。10 分钟 → 30 分钟:订单索引是这个页面唯一的重查询,而它承载的
// 待发货 / 近 15 天已发货都是「分钟级变化」的数据,30 分钟对补货预警完全够用。
// 配合 jobs/mkhBomPrewarmJob(每 20 分钟后台预热)→ 请求路径基本不会撞上冷查。
// 注意:其它 10 分钟缓存(商品主数据 / 库存合并索引)仍用 MKH_CACHE_TTL_MS,别一起放大,
// 库存是业务要看的实时口径,30 分钟太旧了。
const ORDER_INDEX_CACHE_TTL_MS = 30 * 60 * 1000;
// 后台刷新失败后,至少隔这么久才允许下一次尝试 —— 否则每个请求都会去撞一次全表扫描。
const ORDER_INDEX_RETRY_AFTER_FAILURE_MS = 60 * 1000;
// 出库校验查询超时:**故意比订单主查询短**。出库校验失败是安全降级
// (宁可漏杀不可错杀,见 ⑦-c),不值得为它多等 5 分钟。
const OUTBOUND_QUERY_TIMEOUT_MS = 180000;
// 日销兜底(⑦-a):这些店铺的单上游不计入日销,兜底也必须排除,否则会误拉进预警 // 日销兜底(⑦-a):这些店铺的单上游不计入日销,兜底也必须排除,否则会误拉进预警
const SALE_EXCLUDED_SHOP_KEYWORDS = Object.freeze(['样品', '测试']); const SALE_EXCLUDED_SHOP_KEYWORDS = Object.freeze(['样品', '测试']);
// 日销兜底(⑦-a):**异常单**同样不能计入「已发货」—— // 日销兜底(⑦-a):**异常单**同样不能计入「已发货」——
@ -1392,8 +1435,10 @@ async function loadMkhProductIndex() {
/** /**
* 未完成加工单(在途量)索引 —— 进程内缓存 { bySku: Map<归一化编码, 在途指标>, degraded }。 * 未完成加工单(在途量)索引 —— 进程内缓存 { bySku: Map<归一化编码, 在途指标>, degraded }。
* 只保留「半成品包装项目仓加工、未完成、非作废」的加工单,口径见文件头 ⑧。 * 只保留「半成品包装项目仓加工、未完成、非作废」的加工单,口径见文件头 ⑧。
* ⚠️ 该数据源是链接服务器,取不到时**降级为空索引**(补货预警照常跑), * 数据源:聚水潭原生加工单三表 —— jst_manufactureInfo(单头)+ jst_manufactureItem(成品明细),
* 并缩短缓存避免长时间带着错误在途量。degraded=true 会被透出到接口。 * PO 关联键 po_id;剩余量 = qty − io_qty(已入库数量)。
* ⚠️ 取不到时**降级为空索引**(补货预警照常跑),并缩短缓存避免长时间带着错误在途量。
* degraded=true 会被透出到接口。
*/ */
async function loadPendingWorkOrderIndex() { async function loadPendingWorkOrderIndex() {
const now = Date.now(); const now = Date.now();
@ -1403,43 +1448,26 @@ async function loadPendingWorkOrderIndex() {
if (workOrderIndexCache?.pending) return workOrderIndexCache.pending; if (workOrderIndexCache?.pending) return workOrderIndexCache.pending;
const pending = (async () => { const pending = (async () => {
// ⚠️ 必须走 getPool:cloudDatabase.query() 会把 `dbo.xxx` 重写成 `rpt.xxx`, // 表名已带 rpt. 前缀,`query()` 的 dbo→rpt 重写不会碰它,无需 getPool。
// 跨库四段名会被改坏(见文件头 ⑧)。 // Finished 单的 io_qty 已追平(实测 1,173 行零剩余),靠 `qty > io_qty` 自然退出,不依赖状态文本。
const pool = await cloudDatabase.getPool(); const rows = await cloudDatabase.query(
const request = pool.request(); `SELECT it.sku_id AS skuId,
request.input('workOrderWarehouse', WORK_ORDER_WAREHOUSE); SUM(it.qty - ISNULL(it.io_qty, 0)) AS pendingQty,
request.input('voidStatus', WORK_ORDER_VOID_STATUS); COUNT(DISTINCT i.po_id) AS orderCount,
const result = await request.query(` MIN(TRY_CONVERT(DATETIME, it.delivery_date, 111)) AS eta,
SELECT [商品编码] AS skuId, MIN(CAST(i.po_id AS NVARCHAR(40))) AS firstOrderNo
SUM(CASE FROM ${WORK_ORDER_ITEM_TABLE} it WITH (NOLOCK)
WHEN CAST([数量] AS DECIMAL(18, 4)) > CAST([已入库数量] AS DECIMAL(18, 4)) JOIN ${WORK_ORDER_INFO_TABLE} i WITH (NOLOCK) ON i.po_id = it.po_id
THEN CAST([数量] AS DECIMAL(18, 4)) - CAST([已入库数量] AS DECIMAL(18, 4)) WHERE i.wms_co_id = @workOrderWmsCoId
ELSE 0 AND i.status <> @voidStatus
END) AS pendingQty, AND it.qty > ISNULL(it.io_qty, 0)
COUNT(DISTINCT CASE GROUP BY it.sku_id`,
WHEN CAST([数量] AS DECIMAL(18, 4)) > CAST([已入库数量] AS DECIMAL(18, 4)) { workOrderWmsCoId: WORK_ORDER_WMS_CO_ID, voidStatus: WORK_ORDER_VOID_STATUS },
THEN [加工单号] { requestTimeout: 180000 }
END) AS orderCount, );
MIN(CASE
WHEN CAST([数量] AS DECIMAL(18, 4)) > CAST([已入库数量] AS DECIMAL(18, 4))
THEN TRY_CONVERT(DATETIME, [预计加工完成时间], 111)
END) AS eta,
MIN(CASE
WHEN CAST([数量] AS DECIMAL(18, 4)) > CAST([已入库数量] AS DECIMAL(18, 4))
THEN CAST([加工单号] AS NVARCHAR(40))
END) AS firstOrderNo
FROM ${WORK_ORDER_TABLE} WITH (NOLOCK)
WHERE [加工仓储方] = @workOrderWarehouse
AND [状态] <> @voidStatus
GROUP BY [商品编码]
HAVING SUM(CASE
WHEN CAST([数量] AS DECIMAL(18, 4)) > CAST([已入库数量] AS DECIMAL(18, 4))
THEN CAST([数量] AS DECIMAL(18, 4)) - CAST([已入库数量] AS DECIMAL(18, 4))
ELSE 0
END) > 0`);
const bySku = new Map(); const bySku = new Map();
(result.recordset || []).forEach((row) => { (rows || []).forEach((row) => {
const key = normalizeCode(row.skuId); const key = normalizeCode(row.skuId);
if (!key) return; if (!key) return;
const pendingQty = Math.max(0, toNumber(row.pendingQty) ?? 0); const pendingQty = Math.max(0, toNumber(row.pendingQty) ?? 0);
@ -1586,7 +1614,13 @@ async function loadOutboundOrderIds(orderIds) {
${union} ${union}
) outbound_rows`, ) outbound_rows`,
params, params,
{ requestTimeout: 180000 } {
// 同订单主查询:必须独立连接,否则按共享池 60s 掐断(`requestTimeout` 不生效)。
// 但超时故意更短,见 OUTBOUND_QUERY_TIMEOUT_MS。
freshConnection: true,
connectRequestTimeoutMs: OUTBOUND_QUERY_TIMEOUT_MS,
maxAttempts: 1,
}
); );
})); }));
@ -1616,11 +1650,32 @@ async function loadOutboundOrderIds(orderIds) {
* · 两者商品都取自主表 `skus` 文本列,`MKH-` 打头的组合装不计 * · 两者商品都取自主表 `skus` 文本列,`MKH-` 打头的组合装不计
* · 三条过滤只作用于**已发货**分支:待发货(⑩)本来就是没出货的订单,不做出库校验 * · 三条过滤只作用于**已发货**分支:待发货(⑩)本来就是没出货的订单,不做出库校验
* ⚠️ 不降级为「抛错」:取不到时按空索引处理(补货预警退化成旧口径),并缩短缓存以便重试。 * ⚠️ 不降级为「抛错」:取不到时按空索引处理(补货预警退化成旧口径),并缩短缓存以便重试。
*
* 🔥 2026-11-17 性能重构(「每次打开/刷新都慢、导出也卡」的根因):
* ① 走独立连接(`freshConnection`)+ ORDER_QUERY_TIMEOUT_MS。原来传的
* `{ requestTimeout: 180000 }` 在共享池上**不生效**(请求级 request.timeout 在 mssql 12.x
* 无效),实际一律 60s 被掐断 → 每次加载都降级成「待发SKU=0 / 订单驱动=0」。
* ② 待发货分支补 order_date 下界(见 PENDING_ORDER_MAX_AGE_DAYS),不再扫历史僵尸单。
* ③ 缓存改为 stale-while-revalidate:过期后**先返回旧值**、后台补新值,
* 请求路径不再为冷查买单(实测首屏冷查 126.9s vs 缓存命中 4~5s)。
* ④ TTL 10 → 30 分钟(ORDER_INDEX_CACHE_TTL_MS),配合 jobs/mkhBomPrewarmJob
* 每 20 分钟后台预热 → 正常使用期间请求路径根本撞不上冷查。
*/ */
async function loadOrderIndex() { async function loadOrderIndex(queryOptions = {}) {
const now = Date.now(); const now = Date.now();
if (orderIndexCache?.value && orderIndexCache.expiresAt > now) { const force = queryOptions.force === true;
return orderIndexCache.value; const cached = orderIndexCache?.value || null;
if (!force && cached && orderIndexCache.expiresAt > now) {
return cached;
}
// 过期但有旧值:先给旧值,后台刷新(不阻塞请求)。
// 只有「确实没有旧值」(进程刚起 / 缓存被清)才让调用方等冷查。
if (cached && !force) {
if (!orderIndexCache.pending) {
loadOrderIndex({ force: true }).catch(() => {});
}
return cached;
} }
if (orderIndexCache?.pending) return orderIndexCache.pending; if (orderIndexCache?.pending) return orderIndexCache.pending;
@ -1647,14 +1702,26 @@ async function loadOrderIndex() {
WHERE o.skus LIKE @pendingOrderSkuLike WHERE o.skus LIKE @pendingOrderSkuLike
AND o.status NOT IN (${statusPlaceholders}) AND o.status NOT IN (${statusPlaceholders})
AND ( AND (
o.send_date IS NULL (
-- 待发货:只认近 N 天的单(见 PENDING_ORDER_MAX_AGE_DAYS),
-- 原写法没有时间下界,半年以前的僵尸单也会全表参与扫描与累计。
-- order_date 为空视为「新单」照旧纳入:宁可多算,不可漏算真实待发。
o.send_date IS NULL
AND ISNULL(o.order_date, CAST(GETDATE() AS date))
>= DATEADD(DAY, -${PENDING_ORDER_MAX_AGE_DAYS}, CAST(GETDATE() AS date))
)
OR ( OR (
o.send_date >= DATEADD(DAY, -${SALE_WINDOW_DAYS - 1}, CAST(GETDATE() AS date)) o.send_date >= DATEADD(DAY, -${SALE_WINDOW_DAYS - 1}, CAST(GETDATE() AS date))
AND o.send_date < DATEADD(DAY, 1, CAST(GETDATE() AS date)) AND o.send_date < DATEADD(DAY, 1, CAST(GETDATE() AS date))
) )
)`, )`,
{ pendingOrderSkuLike: PENDING_ORDER_SKU_LIKE, ...statusParams }, { pendingOrderSkuLike: PENDING_ORDER_SKU_LIKE, ...statusParams },
{ requestTimeout: 180000 } {
// 必须走独立连接:共享池的池级 60s 超时改不动(见 ORDER_QUERY_TIMEOUT_MS)
freshConnection: true,
connectRequestTimeoutMs: ORDER_QUERY_TIMEOUT_MS,
maxAttempts: ORDER_QUERY_MAX_ATTEMPTS,
}
))).then(async (results) => { ))).then(async (results) => {
const pendingBySku = new Map(); const pendingBySku = new Map();
const shippedBySku = new Map(); const shippedBySku = new Map();
@ -1753,12 +1820,15 @@ async function loadOrderIndex() {
ttl: PENDING_ORDER_DEGRADED_TTL_MS, ttl: PENDING_ORDER_DEGRADED_TTL_MS,
}; };
} }
return { pendingBySku, shippedBySku, degraded: false, error: null, ttl: MKH_CACHE_TTL_MS }; return { pendingBySku, shippedBySku, degraded: false, error: null, ttl: ORDER_INDEX_CACHE_TTL_MS };
}); });
const epoch = cacheEpoch; const epoch = cacheEpoch;
const operationalEpoch = operationalCacheEpoch; const operationalEpoch = operationalCacheEpoch;
orderIndexCache = { pending, value: null, expiresAt: 0 }; // 刷新期间保留旧值:并发请求照旧拿到旧快照,不必陪着这次(可能几分钟的)全表扫描一起等。
const staleValue = orderIndexCache?.value || null;
const staleExpiresAt = orderIndexCache?.expiresAt || 0;
orderIndexCache = { pending, value: staleValue, expiresAt: staleExpiresAt };
try { try {
const value = await pending; const value = await pending;
if (epoch === cacheEpoch && operationalEpoch === operationalCacheEpoch) { if (epoch === cacheEpoch && operationalEpoch === operationalCacheEpoch) {
@ -1766,7 +1836,13 @@ async function loadOrderIndex() {
} }
return value; return value;
} catch (error) { } catch (error) {
if (epoch === cacheEpoch && operationalEpoch === operationalCacheEpoch) orderIndexCache = null; if (epoch === cacheEpoch && operationalEpoch === operationalCacheEpoch) {
// 刷新失败:有旧值就继续用(比空索引好得多,空索引会让待发货量显示 0),
// 并把「下次再试」压到 1 分钟后 —— 否则每个请求都会去撞一次全表扫描。
orderIndexCache = staleValue
? { pending: null, value: staleValue, expiresAt: Date.now() + ORDER_INDEX_RETRY_AFTER_FAILURE_MS }
: null;
}
throw error; throw error;
} }
} }
@ -2349,7 +2425,7 @@ async function getMkhBomList(query = {}) {
operationalRefreshedAt: operationalRefreshedAt operationalRefreshedAt: operationalRefreshedAt
? new Date(operationalRefreshedAt).toISOString() ? new Date(operationalRefreshedAt).toISOString()
: null, : null,
// 加工单数据源(链接服务器)不可用时为 true,此时在途量按 0 处理 // 加工单数据源不可用(查询失败)时为 true,此时在途量按 0 处理
workOrderDegraded: replenishIndex.workOrderDegraded === true, workOrderDegraded: replenishIndex.workOrderDegraded === true,
workOrderWarehouse: WORK_ORDER_WAREHOUSE, workOrderWarehouse: WORK_ORDER_WAREHOUSE,
// 待发货订单数据源不可用时为 true,此时待发货量按 0 处理(退化为旧口径) // 待发货订单数据源不可用时为 true,此时待发货量按 0 处理(退化为旧口径)
@ -2636,6 +2712,40 @@ async function refreshMkhOperationalData() {
} }
} }
/**
* 后台预热:把「订单两表全表扫」这个重查询挪出用户请求路径。
* 由 jobs/mkhBomPrewarmJob 在启动后、以及每 20 分钟调用一次(可用环境变量调整)。
*
* 为什么需要它:订单索引是整页唯一的重查询(冷查实测 126.9s 首屏、`loadOrderIndex` 单跑 408.5s),
* 而页面其它数据全在内存里算。只要索引一直是热的,打开页面就稳定在 4~5 秒;
* 一旦让它自然过期,下一位用户就得为冷查买单。
*
* 失败不影响功能(下一次请求会自己撞冷查),所以调用方只记日志、不重试。
* @returns {Promise<{elapsedMs: number, steps: string[]}>}
*/
async function prewarmMkhBomIndex() {
const startedAt = Date.now();
const steps = [];
// ① 订单索引:剩余有效期不足一半就强制刷一次。
// 预热 20 分钟一轮 + TTL 30 分钟 → 实际每轮都会刷(剩余 ≈10 分钟 < 15 分钟)。
const remaining = orderIndexCache?.expiresAt ? orderIndexCache.expiresAt - Date.now() : 0;
if (!orderIndexCache?.value || remaining < ORDER_INDEX_CACHE_TTL_MS / 2) {
const orderStartedAt = Date.now();
await loadOrderIndex({ force: true });
steps.push(`orderIndex=${Date.now() - orderStartedAt}ms`);
} else {
steps.push('orderIndex=fresh');
}
// ② 库存/箱表/加工单/待发货合并索引(内部会复用上一步刚刷好的订单索引)
const replenishStartedAt = Date.now();
await loadReplenishIndex();
steps.push(`replenishIndex=${Date.now() - replenishStartedAt}ms`);
return { elapsedMs: Date.now() - startedAt, steps };
}
function clearMkhBomCache() { function clearMkhBomCache() {
// 🔥 先自增代际,再清各缓存:这样「本次清缓存之前已经发起、还没返回」的查询, // 🔥 先自增代际,再清各缓存:这样「本次清缓存之前已经发起、还没返回」的查询,
// 回来时 epoch 对不上,就不会把旧快照写回缓存(否则会覆盖掉清缓存后新查到的值, // 回来时 epoch 对不上,就不会把旧快照写回缓存(否则会覆盖掉清缓存后新查到的值,
@ -2670,10 +2780,21 @@ function clearMkhBomCache() {
}; };
} }
// ── 仅供单测:观察 / 催熟订单索引缓存状态 ─────────────────────────
// stale-while-revalidate 的行为依赖「缓存过期」这个时刻,用真实时钟没法稳定构造,
// 所以给测试两个只读/催熟钩子(挂在 _private 下,不参与业务逻辑)。
const getOrderIndexCacheState = () => (orderIndexCache
? { hasValue: Boolean(orderIndexCache.value), expiresAt: orderIndexCache.expiresAt, pending: Boolean(orderIndexCache.pending) }
: null);
const expireOrderIndexCacheForTest = () => {
if (orderIndexCache?.value) orderIndexCache = { ...orderIndexCache, expiresAt: 0 };
};
module.exports = { module.exports = {
getMkhBomList, getMkhBomList,
clearMkhBomCache, clearMkhBomCache,
refreshMkhOperationalData, refreshMkhOperationalData,
prewarmMkhBomIndex,
getMkhBomDetail, getMkhBomDetail,
listReplenishAlertRows, listReplenishAlertRows,
listMkhBomExportRows, listMkhBomExportRows,
@ -2733,13 +2854,27 @@ module.exports = {
SCOPES, SCOPES,
WARNING_LEVEL, WARNING_LEVEL,
WORK_ORDER_WAREHOUSE, WORK_ORDER_WAREHOUSE,
WORK_ORDER_WMS_CO_ID,
WORK_ORDER_VOID_STATUS, WORK_ORDER_VOID_STATUS,
WORK_ORDER_RECEIVED_STATUS, WORK_ORDER_RECEIVED_STATUS,
WORK_ORDER_INFO_TABLE,
WORK_ORDER_ITEM_TABLE,
EXPORT_MODES, EXPORT_MODES,
buildProductExportRows, buildProductExportRows,
buildComponentExportRows, buildComponentExportRows,
clearMkhOperationalCache, clearMkhOperationalCache,
refreshMkhOperationalData, refreshMkhOperationalData,
prewarmMkhBomIndex,
OPERATIONAL_REFRESH_DEDUPE_MS, OPERATIONAL_REFRESH_DEDUPE_MS,
// 订单链路性能参数(2026-11-17)
ORDER_QUERY_TIMEOUT_MS,
ORDER_QUERY_MAX_ATTEMPTS,
ORDER_INDEX_CACHE_TTL_MS,
ORDER_INDEX_RETRY_AFTER_FAILURE_MS,
PENDING_ORDER_MAX_AGE_DAYS,
PENDING_ORDER_DEGRADED_TTL_MS,
OUTBOUND_QUERY_TIMEOUT_MS,
getOrderIndexCacheState,
expireOrderIndexCacheForTest,
}, },
}; };

View File

@ -4,7 +4,7 @@
* 仓储中心物流转运异常(2026-10-21 新增) * 仓储中心物流转运异常(2026-10-21 新增)
* ──────────────────────────────────────────────────────────────────────────── * ────────────────────────────────────────────────────────────────────────────
* 需求(yanhui 2026-10-21): * 需求(yanhui 2026-10-21):
* 在左侧栏加一栏「仓储中心物流转运异常」(放在「仓储中心 24 小时发货时效」下面), * 在左侧栏加一栏「仓储中心物流转运异常」(放在「仓储中心发货时效」下面),
* 下属 12 个发货仓: * 下属 12 个发货仓:
* 横林二仓 / 横林三仓 / 横林二仓品牌仓 / 崔桥工厂仓 / 崔桥工厂品牌仓 / * 横林二仓 / 横林三仓 / 横林二仓品牌仓 / 崔桥工厂仓 / 崔桥工厂品牌仓 /
* 崔桥工厂半成品包装项目仓 / 新苏北仓 / 睢宁仓 / 山东青岗集仓 / 山东品牌仓 / * 崔桥工厂半成品包装项目仓 / 新苏北仓 / 睢宁仓 / 山东青岗集仓 / 山东品牌仓 /

View File

@ -38,6 +38,10 @@ const EXPORT_DETAIL_LIMIT = 5000;
// 快照超过这么久没刷新 → 页面黄告警(这张表正常每小时刷一轮) // 快照超过这么久没刷新 → 页面黄告警(这张表正常每小时刷一轮)
const SNAPSHOT_STALE_MINUTES = 120; const SNAPSHOT_STALE_MINUTES = 120;
// 数据源(整张镜像表)多久没刷新算停更。与上面同值,但语义不同:
// SNAPSHOT_STALE_MINUTES 判的是「本批窗口内行的 query_time」,
// SOURCE_STALE_MINUTES 判的是「整张表最后被灌库的时刻」—— 窗口内 0 行时只能靠后者。
const SOURCE_STALE_MINUTES = Number(process.env.CANGKU_WLE_SOURCE_STALE_MINUTES) || 120;
const CACHE_TTL_MS = Number(process.env.CANGKU_WLE_CACHE_TTL_MS) || 5 * 60 * 1000; const CACHE_TTL_MS = Number(process.env.CANGKU_WLE_CACHE_TTL_MS) || 5 * 60 * 1000;
// key = `${verifyDate}|${limit}`。用 Map 而不是单槽缓存: // key = `${verifyDate}|${limit}`。用 Map 而不是单槽缓存:
@ -148,14 +152,61 @@ async function loadShippedPackages(batch) {
return rows || []; return rows || [];
} }
// 🔥 2026-11-14 修:原来调这里写的是 `{ timeoutMs: 240000 }` —— **这个参数没人读**。
// mssql 12.x 上请求级 request.timeout 不生效,超时只能靠池配置级 requestTimeout,
// 而共享池(query())的池级超时在 pool 创建时就定死了,改不了。结果是「想给 4 分钟」
// 实际一路按默认 60s 掐断(11-14 实测全表 MAX 已经跑不进 60s → 探测永远返回空)。
// 真正生效的写法只有 querySlow(临时独立连接)+ connectRequestTimeoutMs。
const SOURCE_LAST_UPDATE_TIMEOUT_MS = Number(process.env.CANGKU_WLE_SOURCE_LAST_UPDATE_TIMEOUT_MS)
|| 180000;
/**
* 整张镜像表最后被灌库的时刻(表级新鲜度)。
*
* 🔥 2026-11-02 新增,起因:11-02 09:00 那批推出「已发货 0 单 / 0 个包裹,异常 0 个包裹」,
* 业务问「怎么可能 0 单」。查出来镜像表 **11-01 07:55 之后就没再灌过**,
* 而 v1 的 freshness 只用「本批窗口内行的 query_time」算 —— 窗口一行都没有时
* `snapshotAt` 是空串 → `stale=false`、`hint=''`,页面和钉钉于是把它当成
* 「本批确实没有发货 / 全部正常」。这是最危险的一种假绿。
*
* 成本:全表 `MAX(query_time)` 在一个 402 万行的视图上实测 **13.5s**(谓词下推差),
* 所以**只在窗口 0 行时才调**(正常批次一行都不用付这笔钱),结果随主结果进 5 分钟缓存。
* ⚠️ 11-14 实测已退化到 60s 以上,所以超时上限 180s + maxAttempts=1
* (超时就退回「不知道」,重试只会把等待翻倍 —— 原来 query() 默认 2 次 × 60s 白等)。
*
* @returns {Promise<string>} 'YYYY-MM-DD HH:mm:ss',取不到返回空串
*/
async function loadSourceLastUpdate() {
try {
const rows = await cloudDatabase.querySlow(
`SELECT MAX(e.query_time) AS max_q
FROM dbo.jst_order_express_details e WITH (NOLOCK)`,
{},
{ connectRequestTimeoutMs: SOURCE_LAST_UPDATE_TIMEOUT_MS, maxAttempts: 1 }
);
return formatDateTime(rows?.[0]?.max_q);
} catch (err) {
// 探测失败不该让整页挂掉:退回「不知道」,hint 里会说明取不到表级时间
console.warn(`[WLE] 数据源新鲜度探测失败:${err.message}`);
return '';
}
}
// 售后拦截判定:一次 IN 多少单 + 查询超时。 // 售后拦截判定:一次 IN 多少单 + 查询超时。
// 这两张售后表在 rpt 副本里**都是堆表(零索引)**,`o_id IN (...)` 只能全表扫, // 这两张售后表在 rpt 副本里**都是堆表(零索引)**,`o_id IN (...)` 只能全表扫,
// 实测 125 万行的 returnAndRefund 4.5s、176 万行的 qmcust 8.5s —— 所以: // 实测 125 万行的 returnAndRefund 4.5s、176 万行的 qmcust 8.5s —— 所以:
// · 只查「本来就会报异常」的 oId(正常单不查,量级从 9800 降到几十); // · 只查「本来就会报异常」的 oId(正常单不查,量级从 9800 降到几十);
// · 两套店铺表**并发**查,总耗时取较慢的那条(~8.5s),而不是相加的 13s; // · 两套店铺表**并发**查,总耗时取较慢的那条(~8.5s),而不是相加的 13s;
// · 结果进 5 分钟结果缓存,页面自动刷新时基本命中缓存。 // · 结果进 5 分钟结果缓存,页面自动刷新时基本命中缓存。
//
// 🔥 2026-11-14 修:超时从「名义 240s」改成「真 20s,且不重试」。
// 原来写 `{ timeoutMs: 240000 }`(无效参数),实际按共享池 60s 掐;
// 超时后 query() 还把它当可重试错误 —— resetPool + 再查一次,**再多等 60s**。
// 11-13 09:10 那轮推送就是这么被拖掉 2 分钟的(日志:售后拦截 60s 超时 → 重连重试)。
// 售后表跟不上时业务影响只是「少剔几单」,不值得为它把整批核验拖进超时窗口:
// 2 倍实测余量(8.5s → 20s)够用,超了就降级不剔(catch 里已有兜底)。
const INTERCEPT_QUERY_BATCH = 500; const INTERCEPT_QUERY_BATCH = 500;
const INTERCEPT_QUERY_TIMEOUT_MS = 240000; const INTERCEPT_QUERY_TIMEOUT_MS = 20000;
/** /**
* 找出「现场拦截、货已被售后仓签收」的订单(业务 2026-10-23 口径)。 * 找出「现场拦截、货已被售后仓签收」的订单(业务 2026-10-23 口径)。
@ -185,7 +236,7 @@ async function loadInterceptedOrders(rows) {
const oIds = ids.slice(i, i + INTERCEPT_QUERY_BATCH).join(','); const oIds = ids.slice(i, i + INTERCEPT_QUERY_BATCH).join(',');
for (const source of registry.INTERCEPT_AFTERSALE_SOURCES) { for (const source of registry.INTERCEPT_AFTERSALE_SOURCES) {
tasks.push((async () => { tasks.push((async () => {
const hits = await cloudDatabase.query( const hits = await cloudDatabase.querySlow(
`SELECT h.o_id `SELECT h.o_id
FROM ${source.header} h WITH (NOLOCK) FROM ${source.header} h WITH (NOLOCK)
JOIN ${source.item} it WITH (NOLOCK) ON it.as_id = ${source.headerAsId} JOIN ${source.item} it WITH (NOLOCK) ON it.as_id = ${source.headerAsId}
@ -194,7 +245,8 @@ async function loadInterceptedOrders(rows) {
GROUP BY h.o_id GROUP BY h.o_id
HAVING SUM(ISNULL(it.r_qty, 0)) > 0`, HAVING SUM(ISNULL(it.r_qty, 0)) > 0`,
{}, {},
{ timeoutMs: INTERCEPT_QUERY_TIMEOUT_MS } // maxAttempts: 1 —— 超时就在 catch 里降级「不剔除」,别让重连重试再白等一轮
{ connectRequestTimeoutMs: INTERCEPT_QUERY_TIMEOUT_MS, maxAttempts: 1 }
); );
return hits || []; return hits || [];
})().catch((err) => { })().catch((err) => {
@ -315,7 +367,17 @@ async function getLogisticsExceptions(options = {}) {
orders: [], orders: [],
detailLimit: limit, detailLimit: limit,
truncated: false, truncated: false,
freshness: { snapshotAt: '', ageMinutes: null, stale: false, coversDeadline: null, hint: '' }, freshness: {
snapshotAt: '',
ageMinutes: null,
stale: false,
coversDeadline: null,
emptyWindow: false,
sourceLastUpdate: '',
sourceAgeMinutes: null,
sourceStale: false,
hint: '',
},
generatedAt, generatedAt,
cached: false, cached: false,
cacheAgeSec: 0, cacheAgeSec: 0,
@ -510,11 +572,33 @@ async function getLogisticsExceptions(options = {}) {
} }
// ── 新鲜度 ────────────────────────────────────────────────────────── // ── 新鲜度 ──────────────────────────────────────────────────────────
// 🔥 emptyWindow = 本批窗口里**一行都没取到**(12 仓范围)。
// 这时 snapshotAt 必然是空串,v1 的判据(coversDeadline=null、stale=false、hint='')
// 会让「上游没同步」和「当天真的没发货」长得一模一样,页面/钉钉都显示成 0 单全绿。
// 所以窗口为空时补查一次**表级**最后灌库时刻,把两种情形分开。
const emptyWindow = rows.length === 0;
const sourceLastUpdate = emptyWindow ? await loadSourceLastUpdate() : '';
const ageMinutes = snapshotAt ? diffMinutes(snapshotAt, generatedAt) : null; const ageMinutes = snapshotAt ? diffMinutes(snapshotAt, generatedAt) : null;
const stale = ageMinutes !== null && ageMinutes > SNAPSHOT_STALE_MINUTES; const stale = ageMinutes !== null && ageMinutes > SNAPSHOT_STALE_MINUTES;
const sourceAgeMinutes = sourceLastUpdate ? diffMinutes(sourceLastUpdate, generatedAt) : null;
const sourceStale = sourceAgeMinutes !== null && sourceAgeMinutes > SOURCE_STALE_MINUTES;
const coversDeadline = snapshotAt ? snapshotAt >= batch.deadline : null; const coversDeadline = snapshotAt ? snapshotAt >= batch.deadline : null;
let hint = ''; let hint = '';
if (coversDeadline === false) { if (emptyWindow) {
const lastText = sourceLastUpdate || '';
const hours = sourceAgeMinutes === null ? 0 : Math.round((sourceAgeMinutes / 60) * 10) / 10;
if (sourceStale) {
hint = `${batch.shipDate} 的发货记录在物流镜像表里一条都没有 —— 该表最后更新 ${lastText}(已 ${hours} 小时未同步)。`
+ ' 上面的「0 单 / 0 个包裹」是数据没进库,不代表当天没发货。'
+ ' 请先到聚水潭核对当天发货量,等上游同步后再刷新本页。';
} else if (lastText) {
hint = `${batch.shipDate} 在物流镜像表里 0 条发货记录(该表最后更新 ${lastText},数据源本身正常)。`
+ ' 若当天确实有发货,说明上游漏同步了这一天,请到聚水潭核对;若当天本就停发,这个 0 才是真的。';
} else {
hint = `${batch.shipDate} 在物流镜像表里 0 条发货记录,且取不到该表最后更新时间 ——`
+ ' 分不清是「当天没发货」还是「数据没同步」,请到聚水潭核对后再看本页。';
}
} else if (coversDeadline === false) {
hint = `物流快照最新只到 ${snapshotAt.slice(11, 16)},没覆盖本轮 ${batch.deadline.slice(11, 16)} 核验时刻 ——` hint = `物流快照最新只到 ${snapshotAt.slice(11, 16)},没覆盖本轮 ${batch.deadline.slice(11, 16)} 核验时刻 ——`
+ ' 之后才揽收/更新的轨迹没进来,异常量会偏大,请以上面「数据更新于」为准,或等上游同步后刷新。'; + ' 之后才揽收/更新的轨迹没进来,异常量会偏大,请以上面「数据更新于」为准,或等上游同步后刷新。';
} else if (stale) { } else if (stale) {
@ -561,6 +645,12 @@ async function getLogisticsExceptions(options = {}) {
ageMinutes, ageMinutes,
stale, stale,
coversDeadline, coversDeadline,
// 本批窗口 0 行:0 单含义不明,必须配合下面两个字段读
emptyWindow,
// 表级最后灌库时刻(只有 emptyWindow 时才探测,否则为空串)
sourceLastUpdate,
sourceAgeMinutes,
sourceStale,
hint, hint,
}, },
generatedAt, generatedAt,

View File

@ -1,7 +1,7 @@
'use strict'; 'use strict';
/** /**
* 「仓储中心 24 小时发货时效」两轮核验完成后推文本到钉钉群 —— 配置与状态存取 * 「仓储中心发货时效」两轮核验完成后推文本到钉钉群 —— 配置与状态存取
* ──────────────────────────────────────────────────────────────────────────── * ────────────────────────────────────────────────────────────────────────────
* 业务口径(2026-10-27): * 业务口径(2026-10-27):
* 「13 点核验 7 点前的超时单,核验完成后通知;18:00 核验的订单,核验完成后也通知。」 * 「13 点核验 7 点前的超时单,核验完成后通知;18:00 核验的订单,核验完成后也通知。」

View File

@ -1,10 +1,10 @@
'use strict'; 'use strict';
/** /**
* 仓储中心 24 小时发货时效(2026-10-20 新增) * 仓储中心发货时效(2026-10-20 新增)
* ──────────────────────────────────────────────────────────────────────────── * ────────────────────────────────────────────────────────────────────────────
* 需求(yanhui 2026-10-20): * 需求(yanhui 2026-10-20):
* MKH-BOM 列表左侧加一栏「仓储中心24小时发货时效」,下列 11 个仓: * MKH-BOM 列表左侧加一栏「仓储中心发货时效」,下列 11 个仓:
* 横林二仓 / 横林三仓 / 横林二仓品牌仓 / 崔桥工厂仓 / 崔桥工厂品牌仓 / * 横林二仓 / 横林三仓 / 横林二仓品牌仓 / 崔桥工厂仓 / 崔桥工厂品牌仓 /
* 崔桥工厂半成品包装项目仓 / 新苏北仓 / 睢宁仓 / 山东青岗集仓 / 山东品牌仓 / 河南洛宁仓 * 崔桥工厂半成品包装项目仓 / 新苏北仓 / 睢宁仓 / 山东青岗集仓 / 山东品牌仓 / 河南洛宁仓
* 从系统库存抓取「已发货订单」与「未发货订单」,按**订单审核时间**分轮核算。 * 从系统库存抓取「已发货订单」与「未发货订单」,按**订单审核时间**分轮核算。
@ -32,7 +32,10 @@
* rpt.jst_Orders —— 京东 / 拼多多 / 抖音 / 得物 / 唯品会 * rpt.jst_Orders —— 京东 / 拼多多 / 抖音 / 得物 / 唯品会
* rpt.jst_qmcust_orderlist —— 天猫 / 淘宝 / 1688 * rpt.jst_qmcust_orderlist —— 天猫 / 淘宝 / 1688
* 字段口径(2026-10-20 四次修正,全部以聚水潭「销售出库单」页面为准): * 字段口径(2026-10-20 四次修正,全部以聚水潭「销售出库单」页面为准):
* · 创建时间:**销售出库单的 `created`**(出库单创建时间) * 🔴 2026-10-28 现状:候选池取订单两表的 `send_date`,起算点取状态表的
* `last_oa_confirm_time`(审核时间),**下面这段「创建时间 = 出库单 created」
* 是老口径,仅作历史记录,不要再照着实现**。
* · 创建时间:**销售出库单的 `created`**(出库单创建时间)(已废弃)
* ⚠️ 不是 `order_date`(平台下单时间); * ⚠️ 不是 `order_date`(平台下单时间);
* ⚠️ 更不是 `modified` —— 实测数仓每天凌晨把整批订单的 modified 刷成 * ⚠️ 更不是 `modified` —— 实测数仓每天凌晨把整批订单的 modified 刷成
* 02:2x / 04:3x(样本 9765107 等 7 单全是 10-20 04:39~04:40, * 02:2x / 04:3x(样本 9765107 等 7 单全是 10-20 04:39~04:40,
@ -262,6 +265,48 @@ const OUTBOUND_TABLES = Object.freeze({
// ⚠️ 本表**没有金额**,金额要回订单表按 `o_id = inner_order_id` 取。 // ⚠️ 本表**没有金额**,金额要回订单表按 `o_id = inner_order_id` 取。
const ORDER_STATE_TABLE = 'jst_order_express_details'; const ORDER_STATE_TABLE = 'jst_order_express_details';
// ── 🔥 2026-10-28 数据源切换:主数据源改成「订单 + 订单明细」────────────────
// 业务 yanhui 2026-10-28 明确指出:「核验抓取的销售订单表是错误的,应该抓
// `jst_Orders`(订单)+ `jst_OrderItem`(订单明细),o_id → o_id;审核时间就是
// jst_Orders 里的创建时间」。
//
// 为什么原来那张状态镜像表不能用(实测证据):
// ① `send_time` 会**漏回写**:近 7 天「状态表说发货中+未发」的 4157 单里,
// 订单表已有 `send_date` 的 **563 单**、status 已是 Sent 的 492 单 ——
// 明明发了却还算超时;2026-10-28 06h/07h 那批大批量刷新后集中爆发。
// ② 状态表对**被合并 / 拆单父单**不回写(已有 89 + 755 单),必须回订单表看 status。
// ③ 状态表会**整批停更**:2026-10-27 11:54:59 之后 6.8 小时零写入,
// 18:00 轮推出去 34 单里混着已发货的(业务当场发现)。
// ④ 两张表发货时间**其实同源**:状态表 send_time 与订单表 send_date
// 27387 单逐条比对**零偏差** ⟹ 订单表才是权威,状态表只是它的滞后副本。
//
// ⟹ 主查询直接打订单两表(店铺互斥必须都读),**不再依赖状态表**。
// 仓库归属用订单表的 `wms_co_id`(不是状态表的仓名文本),更准。
// 状态表只剩「售后已作废」一个判据,实测在「发货中+未发」里只影响 4 单,可放弃。
const ORDER_SOURCE_TABLES = Object.freeze(['jst_Orders', 'jst_qmcust_orderlist']);
// 订单表 `status` 的取值(聚水潭实时状态,不是下单快照 —— 这一点
// `jst_Orders.status` 与代码历史上「status 不可信」的结论不同,见下面 CREATED 段说明):
// Delivering 发货中 —— **唯一该考核仓库的状态**
// WaitConfirm 待审核 —— 仓库还没接到单,单列「待审核」不计超时
// Question 疑问/异常 —— 单列「异常待处理」不计超时
// Sent 已发货 → 剔除
// Cancelled 已取消(业务叫「作废」)→ 剔除
// Split / Merged 拆单父单 / 被合并单 → 剔除(自己永不发货)
// WaitOuterSent 等供销商|外仓发货 → 剔除(不是本仓发)
// 近 30 天分布:Sent 132341 / Cancelled 66643 / Split 8251 / Question 2057 /
// Merged 1854 / Delivering 1446 / WaitConfirm 190 / WaitOuterSent 45
const ORDER_PENDING_STATUS = 'Delivering';
const ORDER_UNAUDITED_STATUS = 'WaitConfirm';
const ORDER_QUESTION_STATUS = 'Question';
const ORDER_SHIPPED_STATUS = 'Sent';
// 主查询只捞这三种(其余状态一律不进候选,SQL 侧就过滤掉,不传回 Node)
const ORDER_CANDIDATE_STATUSES = Object.freeze([
ORDER_PENDING_STATUS,
ORDER_UNAUDITED_STATUS,
ORDER_QUESTION_STATUS,
]);
// 「发货中」= 已审核、仓库还没发货 —— **唯一该考核仓库的状态** // 「发货中」= 已审核、仓库还没发货 —— **唯一该考核仓库的状态**
const SHIPPING_STATUS = '发货中'; const SHIPPING_STATUS = '发货中';
// 「已支付待审核」= 还没审单,仓库根本没接到 → 不计超时(单列为「待审核」) // 「已支付待审核」= 还没审单,仓库根本没接到 → 不计超时(单列为「待审核」)
@ -276,24 +321,26 @@ const ABNORMAL_STATUS = '异常';
// 漏掉这个排除,整个页面会被作废单淹没。 // 漏掉这个排除,整个页面会被作废单淹没。
const IGNORED_STATES = Object.freeze(['已发货', '已取消', '等供销商|外仓发货']); const IGNORED_STATES = Object.freeze(['已发货', '已取消', '等供销商|外仓发货']);
// ── 起算点:聚水潭「创建时间」────────────────────────────────────────────── // ── 起算点:聚水潭「审核时间」`last_oa_confirm_time` ────────────────────────
// 业务 2026-10-20 最终定版:「起算点是聚水潭的创建时间,不是审核时间」。 // 🔥 2026-10-28 **下午二次纠偏**(业务 yanhui 拿 9837824 打回来):
// 起算点是**审核时间**,不是订单创建时间。证据:
// 9837824 created 10-19 23:44:22 → last_oa_confirm_time 10-28 09:58:42,
// 积压 8 天半;仓库 09:58 审核、10:09:55 快递员就上门取件。
// 按 created 算「超时 205 小时」= 把客服审核积压算到仓库头上。
// 量化(10-28 13:00 轮 599 单):376 单是当天 08:10~10:30 才批量审核的,
// 按审核时间分轮后 13:00 轮只剩 247(再剔除漏回写的已发单 → 138)。
// //
// ⚠️ 状态表 `jst_order_express_details` **没有**聚水潭创建时间,必须回订单表补: // ⚠️ 上午那版注释里「created 100% 早于 last_oa_confirm_time,正常差 7~40 分钟,
// · `createdAt`(本表那个 datetime2)—— ❌ **不是**订单创建时间。 // 业务要求按创建时间算」已被推翻 —— 那句话只统计了当期正常单,
// 实测比付款晚 1.5~3.5 小时(261019-… pay 21:05:16 / createdAt 次日 00:23:51), // 长尾积压单能差 8~11 天。**别再把起算点改回 created。**
// 是**同步落库时间**,用了会把起算点整体推后几小时。
// · `pay_time` —— ❌ 付款时间,业务明确说「这一单的创建还是按照付款时间来的」,
// 要换掉。
// · ✅ `jst_Orders.created` / `jst_qmcust_orderlist.created` —— **聚水潭创建时间**,
// 稳定比下单/付款晚 15~30 秒(抽样 00:07:23 → 00:07:41),
// 这才是聚水潭订单列表里「创建时间」那一列。
// //
// 性能(2026-10-20 实测 9,676 个候选): // 审核时间只存在于状态镜像表 `jst_order_express_details`(订单两表没有这个字段),
// 只投影 `o_id, created` 两列、分批 200 → jst_Orders **14.5s** + qmcust **2.9s**。 // 由 service 层按 `inner_order_id IN (...)` 批量取;取不到时回退 created 并标 `*`。
// 🔥 千万别顺手把 pay_amount / labels 一起取出来:同样 IN 400 个只要 **38.7s**。 // 用 last 而不是 first:业务认为改单重审后重新进作业流,从最后一次审核计时
// (代价是重复审核会冲掉已累计超时,业务已知悉)。
const CREATED_SOURCE_TABLES = Object.freeze(['jst_Orders', 'jst_qmcust_orderlist']); const CREATED_SOURCE_TABLES = Object.freeze(['jst_Orders', 'jst_qmcust_orderlist']);
// 分批大小:200 实测最快(再大收益递减,再小批数太多) // 分批大小:200 实测最快(再大收益递减,再小批数太多)
// ⚠️ 2026-10-28 起主链路已不用(created 直接从主查询取),保留给历史脚本/测试引用。
const CREATED_BACKFILL_BATCH = 200; const CREATED_BACKFILL_BATCH = 200;
// ── 订单表里的「作废」状态:这些单不会由本单发货,必须剔除 ───────────────── // ── 订单表里的「作废」状态:这些单不会由本单发货,必须剔除 ─────────────────
@ -331,6 +378,64 @@ const VOID_ORDER_LABEL_KEYWORDS = Object.freeze(['发货前售后']);
// 万一哪天出现「发货中 + 已作废 + 订单表也不是 Sent」,不至于再被算成超时。 // 万一哪天出现「发货中 + 已作废 + 订单表也不是 Sent」,不至于再被算成超时。
const AFTERSALE_VOID_STATUS = '已作废'; const AFTERSALE_VOID_STATUS = '已作废';
/**
* 状态镜像表 `jst_order_express_details.order_status_name` 的**终态**。
*
* 🔥 2026-10-29 血的教训(业务第三次报「作废单/已发单还在考核里」):
* 订单两表**会各自停更**(当天 qmcust 停在 07:25、jst_Orders 停在 12:45),
* 停更期间在聚水潭做的「取消 / 发货」动作,订单表里根本看不到 ——
* 订单 status 仍是 `Delivering`、`send_date` 仍是空,于是被当成真超时。
* 状态镜像表虽然也会停(当天 11:52),但**比订单表新鲜 4 小时**,
* 而且 `order_status_name` 是聚水潭订单状态的直接映射。
*
* 实测(2026-10-29 13:00 轮 159 单):
* · `order_status_name='已取消'` 11 单 —— 订单表的 `labels` 里**没有**「发货前售后」
* 这个关键词(`presaleVoid` 判据完全失效),状态表的 `order_labels` 才有,且带
* 「已打印被取消」。业务就是拿这 11 单说「作废的也在考核之内」。
* · `order_status_name='已发货'` 0 单 —— 机制上必须有,否则停更期发的货永远判不出。
*
* ⚠️ **`aftersale_status_name='已作废'` 不是作废单**!那是「售后单被撤销」,
* 订单照常发货、**仍然要考核**(近 2 天 1387 单都是这种)。别把两个混为一谈,
* 能判「这单不用发了」的只有 `order_status_name='已取消'`。
*/
const STATE_ORDER_VOID_STATUS = '已取消';
const STATE_ORDER_SHIPPED_STATUS = '已发货';
/**
* 销售出库单 `status` 里**等于单据作废**的值。
*
* 🔥 2026-10-29 新增(业务点名 9992097 等 9 单:「在聚水潭的销售出库单里找一下这个作废单据」)。
*
* 聚水潭的作废会落在**出库单**上:`jst_salesOutboundInfo.status` / `jst_qmcust_salesoutbound.status`
* 取值只有四种(近 2 天实测):`Confirmed` / `WaitConfirm` / `Delete` / `OuterConfirming`,
* 其中 `Delete` 就是单据作废。
*
* 为什么必须加这一条判据(状态表 `order_status_name='已取消'` 不够):
* · 出库单 `Delete` 的近 7 天样本里,**55 单订单表仍是 `Delivering`、36 单是 `Question`**,
* 这些单状态镜像表未必抓得到(它一天只抓几次),只能靠出库单判;
* · 出库单是仓库侧最贴身的单据,作废动作一定先落在这里。
*
* ⚠️ **不能只看「有 Delete 就算作废」**:一个订单可能有多张出库单(拆包 / 重开),
* 删掉旧的那张、新的还在 `WaitConfirm` —— 这种单照常要发。
* ⟹ 判据是「**该订单没有任何非 Delete 的出库单**」,见 service 里 ioAllDeleted 的说明。
*
* ⚠️ 也**不能**用「没有出库单」当判据:近 3 天未发单里 **82%(1467/1790)本来就没有出库单**
* (订单还没推下游),拿它判作废会把绝大多数正常待发单全放跑。
*/
const IO_VOID_STATUS = 'Delete';
/**
* 状态镜像表 `logistic_status_name` 里**等于已发**的值。
*
* `拒收` 也算已发 —— 快递拿走过了,客户拒收是后续环节,仓库的发货动作已完成。
* ⚠️ **`无物流单` 不算**(39/159 单是这种:单子还没录快递单,可能自提/待定),
* `未揽收` 也不算(只是打了单,快递还没来取)。
* ⚠️ 别拿 `logistic_time` 当发货时间:它多数是「快递员将上门取件」的预告。
*/
const STATE_LOGISTIC_SHIPPED_STATUSES = Object.freeze([
'已揽收', '运输中', '派送中', '已签收', '拒收',
]);
// 24 小时发货时效 —— ⚠️ 仅用于**页面命名/路由**,**不参与判定**。 // 24 小时发货时效 —— ⚠️ 仅用于**页面命名/路由**,**不参与判定**。
// 2026-10-20 三次调整后判定改成「到 13:00 / 18:00 核验时刻仍未发即超时」, // 2026-10-20 三次调整后判定改成「到 13:00 / 18:00 核验时刻仍未发即超时」,
// 没有滚动 24 小时窗口(见 SHIP_TIMELINESS_HOURS 的历史误用记录)。 // 没有滚动 24 小时窗口(见 SHIP_TIMELINESS_HOURS 的历史误用记录)。
@ -439,12 +544,29 @@ async function loadCenterWarehouseMap(force = false) {
warehouseCache = { warehouseCache = {
at: Date.now(), at: Date.now(),
rows: list, rows: list,
// 全量「wms_co_id → 仓名」映射(**含归不到主仓的仓**)。
// 发货时效主查询不再 LEFT JOIN 仓表(实测 JOIN 会让执行计划从 28s 恶化到 61~105s),
// 改为在主查询里取回 wms_co_id、在 Node 侧用这份缓存换名字。
allNames: rows.map((r) => ({ wmsCoId: Number(r.wms_co_id), name: String(r.name || '') })),
unmatched,
unmatchedCount: unmatched.length, unmatchedCount: unmatched.length,
excluded, excluded,
}; };
return list; return list;
} }
/** 全量「wms_co_id → 仓名」映射(含归不到主仓的仓),供 service 侧做仓名还原 */
async function loadWarehouseNameMap() {
if (Date.now() - warehouseCache.at >= WAREHOUSE_CACHE_TTL_MS || !warehouseCache.rows.length) {
await loadCenterWarehouseMap();
}
const map = new Map();
for (const r of warehouseCache.allNames || []) {
if (Number.isFinite(r.wmsCoId)) map.set(r.wmsCoId, r.name);
}
return map;
}
function clearWarehouseCache() { function clearWarehouseCache() {
warehouseCache = { at: 0, rows: [] }; warehouseCache = { at: 0, rows: [] };
} }
@ -557,6 +679,7 @@ module.exports = {
centerWindowEnd, centerWindowEnd,
nextRoundDeadline, nextRoundDeadline,
loadCenterWarehouseMap, loadCenterWarehouseMap,
loadWarehouseNameMap,
clearWarehouseCache, clearWarehouseCache,
getWarehouseCache: () => warehouseCache, getWarehouseCache: () => warehouseCache,
resolveActiveRound, resolveActiveRound,
@ -569,6 +692,13 @@ module.exports = {
NOT_SPLIT_MERGED_SQL, NOT_SPLIT_MERGED_SQL,
OUTBOUND_TABLES, OUTBOUND_TABLES,
ORDER_STATE_TABLE, ORDER_STATE_TABLE,
// 2026-10-28 起主数据源 = 订单两表(状态表退居兜底)
ORDER_SOURCE_TABLES,
ORDER_PENDING_STATUS,
ORDER_UNAUDITED_STATUS,
ORDER_QUESTION_STATUS,
ORDER_SHIPPED_STATUS,
ORDER_CANDIDATE_STATUSES,
SHIPPING_STATUS, SHIPPING_STATUS,
UNAUDITED_STATUS, UNAUDITED_STATUS,
ABNORMAL_STATUS, ABNORMAL_STATUS,
@ -579,6 +709,10 @@ module.exports = {
VOID_QUESTION_STATUS, VOID_QUESTION_STATUS,
VOID_ORDER_LABEL_KEYWORDS, VOID_ORDER_LABEL_KEYWORDS,
AFTERSALE_VOID_STATUS, AFTERSALE_VOID_STATUS,
STATE_ORDER_VOID_STATUS,
STATE_ORDER_SHIPPED_STATUS,
STATE_LOGISTIC_SHIPPED_STATUSES,
IO_VOID_STATUS,
SHIP_TIMELINESS_HOURS, SHIP_TIMELINESS_HOURS,
toNumber, toNumber,
}; };

File diff suppressed because it is too large Load Diff

View File

@ -395,8 +395,12 @@ test('replenish: products without sales stay "no sale" even with a pending work
test('pending work order filters keep the business-confirmed source and exclusions', () => { test('pending work order filters keep the business-confirmed source and exclusions', () => {
assert.equal(_private.WORK_ORDER_WAREHOUSE, '简尚-崔桥工厂半成品包装项目仓'); assert.equal(_private.WORK_ORDER_WAREHOUSE, '简尚-崔桥工厂半成品包装项目仓');
assert.equal(_private.WORK_ORDER_VOID_STATUS, '作废'); // 2026-11-11 换源:聚水潭原生加工单三表(po_id 关联),状态值域为英文
assert.equal(_private.WORK_ORDER_RECEIVED_STATUS, '全部入库'); assert.equal(_private.WORK_ORDER_WMS_CO_ID, 15718196);
assert.equal(_private.WORK_ORDER_VOID_STATUS, 'Cancelled');
assert.equal(_private.WORK_ORDER_RECEIVED_STATUS, 'Finished');
assert.equal(_private.WORK_ORDER_INFO_TABLE, 'rpt.jst_manufactureInfo');
assert.equal(_private.WORK_ORDER_ITEM_TABLE, 'rpt.jst_manufactureItem');
assert.equal(_private.WARNING_LEVEL.SCHEDULED, '已排产'); assert.equal(_private.WARNING_LEVEL.SCHEDULED, '已排产');
}); });
@ -1514,3 +1518,190 @@ test('operational refresh: 并发刷新只查一次运营数据,短时重试
svc.clearMkhBomCache(); svc.clearMkhBomCache();
} }
}); });
// ── 2026-11-17 订单链路性能(「每次打开 / 刷新都慢、导出也卡」)──────────
// 实测背景:rpt.jst_Orders 158 万行光 COUNT(*) 要 152.8s(≈1 万行/秒),
// `skus LIKE '%MKH%'` 前导通配必然全表扫;而旧代码传的 `requestTimeout: 180000`
// 在共享池上不生效(请求级 request.timeout 在 mssql 12.x 无效)→ 60s 必超时降级。
test('order index: 订单查询走独立连接并放大超时(否则共享池 60s 必超时降级)', async () => {
const cloudDatabase = require('../src/config/cloudDatabase');
const svc = require('../src/services/mkhBomService');
const originalQuery = cloudDatabase.query;
const calls = [];
cloudDatabase.query = async (sql, params, options) => {
calls.push({ sql: String(sql), params: params || {}, options: options || {} });
return [];
};
try {
svc.clearMkhBomCache();
await svc._private.loadOrderIndex();
const orderCalls = calls.filter((call) => call.sql.includes('o.skus LIKE'));
assert.equal(orderCalls.length, 2, '两张渠道订单表都要读(只读一张会漏需求)');
orderCalls.forEach((call) => {
assert.equal(call.options.freshConnection, true, '必须显式要一条独立连接');
assert.equal(
call.options.connectRequestTimeoutMs,
svc._private.ORDER_QUERY_TIMEOUT_MS,
'超时必须走连接级参数'
);
assert.ok(call.options.connectRequestTimeoutMs >= 300000, '超时下限 5 分钟(实测单表 COUNT 就要 152.8s)');
assert.equal(call.options.maxAttempts, 1, '慢库重连重试只会把等待翻倍');
assert.equal(call.options.requestTimeout, undefined, '不要再传那个名义上生效的 requestTimeout');
});
} finally {
cloudDatabase.query = originalQuery;
svc.clearMkhBomCache();
}
});
test('order index: 待发货分支带近 180 天下界,不再扫历史僵尸单', async () => {
const cloudDatabase = require('../src/config/cloudDatabase');
const svc = require('../src/services/mkhBomService');
const originalQuery = cloudDatabase.query;
const sqls = [];
cloudDatabase.query = async (sql) => {
sqls.push(String(sql));
return [];
};
try {
svc.clearMkhBomCache();
await svc._private.loadOrderIndex();
const orderSql = sqls.find((sql) => sql.includes('o.skus LIKE')) || '';
assert.match(
orderSql,
/o\.send_date IS NULL\s+AND ISNULL\(o\.order_date/,
'待发货必须把 order_date 下界和 send_date IS NULL 绑在一起'
);
assert.ok(
orderSql.includes(`DATEADD(DAY, -${svc._private.PENDING_ORDER_MAX_AGE_DAYS}`),
'下界天数必须来自常量(默认 180 天)'
);
assert.equal(svc._private.PENDING_ORDER_MAX_AGE_DAYS, 180);
} finally {
cloudDatabase.query = originalQuery;
svc.clearMkhBomCache();
}
});
test('order index: 源失败时降级缓存 5 分钟,避免每分钟重打慢库', async () => {
const cloudDatabase = require('../src/config/cloudDatabase');
const svc = require('../src/services/mkhBomService');
const originalQuery = cloudDatabase.query;
let queryCount = 0;
cloudDatabase.query = async (sql) => {
queryCount += 1;
if (String(sql).includes('jst_qmcust_orderlist')) {
throw new Error('Timeout: Request failed to complete in 60000ms');
}
return [];
};
try {
svc.clearMkhBomCache();
const index = await svc._private.loadOrderIndex();
assert.equal(index.degraded, true, '一张表失败要标降级');
assert.equal(svc._private.PENDING_ORDER_DEGRADED_TTL_MS, 5 * 60 * 1000, '降级缓存必须是 5 分钟');
assert.equal(index.ttl, 5 * 60 * 1000);
const state = svc._private.getOrderIndexCacheState();
const remaining = state.expiresAt - Date.now();
assert.ok(remaining > 4 * 60 * 1000, `降级态有效期应接近 5 分钟,实际 ${remaining}ms`);
const before = queryCount;
await svc._private.loadOrderIndex();
assert.equal(queryCount, before, '降级缓存有效期内不得重复扫表');
} finally {
cloudDatabase.query = originalQuery;
svc.clearMkhBomCache();
}
});
test('order index: 缓存过期后先返回旧值、后台刷新(用户不再为冷查买单)', async () => {
const cloudDatabase = require('../src/config/cloudDatabase');
const svc = require('../src/services/mkhBomService');
const originalQuery = cloudDatabase.query;
let phase = 'cold';
let orderQueries = 0;
// 模拟「后台刷新卡在 300s 大表扫描上」:永不 resolve,但绝不能拖住请求路径
const pendingForever = new Promise(() => {});
cloudDatabase.query = async (sql) => {
if (!String(sql).includes('o.skus LIKE')) return [];
orderQueries += 1;
if (phase === 'cold') {
return [{
oId: 1,
orderDate: new Date('2026-11-10T00:00:00Z'),
sendDate: null,
skus: '1.MKHDNZ0409260700059',
}];
}
return pendingForever;
};
try {
svc.clearMkhBomCache();
const first = await svc._private.loadOrderIndex();
assert.equal(first.pendingBySku.get('MKHDNZ0409260700059').pendingOrderQty, 1);
phase = 'stale';
svc._private.expireOrderIndexCacheForTest();
const startedAt = Date.now();
const second = await svc._private.loadOrderIndex();
const elapsed = Date.now() - startedAt;
assert.equal(second, first, '过期后必须立刻返回旧快照,而不是等后台刷新');
assert.ok(elapsed < 1000, `必须立刻返回(旧写法要等 126.9s 冷查),实际 ${elapsed}ms`);
await new Promise((resolve) => { setTimeout(resolve, 20); });
const state = svc._private.getOrderIndexCacheState();
assert.equal(state.pending, true, '必须真的发起了一次后台刷新');
assert.equal(orderQueries, 4, '前台 2 次(两张表)+ 后台刷新 2 次');
} finally {
cloudDatabase.query = originalQuery;
svc.clearMkhBomCache();
}
});
test('prewarm: 有效期过半不重查,过期则强制刷新订单索引', async () => {
const cloudDatabase = require('../src/config/cloudDatabase');
const svc = require('../src/services/mkhBomService');
const originalQuery = cloudDatabase.query;
let orderQueries = 0;
cloudDatabase.query = async (sql) => {
if (String(sql).includes('o.skus LIKE')) orderQueries += 1;
return [];
};
try {
svc.clearMkhBomCache();
await svc.prewarmMkhBomIndex();
const afterCold = orderQueries;
assert.equal(afterCold, 2, '冷启动预热要把两张订单表都查一遍');
// 刚刷完,剩余 30 分钟 > 一半 → 不该再查(预热 20 分钟一轮,不会白扫)
const fresh = await svc.prewarmMkhBomIndex();
assert.ok(fresh.steps.includes('orderIndex=fresh'), `实际步骤: ${fresh.steps.join(', ')}`);
assert.equal(orderQueries, afterCold, '有效期充足时不得重查订单表');
// 过期 → 下一轮预热必须强制刷新
svc._private.expireOrderIndexCacheForTest();
const refreshed = await svc.prewarmMkhBomIndex();
assert.ok(
refreshed.steps.some((step) => /^orderIndex=\d+ms$/.test(step)),
`过期后必须强制刷新,实际步骤: ${refreshed.steps.join(', ')}`
);
assert.equal(orderQueries, afterCold + 2);
} finally {
cloudDatabase.query = originalQuery;
svc.clearMkhBomCache();
}
});

View File

@ -145,22 +145,28 @@ test('状态为空时按运单号区分:有号=未揽收,无号=无物流单
const dbPath = require.resolve('../src/config/cloudDatabase'); const dbPath = require.resolve('../src/config/cloudDatabase');
function stubDb(rows, options = {}) { function stubDb(rows, options = {}) {
const calls = { times: 0, sql: [], params: [] }; const calls = { times: 0, sql: [], params: [], options: [], api: [] };
const handler = async (sql, params) => { const makeHandler = (api) => async (sql, params, opts) => {
calls.times += 1; calls.times += 1;
calls.sql.push(String(sql)); calls.sql.push(String(sql));
calls.params.push(params || {}); calls.params.push(params || {});
calls.options.push(opts || {});
calls.api.push(api);
// 售后拦截判定会额外查两张售后表 —— 按表名分流,别把物流行当成售后行 // 售后拦截判定会额外查两张售后表 —— 按表名分流,别把物流行当成售后行
if (/jst_returnAndRefundInfo|jst_qmcust_refundlist/u.test(String(sql))) { if (/jst_returnAndRefundInfo|jst_qmcust_refundlist/u.test(String(sql))) {
return options.interceptRows || []; return options.interceptRows || [];
} }
// 窗口 0 行时的「表级最后灌库时刻」探测
if (/MAX\(\s*e\.query_time\s*\)/iu.test(String(sql))) {
return options.sourceMaxQueryTime === undefined ? [] : [{ max_q: options.sourceMaxQueryTime }];
}
return rows; return rows;
}; };
require.cache[dbPath] = { require.cache[dbPath] = {
id: dbPath, id: dbPath,
filename: dbPath, filename: dbPath,
loaded: true, loaded: true,
exports: { query: handler, querySlow: handler }, exports: { query: makeHandler('query'), querySlow: makeHandler('querySlow') },
}; };
return calls; return calls;
} }
@ -672,3 +678,84 @@ test('售后表查询失败时降级:不剔单、不炸页面', async () => {
delete require.cache[require.resolve('../src/services/warehouseLogisticsExceptionRegistry')]; delete require.cache[require.resolve('../src/services/warehouseLogisticsExceptionRegistry')];
} }
}); });
// ── ⑧ 窗口 0 行:0 单不能被当成「当天没发货 / 全部正常」(2026-11-02)──────
// 起因:11-02 09:00 那批推出「已发货 0 单 / 0 个包裹,异常 0 个包裹」,
// 实况是镜像表 11-01 07:55 之后就没再灌库,11-01 的 12 仓发货记录一条都没进库。
test('窗口 0 行 + 数据源停更 → emptyWindow/sourceStale,hint 明说「数据没进库」', async () => {
const nov2 = new Date(2026, 10, 2, 10, 0, 0); // 2026-11-02 10:00(本机时区)
await withStub(async (svc, calls) => {
const data = await svc.getLogisticsExceptions({ date: '2026-11-02', now: nov2, limit: 100 });
assert.equal(data.summary.shippedOrders, 0);
assert.equal(data.freshness.emptyWindow, true);
assert.equal(data.freshness.sourceLastUpdate, '2026-11-01 07:55:04');
assert.ok(data.freshness.sourceAgeMinutes > 120, `应算出停更小时数,实际 ${data.freshness.sourceAgeMinutes}`);
assert.equal(data.freshness.sourceStale, true);
assert.match(data.freshness.hint, /一条都没有/);
assert.match(data.freshness.hint, /不代表当天没发货/);
// 只在空窗口才付那次全表 MAX(query_time)(实测 13.5s)
assert.equal(calls.sql.filter((s) => /MAX\(\s*e\.query_time\s*\)/iu.test(s)).length, 1);
}, [], { sourceMaxQueryTime: '2026-11-01 07:55:04' });
});
test('窗口 0 行但数据源是新的 → 仍然提示「0 条记录」,不能静默全绿', async () => {
const nov2 = new Date(2026, 10, 2, 10, 0, 0);
// ⚠️ sourceLastUpdate 必须是「相对真实现在」的时间,不能像原来那样硬编码 2026-11-02 09:58。
// 服务层算 ageMinutes 用的是 registry.beijingNow()(真实时钟),不是测试传进来的 now ——
// 硬编码的日期过一天就变成「停更 24h」,这个用例第二天起就必挂(2026-11-14 实测挂在 main 上)。
const freshText = new Intl.DateTimeFormat('sv-SE', {
timeZone: 'Asia/Shanghai',
year: 'numeric', month: '2-digit', day: '2-digit',
hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false,
}).format(new Date(Date.now() - 3 * 60 * 1000));
await withStub(async (svc) => {
const data = await svc.getLogisticsExceptions({ date: '2026-11-02', now: nov2, limit: 100 });
assert.equal(data.freshness.emptyWindow, true);
assert.equal(data.freshness.sourceStale, false, '表是新的,不该报停更');
assert.match(data.freshness.hint, /0 条发货记录/, '真 0 单也要说清是「库里没有记录」');
assert.match(data.freshness.hint, /数据源本身正常/);
}, [], { sourceMaxQueryTime: freshText });
});
test('窗口有行时不做全表探测(省掉 13.5s 的表级 MAX)', async () => {
await withStub(async (svc, calls) => {
const data = await svc.getLogisticsExceptions({ date: '2026-10-21', now: at(21, 10, 0), limit: 100 });
assert.equal(data.freshness.emptyWindow, false);
assert.equal(data.freshness.sourceLastUpdate, '');
assert.equal(calls.sql.filter((s) => /MAX\(\s*e\.query_time\s*\)/iu.test(s)).length, 0);
});
});
// ── ⑨ 超时参数必须「真生效」(2026-11-14)──────────────────────────────────
// 起因:11-13 09:10 那轮钉钉推送 300s 超时没推出去。查代码发现两处写了
// `{ timeoutMs: 240000 }` 想「给足 4 分钟」,而 cloudDatabase **根本不读 timeoutMs**
// (mssql 12.x 请求级 request.timeout 不生效,只能靠池配置级 requestTimeout,
// 共享池的池级超时创建时就定死了)—— 实际一路按 60s 掐断,
// 超时后 query() 还当可重试错误重连再查一次,日志里白等了约 2 分钟。
test('售后拦截查询走 querySlow + 20s 短超时 + 不重试', async () => {
await withStub(async (svc, calls) => {
await svc.getLogisticsExceptions({ date: '2026-10-21', now: at(21, 10, 0), limit: 100 });
const idx = calls.sql.findIndex((s) => /jst_returnAndRefundInfo|jst_qmcust_refundlist/u.test(s));
assert.ok(idx >= 0, '这批有异常单,应该去查售后表');
assert.equal(calls.api[idx], 'querySlow', '必须走 querySlow:query() 的池级超时调用方改不了');
assert.equal(calls.options[idx].connectRequestTimeoutMs, 20000, '2 倍实测余量(8.5s → 20s)就够');
assert.equal(calls.options[idx].maxAttempts, 1, '超时就降级「不剔除」,别重连重试白等一轮');
assert.equal(calls.options[idx].timeoutMs, undefined, 'timeoutMs 是无效参数,不许再写');
}, rows, { interceptRows: [{ o_id: 1 }] });
});
test('空窗口的表级 MAX 探测也走 querySlow(共享池 60s 跑不动全表)', async () => {
const nov2 = new Date(2026, 10, 2, 10, 0, 0);
await withStub(async (svc, calls) => {
await svc.getLogisticsExceptions({ date: '2026-11-02', now: nov2, limit: 100 });
const idx = calls.sql.findIndex((s) => /MAX\(\s*e\.query_time\s*\)/iu.test(s));
assert.ok(idx >= 0, '空窗口要探测表级最后灌库时刻');
assert.equal(calls.api[idx], 'querySlow');
assert.ok(
Number(calls.options[idx].connectRequestTimeoutMs) >= 120000,
`全表 MAX 实测已超 60s,必须放宽,实际 ${calls.options[idx].connectRequestTimeoutMs}`
);
assert.equal(calls.options[idx].maxAttempts, 1, '探测失败退回「不知道」即可,不值得重试');
assert.equal(calls.options[idx].timeoutMs, undefined);
}, [], { sourceMaxQueryTime: '2026-11-01 07:55:04' });
});

View File

@ -495,3 +495,249 @@ test('发文本:超长正文自动截断后仍会发出去(不是直接抛
stub.restore(); stub.restore();
} }
}); });
// ── ⑤ 0 单不能用「全部正常」糊过去(2026-11-02)──────────────────────────
// 实况:11-02 09:00 那批推的是「0 单 / 0 个包裹,异常 0 个包裹」,业务以为真没发货,
// 其实是物流镜像表 11-01 07:55 后就没同步。群里绝不能出现「全部正常」这种假绿。
test('数据源停更导致 0 单 → 正文首部醒目告警,且不出现「全部正常」', () => {
const data = sampleData({
rows: [],
summary: {
shippedOrders: 0, packageCount: 0, exceptionOrders: 0,
exceptionPackages: 0, exceptionRate: 0, centerCount: 0, byType: {},
},
exclusions: {},
freshness: {
emptyWindow: true,
sourceLastUpdate: '2026-11-01 07:55:04',
sourceAgeMinutes: 1565,
sourceStale: true,
hint: '11-01 的发货记录在物流镜像表里一条都没有',
},
});
const built = job.buildNotifyText(data, { maxDetailRows: 30 });
assert.match(built.text, /物流数据未同步/);
assert.match(built.text, /镜像表最后更新 2026-11-01 07:55:04/);
assert.match(built.text, /已 26\.1 小时未同步/);
assert.match(built.text, /不代表当天没发货/);
assert.ok(!built.text.includes('全部正常'), '数据没进库时不能说「全部正常」');
// 抬头仍要带「异常」关键词,否则钉钉自定义关键词会拒收
assert.match(built.text, /【仓储物流转运异常】/);
});
test('数据源正常但当天 0 条记录 → 说明是「库里没有记录」,不说「全部正常」也不谎报停更', () => {
const data = sampleData({
rows: [],
summary: {
shippedOrders: 0, packageCount: 0, exceptionOrders: 0,
exceptionPackages: 0, exceptionRate: 0, centerCount: 0, byType: {},
},
exclusions: {},
freshness: { emptyWindow: true, sourceLastUpdate: '2026-11-02 09:58:00', sourceAgeMinutes: 2, sourceStale: false },
});
const built = job.buildNotifyText(data, { maxDetailRows: 30 });
assert.match(built.text, /在物流镜像表里 0 条发货记录/);
assert.match(built.text, /数据源本身正常/);
assert.match(built.text, /请到聚水潭核对/);
assert.ok(!built.text.includes('物流数据未同步'), '表是新的,不能谎报停更');
assert.ok(!built.text.includes('全部正常'), '0 条不能糊成「全部正常」');
assert.ok(!built.text.includes('数据未覆盖核验时刻'), '0 单已有专门告警,别再叠一条快照告警');
});
// ── ⑥ 有异常时的快照新鲜度也必须进正文(2026-11-11)──────────────────
// 实况:镜像表停在 11-10 11:53,09:10 那批算出 990 单全部异常,正文只有一句
// 「异常 990 个(100%)」。群里没法分辨「真异常」和「数据停在昨天」,
// 而这恰恰决定当天要不要催快递。下面把两种降级(未覆盖核验时刻 / 快照过旧)钉死。
test('快照没覆盖核验时刻 → 正文点名「未覆盖」,并把前一天的日期带上(不能只写 11:53)', () => {
const data = sampleData({
freshness: {
snapshotAt: '2026-10-21 11:53:00',
ageMinutes: 1270,
stale: true,
coversDeadline: false,
emptyWindow: false,
},
});
const built = job.buildNotifyText(data, { maxDetailRows: 30 });
assert.match(built.text, /数据未覆盖核验时刻/);
assert.match(built.text, /最新只到 10-21 11:53/, '跨天必须带 MM-DD,否则会被读成当天 11:53');
assert.match(built.text, /本轮核验 09:00/, '同一天的时刻不带日期');
assert.match(built.text, /别按这个数去催快递/);
// 抬头仍要带「异常」关键词,否则钉钉自定义关键词会拒收
assert.match(built.text, /【仓储物流转运异常】/);
});
test('快照同日但没过核验时刻 → 只写时分,不啰嗦日期', () => {
const data = sampleData({
freshness: { snapshotAt: '2026-10-22 08:30:00', ageMinutes: 30, stale: false, coversDeadline: false },
});
const built = job.buildNotifyText(data, { maxDetailRows: 30 });
assert.match(built.text, /最新只到 08:30/);
assert.ok(!built.text.includes('10-22 08:30'), '同一天不重复写日期');
});
test('快照过旧(stale)→ 正文写「偏旧」+ 未刷新时长,异常量标注仅供参考', () => {
const data = sampleData({
freshness: { snapshotAt: '2026-10-22 09:05:00', ageMinutes: 200, stale: true, coversDeadline: true },
});
const built = job.buildNotifyText(data, { maxDetailRows: 30 });
assert.match(built.text, /物流快照偏旧/);
assert.match(built.text, /09:05/);
assert.match(built.text, /已 3\.3 小时未刷新/);
assert.match(built.text, /仅供参考/);
});
test('快照正常 → 正文不出现任何新鲜度告警(别把正常批次也刷成黄色)', () => {
const data = sampleData({
freshness: { snapshotAt: '2026-10-22 09:05:00', ageMinutes: 3, stale: false, coversDeadline: true },
});
const built = job.buildNotifyText(data, { maxDetailRows: 30 });
assert.ok(!built.text.includes('数据未覆盖核验时刻'));
assert.ok(!built.text.includes('物流快照偏旧'));
assert.match(built.text, /异常 144 个包裹/);
});
test('快照字段缺失(老缓存 / 接口未返回)→ 不能崩,也不能瞎报警', () => {
const data = sampleData({ freshness: undefined });
const built = job.buildNotifyText(data, { maxDetailRows: 30 });
assert.match(built.text, /异常 144 个包裹/);
assert.ok(!built.text.includes('⚠️ 数据未覆盖'));
assert.equal(job.buildFreshnessWarning(undefined, {}), '');
assert.equal(job.buildFreshnessWarning({ coversDeadline: null }, {}), '');
});
// ── ⑥ 推送失败要重试,不能「一天只有一次机会」(2026-11-11)──────────────
// 实况:11-11 09:10 那次撞上业务库连不上(状态里 `Failed to connect to 218.93.9.21:1433`),
// 老逻辑用 `HH:mm === sendTime` 严格相等,只给一分钟机会,失败后当天彻底不推、群里一整天没消息。
// 下面把窗口与节流的边界钉死,避免改成「每分钟都重跑」把 240s 的全量核验打成 DDoS。
function beijing(isoText) {
return new Date(isoText); // 测试用 UTC 写法,避免本机时区把断言带偏
}
test('重试调度:到点第一次跑,推成功之后当天不再跑', () => {
const sendTime = '09:10';
const first = job.resolveScheduledPushDecision({
now: beijing('2026-11-11T01:10:00Z'), // 北京 09:10
sendTime,
state: {},
});
assert.equal(first.run, true);
assert.equal(first.reason, 'first_round');
assert.equal(first.attempt, 1);
assert.equal(first.pushDate, '2026-11-11');
const sent = job.resolveScheduledPushDecision({
now: beijing('2026-11-11T01:11:00Z'), // 北京 09:11,09:10 那轮已成功
sendTime,
state: { lastSentDate: '2026-11-11', lastSentAt: '2026-11-11T01:10:03Z' },
});
assert.equal(sent.run, false);
assert.equal(sent.reason, 'already_sent_today');
});
test('重试调度:没到点的分钟一律不跑(不会被「窗口」提前触发)', () => {
const decision = job.resolveScheduledPushDecision({
now: beijing('2026-11-11T01:09:00Z'), // 北京 09:09
sendTime: '09:10',
state: {},
});
assert.equal(decision.run, false);
assert.equal(decision.reason, 'before_time');
});
test('重试调度:失败后按 5 分钟间隔重试,间隔内不重复拉全量核验', () => {
const sendTime = '09:10';
const failedState = { lastAttemptAt: '2026-11-11T01:10:00Z', attemptDate: '2026-11-11', attemptCount: 1 };
const tooSoon = job.resolveScheduledPushDecision({
now: beijing('2026-11-11T01:13:00Z'), // 距上次尝试 3 分钟
sendTime,
state: failedState,
});
assert.equal(tooSoon.run, false);
assert.equal(tooSoon.reason, 'wait_interval');
const retry = job.resolveScheduledPushDecision({
now: beijing('2026-11-11T01:15:00Z'), // 距上次尝试 5 分钟,正好到间隔
sendTime,
state: failedState,
});
assert.equal(retry.run, true);
assert.equal(retry.reason, 'retry');
assert.equal(retry.attempt, 2);
});
test('重试调度:过了「推送时刻 + 30 分钟」窗口就不再补推', () => {
const sendTime = '09:10';
const failedState = { lastAttemptAt: '2026-11-11T01:35:00Z', attemptDate: '2026-11-11', attemptCount: 6 };
const inside = job.resolveScheduledPushDecision({
now: beijing('2026-11-11T01:40:00Z'), // 北京 09:40,窗口最后一分钟
sendTime,
state: failedState,
});
assert.equal(inside.run, true, '窗口边界(含)仍要重试');
const closed = job.resolveScheduledPushDecision({
now: beijing('2026-11-11T01:41:00Z'), // 北京 09:41
sendTime,
state: failedState,
});
assert.equal(closed.run, false);
assert.equal(closed.reason, 'window_closed');
});
test('重试调度:跨天后尝试次数归零,昨天的失败不节流今天的首轮', () => {
const decision = job.resolveScheduledPushDecision({
now: beijing('2026-11-12T01:10:00Z'), // 北京 11-12 09:10
sendTime: '09:10',
state: { lastAttemptAt: '2026-11-11T01:35:00Z', attemptDate: '2026-11-11', attemptCount: 6 },
});
assert.equal(decision.run, true);
assert.equal(decision.reason, 'first_round');
assert.equal(decision.attempt, 1);
});
test('重试调度:重试窗口不跨日(23:50 推送不会被次日 00:10 当成「窗口内」)', () => {
const decision = job.resolveScheduledPushDecision({
now: beijing('2026-11-11T16:10:00Z'), // 北京 11-12 00:10
sendTime: '23:50',
state: {},
});
assert.equal(decision.run, false);
assert.equal(decision.reason, 'before_time');
});
test('重试调度:尝试记录残缺(有次数没时间)时不能卡死,该重试就重试', () => {
const decision = job.resolveScheduledPushDecision({
now: beijing('2026-11-11T01:11:00Z'),
sendTime: '09:10',
state: { attemptDate: '2026-11-11', attemptCount: 2, lastAttemptAt: '' },
});
assert.equal(decision.run, true);
assert.equal(decision.reason, 'retry');
assert.equal(decision.attempt, 3);
});
test('重试调度:sendTime 非法时安静不跑(配置坏了不能把定时任务打崩)', () => {
const decision = job.resolveScheduledPushDecision({
now: beijing('2026-11-11T01:10:00Z'),
sendTime: 'not-a-time',
state: {},
});
assert.equal(decision.run, false);
assert.equal(decision.reason, 'bad_send_time');
});
test('重试参数:默认 30 分钟窗口 / 5 分钟间隔,环境变量可覆盖', () => {
assert.equal(job.DEFAULT_RETRY_WINDOW_MINUTES, 30);
assert.equal(job.DEFAULT_RETRY_INTERVAL_MINUTES, 5);
assert.equal(job.minuteOfDay('09:10'), 550);
assert.equal(job.minuteOfDay('00:00'), 0);
assert.equal(job.minuteOfDay('23:59'), 1439);
assert.equal(job.minuteOfDay('9:10'), null, '必须是零填充的 HH:mm');
assert.equal(job.minuteOfDay(''), null);
});

File diff suppressed because it is too large Load Diff

View File

@ -48,6 +48,7 @@ function sampleData(overrides = {}) {
shopName: '京东旗舰店', shopName: '京东旗舰店',
warehouseName: '简尚-崔桥工厂仓', warehouseName: '简尚-崔桥工厂仓',
centerName: '崔桥工厂仓', centerName: '崔桥工厂仓',
logisticCompany: '武进韵达',
auditTime: '2026-10-27 06:32:11', auditTime: '2026-10-27 06:32:11',
overdueMinutes: 388, overdueMinutes: 388,
}, },
@ -57,6 +58,7 @@ function sampleData(overrides = {}) {
shopName: '天猫店', shopName: '天猫店',
warehouseName: '简尚-崔桥工厂仓', warehouseName: '简尚-崔桥工厂仓',
centerName: '崔桥工厂仓', centerName: '崔桥工厂仓',
logisticCompany: '常州安能新',
auditTime: '2026-10-26 09:05:00', auditTime: '2026-10-26 09:05:00',
overdueMinutes: 2875, overdueMinutes: 2875,
}, },
@ -66,6 +68,8 @@ function sampleData(overrides = {}) {
shopName: '抖音店', shopName: '抖音店',
warehouseName: '简尚-横林二仓', warehouseName: '简尚-横林二仓',
centerName: '横林二仓', centerName: '横林二仓',
// 快递名为空 → 明细里要显示「—」,不能出现 undefined
logisticCompany: '',
auditTime: '', auditTime: '',
overdueMinutes: 120, overdueMinutes: 120,
}, },
@ -134,25 +138,33 @@ test('按仓块只列超时 > 0 的仓,并按单数降序', () => {
assert.doesNotMatch(built.text, /睢宁仓 0 单/); assert.doesNotMatch(built.text, /睢宁仓 0 单/);
}); });
test('明细一行 = 仓|内部单号|线上单号|审核 时间|已等', () => { test('明细一行 = 仓|内部单号|线上单号|快递|审核 时间|已等', () => {
const built = job.buildNotifyText(sampleData(), { maxDetailRows: 30 }); const built = job.buildNotifyText(sampleData(), { maxDetailRows: 30 });
assert.match(built.text, /1\. 简尚-崔桥工厂仓|9855123|261021-301318827670255|审核 06:32|已等 6 小时 28 分/); assert.match(built.text, /1\. 简尚-崔桥工厂仓|9855123|261021-301318827670255|武进韵达|审核 06:32|已等 6 小时 28 分/);
// 无线上单号 → 「—」;无审核时间 → 「未审核」;都没有时不能出现 undefined // 无线上单号 → 「—」;无快递名 → 「—」;无创建时间 → 「无创建时间」;都不能出现 undefined
assert.match(built.text, /3\. 简尚-横林二仓|9855300|—|审核 未审核|已等 2 小时/); assert.match(built.text, /3\. 简尚-横林二仓|9855300|—|—|审核 —|已等 2 小时/);
assert.doesNotMatch(built.text, /undefined|NaN/); assert.doesNotMatch(built.text, /undefined|NaN/);
}); });
test('快递列紧跟线上单号(业务 2026-10-27 要求:群里直接看是哪家快递)', () => {
const built = job.buildNotifyText(sampleData(), { maxDetailRows: 30 });
const line = built.text.split('\n').find((l) => l.startsWith('2. 简尚-崔桥工厂仓'));
assert.ok(line, '明细第 2 行不见了');
const parts = line.replace(/^\d+\.\s*/, '').split('|');
assert.deepEqual(parts, ['简尚-崔桥工厂仓', '9855200', 'SO20261027001', '常州安能新', '审核 10-26 09:05', '已等 1 天 23 小时']);
});
test('历史未发单的审核时间必须带 MM-DD,否则会被读成「今天 16:13」', () => { test('历史未发单的审核时间必须带 MM-DD,否则会被读成「今天 16:13」', () => {
// 13:00 轮窗口上界 07:00,但口径「含历史未发」→ 明细里会出现昨天的单 // 13:00 轮窗口上界 07:00,但口径「含历史未发」→ 明细里会出现昨天的单
const built = job.buildNotifyText(sampleData(), { maxDetailRows: 30 }); const built = job.buildNotifyText(sampleData(), { maxDetailRows: 30 });
assert.match(built.text, /2\. 简尚-崔桥工厂仓|9855200|SO20261027001|审核 10-26 09:05|已等 1 天 23 小时/); assert.match(built.text, /2\. 简尚-崔桥工厂仓|9855200|SO20261027001|常州安能新|审核 10-26 09:05|已等 1 天 23 小时/);
// 同一天的就只给 HH:mm,别啰嗦 // 同一天的就只给 HH:mm,别啰嗦
assert.match(built.text, /审核 06:32/); assert.match(built.text, /审核 06:32/);
assert.doesNotMatch(built.text, /审核 10-27 06:32/); assert.doesNotMatch(built.text, /审核 10-27 06:32/);
// 直接测函数本身的跨天判定 // 直接测函数本身的跨天判定
assert.equal(job.auditWhen('2026-10-27 06:32:11', '2026-10-27'), '06:32'); assert.equal(job.auditWhen('2026-10-27 06:32:11', '2026-10-27'), '06:32');
assert.equal(job.auditWhen('2026-10-26 16:13:00', '2026-10-27'), '10-26 16:13'); assert.equal(job.auditWhen('2026-10-26 16:13:00', '2026-10-27'), '10-26 16:13');
assert.equal(job.auditWhen('', '2026-10-27'), '未审核'); assert.equal(job.auditWhen('', '2026-10-27'), '');
}); });
test('不计考核 / 不考核快递 / 数据未覆盖核验点都要在正文里说明', () => { test('不计考核 / 不考核快递 / 数据未覆盖核验点都要在正文里说明', () => {

View File

@ -4,7 +4,7 @@ import request from './request';
// 超时必须放大到 3 分钟,否则前端会先断开、后端还在跑。 // 超时必须放大到 3 分钟,否则前端会先断开、后端还在跑。
const TIMELINESS_TIMEOUT_MS = 3 * 60 * 1000; const TIMELINESS_TIMEOUT_MS = 3 * 60 * 1000;
// 仓储中心 24 小时发货时效:每个主仓「超时未发」数量 + 超时订单明细 // 仓储中心发货时效:每个主仓「超时未发」数量 + 超时订单明细
// params.round 'NOON' | 'AFTERNOON'(不传按当前时刻自动判定) // params.round 'NOON' | 'AFTERNOON'(不传按当前时刻自动判定)
// params.limit 明细条数上限 // params.limit 明细条数上限
export const getWarehouseShipTimeliness = (params = {}) => request.get( export const getWarehouseShipTimeliness = (params = {}) => request.get(
@ -22,6 +22,18 @@ export const getWarehouseShipTimelinessRounds = () => request.get(
{ timeout: 30000 } { timeout: 30000 }
); );
// 「超时未发」明细导出:不分页、不截断,返回本轮考核口径内的全部行。
// 与 /list 共用后端同一份缓存,所以页面刚刷过时这里是秒回;
// 冷启动(缓存已过期)仍要全量扫视图,超时同样放大到 3 分钟。
export const getWarehouseShipTimelinessExportRows = (params = {}) => request.get(
'/api/warehouse-ship-timeliness/export',
{
params,
timeout: TIMELINESS_TIMEOUT_MS,
headers: { 'Cache-Control': 'no-cache' },
}
);
// ── 两轮核验完成后推文本到钉钉群(2026-10-27 新增)──────────────────────── // ── 两轮核验完成后推文本到钉钉群(2026-10-27 新增)────────────────────────
// 通道 = 群自定义机器人 webhook(不发 .xlsx,只发 text;加签密钥可选) // 通道 = 群自定义机器人 webhook(不发 .xlsx,只发 text;加签密钥可选)
// 读配置:加签密钥只回掩码(webhookSecretConfigured + webhookSecretPreview) // 读配置:加签密钥只回掩码(webhookSecretConfigured + webhookSecretPreview)

View File

@ -37,7 +37,7 @@ export const DEFAULT_SIDEBAR_CONFIG = {
{ key: 'mkh-bom-data', label: 'MKH-BOM资料', icon: 'table', routeKey: 'mkh-bom-data', visible: true, order: 20 }, { key: 'mkh-bom-data', label: 'MKH-BOM资料', icon: 'table', routeKey: 'mkh-bom-data', visible: true, order: 20 },
], ],
}, },
{ key: 'warehouse-ship-timeliness', type: 'item', label: '仓储中心24小时发货时效', icon: 'inbox', routeKey: 'warehouse-ship-timeliness', visible: true, order: 110 }, { key: 'warehouse-ship-timeliness', type: 'item', label: '仓储中心发货时效', icon: 'inbox', routeKey: 'warehouse-ship-timeliness', visible: true, order: 110 },
{ key: 'warehouse-logistics-exception', type: 'item', label: '仓储中心物流转运异常', icon: 'warning', routeKey: 'warehouse-logistics-exception', visible: true, order: 111 }, { key: 'warehouse-logistics-exception', type: 'item', label: '仓储中心物流转运异常', icon: 'warning', routeKey: 'warehouse-logistics-exception', visible: true, order: 111 },
{ {
key: 'large-stock-monitor', type: 'group', label: '大货库存监控', icon: 'appstore', visible: true, order: 200, defaultExpanded: true, key: 'large-stock-monitor', type: 'group', label: '大货库存监控', icon: 'appstore', visible: true, order: 200, defaultExpanded: true,

View File

@ -360,24 +360,17 @@ const MkhBomData = () => {
const load = useCallback(async ({ background = false } = {}) => { const load = useCallback(async ({ background = false } = {}) => {
const requestGeneration = listRequestGateRef.current.begin(); const requestGeneration = listRequestGateRef.current.begin();
let showProgress = false;
let progressGeneration = null;
if (!background) setLoading(true); if (!background) setLoading(true);
if (!background) setError(''); if (!background) setError('');
try { try {
const now = Date.now(); const now = Date.now();
const forceFresh = !lastListRefreshAtRef.current // 🔥 2026-11-17:首屏 / F5 / 每 2 分钟轮询**不再带 fresh=1**。
|| now - lastListRefreshAtRef.current >= AUTO_REFRESH_MS; // 旧逻辑「首屏 || 距上次 ≥ 2 分钟」就发 fresh=1 → 后端清空运营缓存 →
showProgress = forceFresh && !background; // 订单两表必然全表扫(冷查实测首屏 126.9s,而命中缓存只要 4~5 秒)。
if (showProgress) progressGeneration = beginRefreshProgress('正在更新最新业务数据'); // 于是「每次打开、每次刷新、每 2 分钟」都在等两分钟以上。
// 首次打开/F5 和定时轮询才重读云库;筛选、分页只复用刚刷新的内存索引。 // 现在新鲜度由后端后台预热维持(每 20 分钟一轮,见 jobs/mkhBomPrewarmJob),
// 后端仍会合并多用户的并发刷新,不会对业务云库造成重复全量查询。 // 页面走缓存;要强制重读只有一个入口 ——「同步最新数据 / 刷新数据」按钮(handleSync)。
const result = await getMkhBomList({ const result = await getMkhBomList({ ...query, live: 1, _refresh: now });
...query,
live: 1,
...(forceFresh ? { fresh: 1 } : null),
_refresh: now,
});
if (!listRequestGateRef.current.isCurrent(requestGeneration)) return; if (!listRequestGateRef.current.isCurrent(requestGeneration)) return;
if (!result || result.success === false) { if (!result || result.success === false) {
setError(result?.error || '加载 MKH-BOM 资料失败'); setError(result?.error || '加载 MKH-BOM 资料失败');
@ -385,22 +378,21 @@ const MkhBomData = () => {
} }
const snapshot = result?.data || null; const snapshot = result?.data || null;
try { try {
requireMkhFreshContract(snapshot, { requireApplied: forceFresh }); requireMkhFreshContract(snapshot);
} catch (contractError) { } catch (contractError) {
setData({ rows: [], total: 0, page: 1, pageSize: 50, bomReady: false }); setData({ rows: [], total: 0, page: 1, pageSize: 50, bomReady: false });
throw contractError; throw contractError;
} }
setData(snapshot); setData(snapshot);
if (forceFresh) lastListRefreshAtRef.current = Date.now(); lastListRefreshAtRef.current = Date.now();
setError(''); setError('');
} catch (requestError) { } catch (requestError) {
if (!listRequestGateRef.current.isCurrent(requestGeneration)) return; if (!listRequestGateRef.current.isCurrent(requestGeneration)) return;
setError(requestError?.response?.data?.error || requestError?.message || '加载 MKH-BOM 资料失败'); setError(requestError?.response?.data?.error || requestError?.message || '加载 MKH-BOM 资料失败');
} finally { } finally {
if (!background && listRequestGateRef.current.isCurrent(requestGeneration)) setLoading(false); if (!background && listRequestGateRef.current.isCurrent(requestGeneration)) setLoading(false);
if (showProgress) endRefreshProgress(progressGeneration);
} }
}, [beginRefreshProgress, endRefreshProgress, query]); }, [query]);
useEffect(() => { load(); }, [load]); useEffect(() => { load(); }, [load]);

View File

@ -252,8 +252,15 @@ function WarehouseLogisticsException() {
const [activeCenter, setActiveCenter] = useState(''); const [activeCenter, setActiveCenter] = useState('');
// 异常类型筛选:为空 = 全部 // 异常类型筛选:为空 = 全部
const [activeType, setActiveType] = useState(''); const [activeType, setActiveType] = useState('');
// 核验日;null = 交给后端按「现在几点」自动判(未到 9 点自动看昨天那批) // 核验日;默认 null = 交给后端按「现在几点」自动判(未到 9 点自动看昨天那批)
const [verifyDate, setVerifyDate] = useState(null); // 🔥 钉钉消息里的链接带 `?date=YYYY-MM-DD`(见 buildPageLink),页面必须认这个参数 ——
// 否则群里点进来看到的是「今天这批」,跟消息里说的不是同一批,历史消息会误导人。
const [verifyDate, setVerifyDate] = useState(() => {
const raw = String(new URLSearchParams(window.location.search).get('date') || '').trim();
if (!/^\d{4}-\d{2}-\d{2}$/u.test(raw)) return null;
const parsed = dayjs(raw);
return parsed.isValid() ? parsed : null;
});
// 导出中(导出比列表慢,按钮要转圈,避免重复点) // 导出中(导出比列表慢,按钮要转圈,避免重复点)
const [exporting, setExporting] = useState(false); const [exporting, setExporting] = useState(false);
// 每天定点把异常文本推到钉钉群(「异常通知」) // 每天定点把异常文本推到钉钉群(「异常通知」)
@ -564,14 +571,16 @@ function WarehouseLogisticsException() {
/> />
) : null} ) : null}
{freshness && (freshness.coversDeadline === false || freshness.stale) ? ( {freshness && (freshness.emptyWindow || freshness.coversDeadline === false || freshness.stale) ? (
<Alert <Alert
type={freshness.coversDeadline === false ? 'error' : 'warning'} type={freshness.emptyWindow || freshness.coversDeadline === false ? 'error' : 'warning'}
showIcon showIcon
className="wle-alert" className="wle-alert"
message={freshness.coversDeadline === false message={freshness.emptyWindow
? '物流快照未覆盖本轮核验时刻,异常量偏大' ? '本批 0 单:物流镜像表里没有当天的发货记录,这个 0 不可当结论'
: '物流数据可能滞后'} : (freshness.coversDeadline === false
? '物流快照未覆盖本轮核验时刻,异常量偏大'
: '物流数据可能滞后')}
description={freshness.hint} description={freshness.hint}
/> />
) : null} ) : null}
@ -589,7 +598,11 @@ function WarehouseLogisticsException() {
formatter={(v) => (notStarted ? '—' : number(v))} formatter={(v) => (notStarted ? '—' : number(v))}
/> />
<Text type="secondary" className="wle-stat__sub"> <Text type="secondary" className="wle-stat__sub">
共 {notStarted ? '—' : number(summary.packageCount)} 个包裹 {notStarted
? '—'
: (freshness?.emptyWindow
? '数据未同步,见上方红条'
: `共 ${number(summary.packageCount)} 个包裹`)}
</Text> </Text>
</Card> </Card>
<Card bordered={false} className="wle-stat"> <Card bordered={false} className="wle-stat">

View File

@ -1,17 +1,19 @@
import React, { useCallback, useEffect, useMemo, useState } from 'react'; import React, { useCallback, useEffect, useMemo, useState } from 'react';
import { import {
Alert, Button, Card, Collapse, Empty, Input, InputNumber, Modal, Space, Spin, Statistic, Alert, Button, Card, Collapse, Dropdown, Empty, Input, InputNumber, Modal, Space, Spin,
Switch, Table, Tag, TimePicker, Tooltip, Typography, message, Statistic, Switch, Table, Tag, TimePicker, Tooltip, Typography, message,
} from 'antd'; } from 'antd';
import { BellOutlined, ReloadOutlined } from '@ant-design/icons'; import { BellOutlined, DownloadOutlined, ReloadOutlined } from '@ant-design/icons';
import dayjs from 'dayjs'; import dayjs from 'dayjs';
import { SycmPage } from '../../components/Common'; import { SycmPage } from '../../components/Common';
import { import {
getShipTimelinessNotifySettings, getShipTimelinessNotifySettings,
getWarehouseShipTimeliness, getWarehouseShipTimeliness,
getWarehouseShipTimelinessExportRows,
runShipTimelinessNotify, runShipTimelinessNotify,
saveShipTimelinessNotifySettings, saveShipTimelinessNotifySettings,
} from '../../api/warehouseShipTimeliness'; } from '../../api/warehouseShipTimeliness';
import { exportTableFile } from '../../utils/tableExport';
import './style.css'; import './style.css';
const { Title, Text } = Typography; const { Title, Text } = Typography;
@ -81,7 +83,7 @@ const NOTIFY_HELP_ITEMS = [
业务口径:<b>13:00 核验 7 点前审核的超时单</b>、<b>18:00 核验 16 点前审核的单</b>, 业务口径:<b>13:00 核验 7 点前审核的超时单</b>、<b>18:00 核验 16 点前审核的单</b>,
各自<b>核验完成后</b>推一次,所以是两个独立时刻,互不影响。 各自<b>核验完成后</b>推一次,所以是两个独立时刻,互不影响。
<br /> <br />
默认给到 <b>13:05 / 18:05</b>(核验点 + 5 分钟):聚水潭状态镜像要晚几分钟才覆盖到核验时刻, 默认给到 <b>13:05 / 18:05</b>(核验点 + 5 分钟):订单表的 updateTime 要晚几分钟才覆盖到核验时刻,
整点推容易报「数据没覆盖核验点、超时数偏大」。想改成整点也可以,消息里会带这句提醒。 整点推容易报「数据没覆盖核验点、超时数偏大」。想改成整点也可以,消息里会带这句提醒。
<br /> <br />
同一轮次同一天只推一次(服务重启不会重复轰炸);要重发点「立即推送」。 同一轮次同一天只推一次(服务重启不会重复轰炸);要重发点「立即推送」。
@ -163,19 +165,46 @@ const HELD_COLUMNS = [
}, },
}, },
{ {
title: '审核时间', title: (
<Tooltip title="聚水潭「审核时间」= 状态表 last_oa_confirm_time 与订单表 modified 的较晚者(状态表会滞后,9978643 旧值比真实审核早一天)。两者都没有才回退订单创建时间,标 *">
<span>审核时间</span>
</Tooltip>
),
dataIndex: 'auditTime', dataIndex: 'auditTime',
width: 152, width: 152,
ellipsis: true, ellipsis: true,
render: (v) => (v || <span className="wst-detail__fallback">未审核</span>), render: (v, row) => {
if (!v) return <span className="wst-detail__fallback">无审核时间</span>;
return row?.benchmarkSource === 'created' ? `${v} *` : v;
},
}, },
{ title: '下单时间', dataIndex: 'createdAt', width: 152, ellipsis: true, render: (v) => v || '—' },
{ title: '付款时间', dataIndex: 'payTime', width: 152, ellipsis: true, render: (v) => v || '—' }, { title: '付款时间', dataIndex: 'payTime', width: 152, ellipsis: true, render: (v) => v || '—' },
{ title: '已挂起', dataIndex: 'heldDays', width: 88, render: (v) => (v > 0 ? `${v} 天` : '—') }, { title: '已挂起', dataIndex: 'heldDays', width: 88, render: (v) => (v > 0 ? `${v} 天` : '—') },
]; ];
const DETAIL_COLUMNS = [ const DETAIL_COLUMNS = [
// 内部单号 = 聚水潭 o_id(系统内部编号,仓管在系统里按它查单) // 内部单号 = 聚水潭 o_id(系统内部编号,仓管在系统里按它查单)
{ title: '内部单号', dataIndex: 'oId', width: 110 }, {
title: '内部单号',
dataIndex: 'oId',
width: 158,
// 🔥 来自停更订单表的单必须打标(2026-10-28):
// 该表停更之后发出的单,send_date 仍是空 → 被判「未发」,实际很可能已经发了。
// 18:00 轮实测 546 单里 540 单是这种,不标出来业务会以为判定写错。
render: (v, row) => (
<span className="wst-detail__oid">
{v || '—'}
{row?.sourceStale ? (
<Tooltip
title={`这单来自 ${row?.srcLabel || '订单表'},该表已停止同步:停更之后发出的单在这里仍是「未发货」,很可能已经发了。请先在聚水潭核对。`}
>
<Tag bordered={false} color="error" className="wst-detail__stale">未同步</Tag>
</Tooltip>
) : null}
</span>
),
},
// 线上订单号 = 平台 so_id(京东/抖音/天猫等平台单号,客服按它对接客户) // 线上订单号 = 平台 so_id(京东/抖音/天猫等平台单号,客服按它对接客户)
{ {
title: '线上订单号', title: '线上订单号',
@ -201,7 +230,7 @@ const DETAIL_COLUMNS = [
{ {
// 发货时间 = 聚水潭回传的发货时间(业务 2026-10-20:明细里不要创建时间,要发货时间) // 发货时间 = 聚水潭回传的发货时间(业务 2026-10-20:明细里不要创建时间,要发货时间)
title: ( title: (
<Tooltip title="聚水潭回传的发货时间(send_time)。为空但有运单号的,说明仓库已打单、还没揽收/回传发货时间,会显示成「已打单」"> <Tooltip title="订单表 jst_Orders.send_date(聚水潭回传的发货时间)。为空但有运单号的,说明仓库已打单、还没揽收/回传发货时间,会显示成「已打单」">
<span>发货时间</span> <span>发货时间</span>
</Tooltip> </Tooltip>
), ),
@ -222,47 +251,111 @@ const DETAIL_COLUMNS = [
}, },
}, },
{ {
// 审核时间 = **考核基准**,取聚水潭「审核时间」列(最后一次审核,重审会刷新) // 审核时间 = 本页的**考核起算点**(业务 2026-10-28 下午三次定版)
// = max(状态表 last_oa_confirm_time, 订单表 modified),都没有才回退创建时间并打 `*`
title: ( title: (
<Tooltip title="= 聚水潭订单列表「审核时间」那一列(最后一次审核,重新审核会刷新)。今天 7:00 前审核的 13:00 核验;截止 16:00 前审核的(含今天之前未发的历史单)18:00 核验,已等时长也从它算"> <Tooltip title="聚水潭「审核时间」= 状态表 last_oa_confirm_time 与订单表 modified 的较晚者。状态表会滞后(9978643 状态表是 10-27 17:08,真实审核 10-28 14:52),所以取较晚的那个。今天 7:00 前审核的 13:00 核验;截止 16:00 前审核的(含历史未发单)18:00 核验。带 * 表示两者都没有,回退订单创建时间">
<span>审核时间</span> <span>审核时间</span>
</Tooltip> </Tooltip>
), ),
dataIndex: 'auditTime', dataIndex: 'auditTime',
width: 152, width: 152,
ellipsis: true, ellipsis: true,
render: (v, row) => (v render: (v, row) => {
? v if (!v) return <span className="wst-detail__fallback">—</span>;
: ( if (row?.benchmarkSource === 'created') {
<Tooltip title="没取到审核时间,已回退创建/付款时间参与分轮与计时"> return (
<span className="wst-detail__fallback">{row?.benchmarkTime || '—'} *</span> <Tooltip title="状态表审核时间和订单表 modified 都取不到,已回退订单创建时间参与分轮与计时(`*` 为标记)">
</Tooltip> <span>{v} *</span>
)), </Tooltip>
);
}
return v;
},
},
// 下单时间 = 客户在平台下单那一刻(只做参考对账,不参与计时)
{
title: (
<Tooltip title="聚水潭订单创建时间(jst_Orders.created),即客户下单时刻。只做参考,不参与分轮与计时">
<span>下单时间</span>
</Tooltip>
),
dataIndex: 'createdAt',
width: 152,
ellipsis: true,
render: (v) => v || '—',
}, },
// 付款时间 = 客户付款那一刻(并列展示,方便对账) // 付款时间 = 客户付款那一刻(并列展示,方便对账)
{ title: '付款时间', dataIndex: 'payTime', width: 152, ellipsis: true, render: (v) => v || '—' }, { title: '付款时间', dataIndex: 'payTime', width: 152, ellipsis: true, render: (v) => v || '—' },
{ {
// 发货状态:聚水潭实时状态(发货中 = 已审核未发货,即考核对象) // 发货状态:**优先显示聚水潭终态**(状态镜像表),订单表状态只作对照
// 🔥 2026-10-29:订单两表会各自停更,停更期间聚水潭里已经「已取消 / 已发货」的单,
// 订单表里仍是「发货中」——业务看到的「作废的也在考核里」就是这么来的。
// 状态镜像表比订单表新鲜,`order_status_name` 才是聚水潭的真状态。
title: ( title: (
<Tooltip title="聚水潭订单实时状态。发货中 = 已审核、仓库还没发货"> <Tooltip title="优先显示聚水潭订单终态(状态镜像表,订单表停更时只有它靠得住)。⚠ = 与订单表 jst_Orders.status 不一致">
<span>发货状态</span> <span>发货状态</span>
</Tooltip> </Tooltip>
), ),
dataIndex: 'state', dataIndex: 'stateOrderStatus',
width: 104, width: 128,
render: (v) => ( render: (v, row) => {
<Tag bordered={false} color={v === '发货中' ? 'orange' : 'default'}>{v || '—'}</Tag> const lake = v || '';
), const ord = row?.state || '';
const diff = Boolean(lake && ord && lake !== ord);
const text = lake || ord || '—';
const color = text === '已取消' ? 'red' : (text === '发货中' ? 'orange' : 'default');
return (
<Tooltip title={`聚水潭:${lake || '—'}|订单表:${ord || '—'}${diff ? '(不一致,订单表没同步到这个状态)' : ''}`}>
<Tag bordered={false} color={color}>{text}{diff ? ' ⚠' : ''}</Tag>
</Tooltip>
);
},
}, },
{ {
title: '物流状态', // 物流状态:优先用状态表的真实物流节点(未揽收 / 已揽收 / 运输中 / 已签收…),
dataIndex: 'logisticStatus', // 订单表没有物流轨迹,只能靠「有没有运单号」猜「已打单 · 未揽收」
width: 100, title: (
render: (v) => (v ? <Tag bordered={false}>{v}</Tag> : '—'), <Tooltip title="聚水潭物流节点(状态镜像表)。已揽收及之后 = 货已经被快递拿走">
<span>物流状态</span>
</Tooltip>
),
dataIndex: 'stateLogisticStatus',
width: 108,
render: (v, row) => {
const text = v || row?.logisticStatus || '';
if (!text) return '—';
const shipped = ['已揽收', '运输中', '派送中', '已签收', '拒收'].includes(v);
return <Tag bordered={false} color={shipped ? 'green' : 'default'}>{text}</Tag>;
},
},
{
// 销售出库单状态(2026-10-29 新增)
// 🔥 业务点名「这些订单都是作废订单」后挖出来的:聚水潭的作废**落在出库单上**
// (`status='Delete'`),订单表的 labels 判据在那批单上 0 命中。
// 这一列让业务能直接对照聚水潭「销售出库单」页面,不用再问「系统里为什么没有」。
title: (
<Tooltip title="聚水潭「销售出库单」的单据状态。已作废=单据被删(不考核);待出库=已生成单据但没出库;空白=还没建出库单(正常,近八成未发单本来就没有)">
<span>销售出库单</span>
</Tooltip>
),
dataIndex: 'ioStatus',
width: 112,
render: (v) => {
const map = {
Delete: ['已作废', 'red'],
WaitConfirm: ['待出库', 'blue'],
Confirmed: ['已出库', 'green'],
OuterConfirming: ['外部确认中', 'default'],
};
const hit = map[v];
if (!hit) return '—';
return <Tag bordered={false} color={hit[1]}>{hit[0]}</Tag>;
},
}, },
{ {
title: ( title: (
<Tooltip title="从审核时间到本轮核验时刻(13:00 / 18:00)等了多久"> <Tooltip title="从审核时间(仓库接到单的时刻)到本轮核验时刻(13:00 / 18:00)等了多久">
<span>已等时长</span> <span>已等时长</span>
</Tooltip> </Tooltip>
), ),
@ -273,17 +366,95 @@ const DETAIL_COLUMNS = [
]; ];
/** /**
* 仓储中心 24 小时发货时效(独立页面) * 导出列(「超时未发」明细)。
*
* ⚠️ 必须**单独一份**,不能直接复用 DETAIL_COLUMNS:
* ① 那里的 title 是 JSX(带 Tooltip),导出时会变成 "[object Object]" 当表头;
* ② 页面上没有「快递公司 / 运单号」两列,而业务追单恰恰要这两列
* (有运单号 = 已打单未揽收,能一眼看出卡在哪一步)。
* 标题一律纯字符串,格式化统一走 exportValue(null 值别导出裸空/裸 0)。
*/
const EXPORT_COLUMNS = [
{ title: '内部单号', dataIndex: 'oId' },
{ title: '线上订单号', dataIndex: 'soId' },
{ title: '店铺', dataIndex: 'shopName' },
{ title: '仓储中心', dataIndex: 'centerName' },
{ title: '发货仓', dataIndex: 'warehouseName' },
{ title: '快递公司', dataIndex: 'logisticCompany', exportValue: (v) => v || '未指定' },
{ title: '运单号', dataIndex: 'logisticId', exportValue: (v) => v || '未打单' },
{ title: '物流状态', dataIndex: 'stateLogisticStatus', exportValue: (v, row) => v || row?.logisticStatus || '' },
{ title: '发货状态', dataIndex: 'state' },
// 聚水潭终态与订单表状态分开导出:两者不一致的单,就是「订单表没同步」的证据
{ title: '聚水潭状态', dataIndex: 'stateOrderStatus', exportValue: (v) => v || '—' },
// 销售出库单状态:聚水潭的作废落在这一层(Delete=单据已作废),
// 业务对账时要拿这一列跟聚水潭「销售出库单」页面对
{
title: '销售出库单',
dataIndex: 'ioStatus',
exportValue: (v) => ({
Delete: '已作废',
WaitConfirm: '待出库',
Confirmed: '已出库',
OuterConfirming: '外部确认中',
}[v] || '未建单'),
},
{ title: '状态表抓取时间', dataIndex: 'stateQueryTime', exportValue: (v) => v || '—' },
// 导出也要带上「这单的来源表 + 该表是否停更」,否则 Excel 脱离页面就没有上下文,
// 拿着 540 单「未发」去追仓库,实际人家早就发了。
{ title: '数据源', dataIndex: 'srcLabel', exportValue: (v) => v || '—' },
{
title: '数据源是否停更',
dataIndex: 'sourceStale',
exportValue: (v) => (v ? '是(该单可能已发)' : '否'),
},
{ title: '发货时间', dataIndex: 'sendTime', exportValue: (v) => v || '未发货' },
{
title: '审核时间',
dataIndex: 'auditTime',
// 起算点 = 审核时间;没取到时回退订单创建时间,导出用 `*` 标出来,否则对账对不上
exportValue: (v, row) => {
const t = v || row?.benchmarkTime || '';
if (!t) return '无审核时间';
return row?.benchmarkSource === 'created' ? `${t} *` : t;
},
},
{ title: '下单时间', dataIndex: 'createdAt', exportValue: (v) => v || '—' },
{ title: '付款时间', dataIndex: 'payTime' },
// 分钟数给一列原始值,业务在 Excel 里能直接排序/筛选;人读的那列再格式化
{ title: '已等(分钟)', dataIndex: 'overdueMinutes' },
{ title: '已等时长', dataIndex: 'overdueMinutes', exportValue: (v) => formatOverdue(v) },
];
// key = 导出格式(tableExport 只支持这两种)
const EXPORT_MENU_ITEMS = [
{ key: 'xlsx', label: '导出 Excel(.xlsx)' },
{ key: 'csv', label: '导出 CSV(.csv)' },
];
// 文件名里不能出现 : \ / * ? " < > |,轮次用「13点轮」这种写法避开冒号
const roundFileText = (roundInfo) => (
Number.isFinite(Number(roundInfo?.verifyHour))
? `${String(Number(roundInfo.verifyHour)).padStart(2, '0')}点轮`
: '本轮'
);
/**
* 仓储中心发货时效(独立页面)
* ──────────────────────────────────────────────────────────────── * ────────────────────────────────────────────────────────────────
* 业务口径(yanhui 2026-10-20): * 业务口径(yanhui 2026-10-20 定轮次;2026-10-28 定起算点):
* · 11 个主仓,子仓并入主仓一起算; * · 11 个主仓,子仓并入主仓一起算;
* · 数据源 = 订单表 jst_Orders + jst_qmcust_orderlist(两张表店铺互斥,都要读);
* · 今天 07:00 前**审核**的订单 13:00 核验,截止今天 16:00 前审核的单 18:00 核验 * · 今天 07:00 前**审核**的订单 13:00 核验,截止今天 16:00 前审核的单 18:00 核验
* (含 7 点前未发出的、含今天之前审核至今未发的历史单;山东两仓 15:00、河南洛宁 13:00); * (含 7 点前审核未发出的、含今天之前审核至今未发的历史单;山东两仓 15:00、河南洛宁 13:00);
* 今天之前审核仍未发的(历史未发)两个轮次都算; * 今天之前仍未发的(历史未发)两个轮次都算;
* **到核验时刻未发即超时**,没有「满 24 小时」门槛(业务纠偏点); * **到核验时刻未发即超时**,没有「满 24 小时」门槛(业务纠偏点);
* 轮次归属和「已等时长」都按**审核时间**算(聚水潭「审核时间」列,最后一次审核); * 轮次归属和「已等时长」都按**审核时间**算 ——
* 业务 2026-10-28 下午三次定版:审核时间 = max(状态表 last_oa_confirm_time, 订单表 modified)。
* 只取状态表会漏 —— 状态表会滞后(9978643 状态表写的是 10-27 17:08,聚水潭真实审核 10-28 14:52,
* 整整早一天),导致「今天下午才审核的单」被算进 13:00 轮,冤枉仓库;
* 两者都没有才回退订单创建时间,页面上带 `*` 标记;
* · **13:00 之前不核验**,直接显示「未到核验时间」,不拿昨天的结果冒充今天; * · **13:00 之前不核验**,直接显示「未到核验时间」,不拿昨天的结果冒充今天;
* · 已出库 / 待出库以**聚水潭发货时间**为准(有 send_time = 已发); * · 已出库 / 待出库以订单表 **send_date** 为准(SQL 直接 `send_date IS NULL` 才进候选);
* · 只显示超时未出库(发完的仓显示「—」),点仓库可筛右侧明细。 * · 只显示超时未出库(发完的仓显示「—」),点仓库可筛右侧明细。
* *
* 数据来自 /api/warehouse-ship-timeliness/list(service 层见 * 数据来自 /api/warehouse-ship-timeliness/list(service 层见
@ -297,6 +468,8 @@ function WarehouseShipTimeliness() {
const [activeCenter, setActiveCenter] = useState(''); const [activeCenter, setActiveCenter] = useState('');
// 「业务挂起(疑问单)」明细弹窗 // 「业务挂起(疑问单)」明细弹窗
const [heldOpen, setHeldOpen] = useState(false); const [heldOpen, setHeldOpen] = useState(false);
// 「导出明细」按钮 loading(全量导出可能要走一次冷启动查询,必须给反馈)
const [exporting, setExporting] = useState(false);
// ── 钉钉通知(两轮核验完成后各推一次)────────────────────────────────── // ── 钉钉通知(两轮核验完成后各推一次)──────────────────────────────────
const [notifyOpen, setNotifyOpen] = useState(false); const [notifyOpen, setNotifyOpen] = useState(false);
@ -343,6 +516,11 @@ function WarehouseShipTimeliness() {
const summary = data?.summary || {}; const summary = data?.summary || {};
const round = data?.round || null; const round = data?.round || null;
const freshness = data?.freshness || null; const freshness = data?.freshness || null;
// 🔥 超时单里「所在订单表已停更」的数量(2026-10-28 定型):
// 停更⟹停更之后发出的单 send_date 仍为空⟹被判「未发」,但实际很可能已发。
// 18:00 轮实测 546 单里 540 单属于这种,必须显著提示,否则业务会以为判定写错。
const staleUnshipped = Number(summary.sourceStaleUnshipped || 0);
const staleSources = Array.isArray(data?.dataSources) ? data.dataSources.filter((s) => s && s.stale) : [];
// 13:00 之前后端返回 round=null + notStarted=true:此时**不展示任何超时数字** // 13:00 之前后端返回 round=null + notStarted=true:此时**不展示任何超时数字**
const notStarted = Boolean(data?.notStarted); const notStarted = Boolean(data?.notStarted);
const hasRound = Boolean(round); const hasRound = Boolean(round);
@ -363,10 +541,84 @@ function WarehouseShipTimeliness() {
return hit ? hit.name : activeCenter; return hit ? hit.name : activeCenter;
}, [activeCenter, centers]); }, [activeCenter, centers]);
// 选中仓时,该仓的超时单数以 centers 里的统计为准(明细可能被截断)
const activeCenterRow = useMemo(
() => (activeCenter ? centers.find((c) => c.key === activeCenter) || null : null),
[activeCenter, centers]
);
const detailOrders = useMemo(() => ( const detailOrders = useMemo(() => (
activeCenter ? orders.filter((o) => o.centerKey === activeCenter) : orders activeCenter ? orders.filter((o) => o.centerKey === activeCenter) : orders
), [activeCenter, orders]); ), [activeCenter, orders]);
// 明细真实总数(后端截断前):页面的「共 N 单」必须用它,
// 用 detailOrders.length 会把「已截断只显示前 1000 条」写成「一共就这么点」
const detailTotal = Number.isFinite(Number(data?.detailTotal))
? Number(data.detailTotal)
: detailOrders.length;
const heldTotal = Number.isFinite(Number(data?.heldTotal))
? Number(data.heldTotal)
: heldOrders.length;
// 不考核快递清单跟随后端(加/减快递只改服务层一处,别在前端写死)
const excludedCarrierText = (
Array.isArray(data?.excludedCarriers) && data.excludedCarriers.length
? data.excludedCarriers
: ['自提', '中铁', '壹米滴答', '武进安能']
).join(' / ');
// ── 导出「超时未发」明细 ─────────────────────────────────────────────────
/**
* 导出口径必须和页面明细一致,所以:
* · 数据源走 `/export`(后端同一个 getShipTimeliness,只是不按 limit 截断);
* · 选中仓时在前端按 centerKey 过滤,和后端算超时用的主仓归属是同一套。
* 🔥 不能直接导出页面上的 `orders` —— 它被 limit=1000 截断过,导出会少行,
* 而业务拿它去考核,少行比报错更危险。
*/
const handleExport = async (format) => {
setExporting(true);
try {
const result = await getWarehouseShipTimelinessExportRows({
round: round?.key || undefined,
});
if (!result || result.success === false) {
message.error(result?.error || '导出失败');
return;
}
const payload = result.data || {};
if (payload.notStarted) {
message.warning('本轮还没到核验时间,没有可导出的数据');
return;
}
const allRows = Array.isArray(payload.rows) ? payload.rows : [];
if (!allRows.length) {
message.warning('本轮没有超时未发订单,无需导出');
return;
}
const rows = activeCenter
? allRows.filter((row) => row.centerKey === activeCenter)
: allRows;
if (!rows.length) {
message.warning(`${activeCenterName || '该仓'}本轮没有超时未发订单`);
return;
}
const fileName = [
'仓储中心发货时效_超时未发',
activeCenter ? activeCenterName : '全部仓库',
roundFileText(payload.round || round),
payload.date || data?.date || dayjs().format('YYYY-MM-DD'),
].filter(Boolean).join('_');
await exportTableFile(format, fileName, EXPORT_COLUMNS, rows, '超时未发');
message.success(`已导出 ${rows.length} 单(${String(format).toUpperCase()})`);
} catch (exportError) {
message.error(exportError?.response?.data?.error || exportError?.message || '导出失败');
} finally {
setExporting(false);
}
};
// ── 钉钉通知:配置读写 / 预览 / 立即推送 ───────────────────────────────── // ── 钉钉通知:配置读写 / 预览 / 立即推送 ─────────────────────────────────
// 后端只回加签密钥掩码,所以表单里的 webhookSecret 永远是空的 —— 留空 = 沿用已存的 // 后端只回加签密钥掩码,所以表单里的 webhookSecret 永远是空的 —— 留空 = 沿用已存的
@ -496,9 +748,11 @@ function WarehouseShipTimeliness() {
return ( return (
<SycmPage className="wst-page"> <SycmPage className="wst-page">
<header className="wst-header"> <header className="wst-header">
<Title level={3}>仓储中心 24 小时发货时效</Title> <Title level={3}>仓储中心发货时效(到点未发即超时)</Title>
<Text type="secondary"> <Text type="secondary">
按聚水潭订单实时状态核验 11 个主仓是否在承诺时效内完成发货,只列超时未发货的单量。 按聚水潭订单表实时状态核验 11 个主仓是否在承诺时效内完成发货,只列超时未发货的单量。
{/* 2026-10-28 业务定:名字里不再出现「24 小时」—— 规则本身没有 24h 门槛,
原名会让 10-27 16:00 创建(只等了 21 小时)的单看着像「没到时限也被判超时」。*/}
</Text> </Text>
<Text type="secondary" className="wst-note"> <Text type="secondary" className="wst-note">
每天 <b>13:00</b> 核验「<b>今天 07:00 前审核</b>」、<b>18:00</b> 核验「<b>截止 16:00 前审核</b>」、 每天 <b>13:00</b> 核验「<b>今天 07:00 前审核</b>」、<b>18:00</b> 核验「<b>截止 16:00 前审核</b>」、
@ -508,15 +762,17 @@ function WarehouseShipTimeliness() {
<b>到点还没发就算超时 —— 不设「满 24 小时」门槛</b>(早上 7 点前那份单,13:00 还没走就是超时)。 <b>到点还没发就算超时 —— 不设「满 24 小时」门槛</b>(早上 7 点前那份单,13:00 还没走就是超时)。
<b>仓级例外</b>:18:00 轮里 <b>山东青岗集仓 / 山东品牌仓</b> 只看 <b>15:00 前审核</b>的单、 <b>仓级例外</b>:18:00 轮里 <b>山东青岗集仓 / 山东品牌仓</b> 只看 <b>15:00 前审核</b>的单、
<b>河南洛宁仓</b> 只看 <b>13:00 前审核</b>的单(核验时刻仍是 18:00)。 <b>河南洛宁仓</b> 只看 <b>13:00 前审核</b>的单(核验时刻仍是 18:00)。
<b>轮次与「已等时长」都按审核时间算</b>(= 聚水潭「审核时间」列,最后一次审核); <b>轮次与「已等时长」都按审核时间算</b>(= 状态表 last_oa_confirm_time 与订单表 modified 的较晚者:
明细并列「审核时间 / 发货时间」,方便直接和聚水潭对账。 审核才是仓库接到单的时刻,按下单时间算会把客服审核积压算到仓库头上;
<b>已发 / 未发以聚水潭发货时间为准</b>:有发货时间就是已发,不再用订单表的发货字段反推 状态表的审核时间会滞后,所以要和订单 modified 取较晚的那个);
—— 该字段经常不回写,会把早就发货的单误判成超时。 明细并列「审核时间 / 下单时间 / 发货时间」,方便直接和聚水潭对账。
<b>已发 / 未发以订单表 send_date 为准</b>(有值即已发,SQL 侧直接过滤不进候选);
订单表 send_date 没回写、但状态表 send_time 有值的,也按已发剔除(不漏冤仓库)。
<b>已打单但还没揽收的</b>(聚水潭已生成运单号、发货时间还空着)会标成「已打单 · 未揽收」, <b>已打单但还没揽收的</b>(聚水潭已生成运单号、发货时间还空着)会标成「已打单 · 未揽收」,
鼠标悬停能看到运单号 —— 这类单还留在列表里,等聚水潭回传发货时间才消失。 鼠标悬停能看到运单号 —— 这类单还留在列表里,等聚水潭回传发货时间才消失。
<b>自提 / 中铁 / 壹米滴答 三个快递不考核</b>(客户自提或专线大件,仓库控制不了运输), <b>{excludedCarrierText} 不考核</b>(客户自提、专线大件或加盟快运网点,揽收与在途仓库控制不了),
已按物流公司自动剔除。 已按物流公司自动剔除。
<b>「已支付待审核」和「异常」的单不计考核</b>(仓库还没接到或订单本身有问题),单独归入「不计考核」并给出明细; <b>「待审核」和「异常」的单不计考核</b>(仓库还没接到或订单本身有问题),单独归入「不计考核」并给出明细;
<b>作废单(已取消,含发货前售后)不考核也不展示</b> —— 客户付款后取消的单仓库本就不该发。 <b>作废单(已取消,含发货前售后)不考核也不展示</b> —— 客户付款后取消的单仓库本就不该发。
</Text> </Text>
</header> </header>
@ -568,14 +824,44 @@ function WarehouseShipTimeliness() {
/> />
) : null} ) : null}
{freshness && (freshness.stale || freshness.coversDeadline === false) ? ( {(freshness && (freshness.stale || freshness.coversDeadline === false))
|| staleUnshipped > 0
|| staleSources.length > 0 ? (
<Alert <Alert
// 快照没覆盖到核验时刻 → 数字必然偏大,用红色;只是滞后用黄色 // 快照没覆盖到核验时刻 / 有单来自停更的表 → 数字必然偏大,用红色;只是滞后用黄色
type={freshness.coversDeadline === false ? 'error' : 'warning'} type={staleUnshipped > 0 || freshness?.coversDeadline === false ? 'error' : 'warning'}
showIcon showIcon
className="wst-alert" className="wst-alert"
message={freshness.coversDeadline === false ? '数据未覆盖本轮核验时刻,超时单量偏大' : '发货数据可能滞后'} message={
description={freshness.hint} staleUnshipped > 0
? `${number(staleUnshipped)} 单所在订单表已停止同步,这些单很可能已经发货`
: (freshness?.voidJudgeReliable === false
// 🔥 2026-10-29:出库单/状态表停更 ⟹ 作废判据失效。
// 业务当天报「洛宁仓 16 单都是作废单」,但我们三个来源全停在作废动作之前,
// 判据再准也判不出来 —— 必须明说,别让业务以为是系统认定「没作废」。
? '出库单数据源已停止同步,作废单可能判不出来'
: (staleSources.length > 0
// 状态镜像表也算数据源:它停了,判「已取消 / 已发货」的依据就过期了
? '数据源已停止同步(订单表 / 状态镜像表)'
: (freshness?.coversDeadline === false
? '数据未覆盖本轮核验时刻,超时单量偏大'
: '发货数据可能滞后')))
}
description={(
<>
{freshness?.hint}
{staleSources.length ? (
<div className="wst-alert__sources">
{staleSources.map((s) => (
<span key={s.key} className="wst-alert__source">
{s.label}:最后同步 {String(s.lastUpdate || '').slice(11, 19) || '—'}
(已 {Math.round((s.lagMinutes || 0) / 6) / 10} 小时)
</span>
))}
</div>
) : null}
</>
)}
/> />
) : null} ) : null}
@ -592,6 +878,13 @@ function WarehouseShipTimeliness() {
formatter={(v) => (notStarted ? '—' : number(v))} formatter={(v) => (notStarted ? '—' : number(v))}
valueStyle={{ color: (summary.overdueUnshipped || 0) > 0 ? '#cf1322' : undefined }} valueStyle={{ color: (summary.overdueUnshipped || 0) > 0 ? '#cf1322' : undefined }}
/> />
{staleUnshipped > 0 ? (
<Tooltip title="这批单来自已停止同步的订单表:停更之后发出的单,在库里 send_date 还是空,会被判成「未发」。先在聚水潭核对,别直接拿去追仓库。">
<div className="wst-stat__warn">
其中 {number(staleUnshipped)} 单数据未同步
</div>
</Tooltip>
) : null}
</Card> </Card>
<Card <Card
bordered={false} bordered={false}
@ -600,7 +893,7 @@ function WarehouseShipTimeliness() {
> >
<Statistic <Statistic
title={( title={(
<Tooltip title="已支付待审核(还没审单,仓库没接到)和订单异常的单。这类单不进仓库考核,点开看明细。"> <Tooltip title="待审核(订单状态 WaitConfirm,还没审单,仓库没接到)和订单异常(Question)的单。这类单不进仓库考核,点开看明细。">
<span>不计考核 <span className="wst-stat__more">明细</span></span> <span>不计考核 <span className="wst-stat__more">明细</span></span>
</Tooltip> </Tooltip>
)} )}
@ -692,16 +985,33 @@ function WarehouseShipTimeliness() {
<span> <span>
超时未发货订单 超时未发货订单
<span className="wst-detail__scope"> <span className="wst-detail__scope">
{activeCenterName || '全部仓库'} · {detailOrders.length} 单 {activeCenterName || '全部仓库'} · {activeCenter
{data?.truncated && detailOrders.length >= (data?.detailLimit || 0) ? (activeCenterRow?.overdueUnshipped ?? detailOrders.length)
? `(已截断,仅显示前 ${data.detailLimit} 条)` : detailTotal} 单
{!activeCenter && data?.truncated
? `(页面只显示前 ${data.detailLimit} 条,导出可拿全部 ${detailTotal} 条)`
: ''} : ''}
</span> </span>
</span> </span>
)} )}
extra={activeCenter ? ( extra={(
<button type="button" className="wst-detail__clear" onClick={() => setActiveCenter('')}>查看全部</button> <Space size={8}>
) : null} {activeCenter ? (
<button type="button" className="wst-detail__clear" onClick={() => setActiveCenter('')}>
查看全部
</button>
) : null}
<Dropdown
trigger={['click']}
disabled={exporting || notStarted}
menu={{ items: EXPORT_MENU_ITEMS, onClick: ({ key }) => handleExport(key) }}
>
<Button size="small" icon={<DownloadOutlined />} loading={exporting}>
导出明细
</Button>
</Dropdown>
</Space>
)}
> >
<Spin spinning={loading && !data}> <Spin spinning={loading && !data}>
{notStarted ? ( {notStarted ? (
@ -726,7 +1036,7 @@ function WarehouseShipTimeliness() {
</div> </div>
<Modal <Modal
title={`不计考核(待审核 / 异常)· ${heldOrders.length} 单`} title={`不计考核(待审核 / 异常)· ${heldTotal} 单`}
open={heldOpen} open={heldOpen}
onCancel={() => setHeldOpen(false)} onCancel={() => setHeldOpen(false)}
footer={null} footer={null}
@ -737,7 +1047,7 @@ function WarehouseShipTimeliness() {
type="info" type="info"
showIcon showIcon
className="wst-alert" className="wst-alert"
message="「已支付待审核」= 还没审单,仓库根本没接到;「订单异常」= 聚水潭标记异常(缺货/地址/风控等)。两类都不该算仓库超时,故单列于此。" message="「待审核」= 订单状态还没审单(WaitConfirm),仓库根本没接到;「订单异常」= 聚水潭标记 Question(缺货/地址/风控等)。两类都不该算仓库超时,故单列于此。"
/> />
{heldOrders.length ? ( {heldOrders.length ? (
<Table <Table
@ -931,16 +1241,25 @@ function WarehouseShipTimeliness() {
</Modal> </Modal>
<Text type="secondary" className="wst-foot"> <Text type="secondary" className="wst-foot">
说明:<b>今天 7:00 前审核</b>的订单 13:00 核验;<b>截止 16:00 前审核</b>的单 18:00 核验 说明:数据源 = 聚水潭<b>订单表 jst_Orders + jst_qmcust_orderlist</b>(两张表店铺互斥,按 o_id 去重)。
<b>今天 7:00 前审核</b>的订单 13:00 核验;<b>截止 16:00 前审核</b>的单 18:00 核验
(含 7 点前审核、13:00 还没发出的,也含今天之前审核至今未发的历史单)。 (含 7 点前审核、13:00 还没发出的,也含今天之前审核至今未发的历史单)。
<b>到点仍未发货即超时</b>(不设「满 24 小时」门槛); <b>到点仍未发货即超时</b>(不设「满 24 小时」门槛);
轮次与「已等时长」都按审核时间(聚水潭显示值)算。 轮次与「已等时长」都按<b>审核时间</b>算(= 状态表 last_oa_confirm_time 与订单表 modified 的较晚者,
发货 = 聚水潭回传的发货时间。 审核才是仓库接到单的时刻;状态表会滞后,故取较晚者)。两者都取不到才回退订单创建时间,列上带 <b>*</b>。
<b>作废单不考核</b>(被合并 / 拆单父单 / 已取消,或订单表已有发货时间) 发货 = 订单表 send_date(为空才算未发)。<b>已发货不考核</b>:状态表 send_time 有值、
{summary.voidCount > 0 ? ` —— 本轮已自动剔除 ${summary.voidCount} 单` : ''}; 聚水潭状态「已发货」、或物流已揽收及之后,任一成立即判已发
<b>自提 / 中铁 / 壹米滴答不考核</b> {summary.stateShippedSkipped > 0 ? ` —— 本轮已剔除 ${summary.stateShippedSkipped} 单` : ''}。
状态只取「发货中」。
<b>作废单不考核</b>:聚水潭状态「已取消」,或订单表 labels 含「发货前售后」
{summary.voidCount > 0
? ` —— 本轮已自动剔除 ${summary.voidCount} 单`
+ `${summary.stateVoidSkipped > 0 ? `(其中 ${summary.stateVoidSkipped} 单靠聚水潭状态判出,订单表当时没同步)` : ''}`
: ''};
⚠️ 售后状态「已作废」<b>不算</b>作废单 —— 那是售后单被撤销、订单照常发货,仍要考核。
<b>{excludedCarrierText}不考核</b>
{summary.carrierSkipped > 0 ? ` —— 本轮已剔除 ${summary.carrierSkipped} 单` : ''}; {summary.carrierSkipped > 0 ? ` —— 本轮已剔除 ${summary.carrierSkipped} 单` : ''};
已支付待审核、订单异常的单归入「不计考核」,避免冤枉仓库。 待审核、订单异常的单归入「不计考核」,避免冤枉仓库。
</Text> </Text>
</SycmPage> </SycmPage>
); );

View File

@ -111,6 +111,45 @@
color: #1677ff; color: #1677ff;
} }
/* 超时卡下面的「其中 N 单数据未同步」—— 订单表停更时的警示小字(2026-10-28) */
.wst-stat__warn {
margin-top: 6px;
font-size: 12px;
line-height: 1.4;
color: #cf1322;
cursor: help;
}
/* 停更告警里逐个源列出「最后同步时间 / 滞后多久」 */
.wst-alert__sources {
margin-top: 6px;
display: flex;
flex-wrap: wrap;
gap: 4px 16px;
}
.wst-alert__source {
font-size: 12px;
color: rgba(0, 0, 0, 0.65);
font-variant-numeric: tabular-nums;
}
/* 明细里的「内部单号 + 未同步标记」 */
.wst-detail__oid {
display: inline-flex;
align-items: center;
gap: 4px;
font-variant-numeric: tabular-nums;
}
.wst-detail__stale {
margin-inline-end: 0;
font-size: 11px;
line-height: 16px;
padding-inline: 5px;
cursor: help;
}
/* ============ 主从两栏 ============ */ /* ============ 主从两栏 ============ */
.wst-body { .wst-body {
display: flex; display: flex;