Compare commits
No commits in common. "main" and "codex/picking-bin-picking-only-1008" have entirely different histories.
main
...
codex/pick
@ -238,7 +238,6 @@ router.get('/export', async (req, res) => {
|
||||
const sheetRows = filtered.map((r) => [
|
||||
whMap.get(r.wmsCoId) || r.wmsCoId,
|
||||
r.binName,
|
||||
r.binType,
|
||||
r.skuId,
|
||||
r.stockQty,
|
||||
r.skuCount,
|
||||
@ -257,7 +256,7 @@ router.get('/export', async (req, res) => {
|
||||
sheets: [{
|
||||
name: '库位动销明细',
|
||||
header: [
|
||||
'仓库', '仓位', '类型', '商品编码', '库存数量', '仓位SKU数',
|
||||
'仓库', '仓位', '商品编码', '库存数量', '仓位SKU数',
|
||||
`商品销量(近${days}天)`, `分摊销量(近${days}天)`, '商品日销',
|
||||
'动销等级', '统计天数', '统计基准日',
|
||||
],
|
||||
|
||||
@ -1,62 +0,0 @@
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* 仓储中心 24 小时发货时效 —— HTTP 路由（2026-10-20 新增）
|
||||
* ────────────────────────────────────────────────────────────────────────────
|
||||
* GET /api/warehouse-ship-timeliness/list
|
||||
* query:
|
||||
* round 'NOON' | 'AFTERNOON' 手动指定核验轮次；不传按当前时刻自动判定
|
||||
* limit 明细条数上限（默认 500，最大 2000）
|
||||
*
|
||||
* GET /api/warehouse-ship-timeliness/rounds
|
||||
* 只返回今日两轮的描述（页面顶部提示用，不打订单表，秒回）
|
||||
*
|
||||
* 挂载见 src/index.js：`/api/warehouse-ship-timeliness` + authMiddleware
|
||||
*/
|
||||
|
||||
const express = require('express');
|
||||
const { getShipTimeliness } = require('../services/warehouseShipTimelinessService');
|
||||
const { describeRounds, CENTERS } = require('../services/warehouseShipTimelinessRegistry');
|
||||
|
||||
const router = express.Router();
|
||||
|
||||
function sendError(res, error, fallback) {
|
||||
const status = Number(error?.statusCode) || 500;
|
||||
console.error('[WarehouseShipTimeliness]', {
|
||||
message: error?.message || fallback,
|
||||
code: error?.code || null,
|
||||
status,
|
||||
});
|
||||
res.status(status).json({ success: false, error: error.message || fallback });
|
||||
}
|
||||
|
||||
// 时效总览：每个主仓「超时未发」数量 + 超时订单明细
|
||||
router.get('/list', async (req, res) => {
|
||||
try {
|
||||
const data = await getShipTimeliness(req.query || {});
|
||||
res.json({ success: true, data });
|
||||
} catch (error) {
|
||||
sendError(res, error, '加载仓储中心发货时效失败');
|
||||
}
|
||||
});
|
||||
|
||||
// 仅轮次信息（不查订单）
|
||||
router.get('/rounds', async (_req, res) => {
|
||||
try {
|
||||
res.json({
|
||||
success: true,
|
||||
data: {
|
||||
rounds: describeRounds(new Date()),
|
||||
centers: CENTERS.map((c) => ({
|
||||
key: c.key,
|
||||
name: c.name,
|
||||
placeholder: Boolean(c.placeholder),
|
||||
})),
|
||||
},
|
||||
});
|
||||
} catch (error) {
|
||||
sendError(res, error, '加载核验轮次失败');
|
||||
}
|
||||
});
|
||||
|
||||
module.exports = router;
|
||||
@ -764,20 +764,7 @@ async function connectWithCandidate(candidate) {
|
||||
}
|
||||
|
||||
async function queryWithCandidateConnection(candidate, sqlText, params = {}, options = {}) {
|
||||
// request.timeout（请求级）在 mssql 12.x 上实测不生效（始终按池配置的默认值掐断），
|
||||
// 慢查询必须通过「池配置级 requestTimeout」放宽，这里允许调用方覆盖候选连接的池级超时。
|
||||
let mssqlConfig = candidate.mssqlConfig;
|
||||
const poolRequestTimeout = parsePositiveInt(options.connectRequestTimeoutMs, 0);
|
||||
if (poolRequestTimeout > 0) {
|
||||
mssqlConfig = {
|
||||
...candidate.mssqlConfig,
|
||||
options: {
|
||||
...candidate.mssqlConfig.options,
|
||||
requestTimeout: poolRequestTimeout,
|
||||
},
|
||||
};
|
||||
}
|
||||
const nextPool = new sql.ConnectionPool(mssqlConfig);
|
||||
const nextPool = new sql.ConnectionPool(candidate.mssqlConfig);
|
||||
|
||||
try {
|
||||
await nextPool.connect();
|
||||
@ -1106,28 +1093,6 @@ const queryWithFreshConnection = async (sqlText, params = {}, options = {}) => {
|
||||
return [];
|
||||
};
|
||||
|
||||
/**
|
||||
* 慢查询专用入口：走独立临时连接，池级 requestTimeout 放宽到 SLOW_QUERY_POOL_TIMEOUT_MS。
|
||||
* 背景：mssql 12.x 的 request.timeout（请求级）不生效，超过池默认 60s 的查询必须用
|
||||
* 池配置级 requestTimeout 才能放宽。适用场景：动销分析这类多表大窗口聚合。
|
||||
*/
|
||||
const SLOW_QUERY_POOL_TIMEOUT_MS = parsePositiveInt(
|
||||
process.env.CLOUD_DB_SLOW_QUERY_TIMEOUT_MS,
|
||||
300000
|
||||
);
|
||||
|
||||
const querySlow = async (sqlText, params = {}, options = {}) => {
|
||||
const poolRequestTimeout = parsePositiveInt(
|
||||
options.connectRequestTimeoutMs,
|
||||
SLOW_QUERY_POOL_TIMEOUT_MS
|
||||
);
|
||||
return queryWithFreshConnection(sqlText, params, {
|
||||
...options,
|
||||
connectRequestTimeoutMs: poolRequestTimeout,
|
||||
requestTimeout: poolRequestTimeout,
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* 测试连接
|
||||
*/
|
||||
@ -1178,7 +1143,6 @@ const reload = async () => {
|
||||
module.exports = {
|
||||
getPool,
|
||||
query,
|
||||
querySlow,
|
||||
queryWithFreshConnection,
|
||||
createPinnedQueryClient,
|
||||
test,
|
||||
|
||||
@ -11,12 +11,8 @@
|
||||
*
|
||||
* 口径：
|
||||
* 库存数量：rpt.jst_packInventoryInfo 按 wms_co_id + 仓位 + sku_id 汇总 qty
|
||||
* 统计范围：只统计真实拣选仓位（pack_type=Bin 且 bin_group 为空）；
|
||||
* 箱记录（pack_type=Pack）与存货位（bin_group=存货）不纳入
|
||||
* 销量： 4 个来源分支，均按 send_date 窗口（详见 services/pickingBinSalesAnalysis.js）：
|
||||
* ① jst_Orders 普通行；② jst_Orders 组合装行 → jst_comboProductItem 展开为子件；
|
||||
* ③ jst_qmcust_orderlist（全民客户 B2B 分销）普通行（排除拆单父单 Split）；
|
||||
* ④ qmcust 组合装行 → 同样展开。
|
||||
* 统计范围：只统计拣选位（bin_group 为空）；存货位（bin_group=存货）不纳入
|
||||
* 销量： rpt.jst_Orders × rpt.jst_OrderItem，按 send_date，排除 Delete/Cancelled
|
||||
* 日销： 商品窗口销量 / 窗口天数（整档，不按仓位分摊）
|
||||
* 等级： 严格按商品日销判定，同一商品占多少个仓位都是同一等级
|
||||
*
|
||||
@ -40,9 +36,8 @@ const PICKING_BIN_WINDOW_OPTIONS = [7, 15, 30, 60];
|
||||
const PICKING_BIN_DEFAULT_DAYS = 30;
|
||||
|
||||
/**
|
||||
* 仓位类型：本功能只统计真实拣选仓位（pack_type=Bin 且 bin_group 为空）。
|
||||
* 箱记录（pack_type=Pack）和存货位（bin_group=存货）不纳入动销等级统计，
|
||||
* 取数在仓位库存表上直接过滤，
|
||||
* 仓位类型：本功能只统计拣选位（业务库 bin_group 为空即拣选位）。
|
||||
* 存货位（bin_group=存货）不纳入动销等级统计，取数在仓位库存表上直接过滤，
|
||||
* 页面也不再提供类型切换。
|
||||
*/
|
||||
const BIN_TYPE_PICKING = '拣选';
|
||||
|
||||
@ -35,7 +35,6 @@ const promotionModuleRoutes = require('./api/promotionModule');
|
||||
const productMonitoringRoutes = require('./api/productMonitoring');
|
||||
const modularStockMonitorRoutes = require('./api/modularStockMonitor');
|
||||
const mkhBomRoutes = require('./api/mkhBom');
|
||||
const warehouseShipTimelinessRoutes = require('./api/warehouseShipTimeliness');
|
||||
const dailyInventoryRoutes = require('./api/dailyInventory');
|
||||
const dailyInventoryNotificationRoutes = require('./api/dailyInventoryNotification');
|
||||
const stockSalesAnalysisRoutes = require('./api/stockSalesAnalysis');
|
||||
@ -673,8 +672,6 @@ async function startServer(options = {}) {
|
||||
cubejsApp.use('/api/product-monitoring', authMiddleware, productMonitoringRoutes);
|
||||
cubejsApp.use('/api/modular-stock-monitor', authMiddleware, modularStockMonitorRoutes);
|
||||
cubejsApp.use('/api/mkh-bom', authMiddleware, mkhBomRoutes);
|
||||
// 仓储中心 24 小时发货时效（2026-10-20 新增）：列表左侧侧栏，11 个主仓超时未发
|
||||
cubejsApp.use('/api/warehouse-ship-timeliness', authMiddleware, warehouseShipTimelinessRoutes);
|
||||
cubejsApp.use('/api/daily-inventory', authMiddleware, dailyInventoryRoutes);
|
||||
cubejsApp.use('/api/daily-inventory-notification', authMiddleware, dailyInventoryNotificationRoutes);
|
||||
cubejsApp.use('/api/stock-sales-analysis', authMiddleware, stockSalesAnalysisRoutes);
|
||||
|
||||
@ -70,11 +70,8 @@
|
||||
// 规则：近 15 天日销 > 0 且 现有库存 < 3 天日销 → 预警补货
|
||||
// · 近15天日销 rpt.pm_stockMonitor.fifteenAvgSale
|
||||
// （warehouse = '简尚-崔桥工厂品牌仓'，按 date 取最新一条快照）
|
||||
// · 现有库存 rpt.jst_inventoryInfo（wms_co_id **仓白名单**）实时库存；
|
||||
// 🔥 2026-10-17 修正为**多仓求和**（原来是单仓 15870495）：商品档案 other_3 只记
|
||||
// 「归属仓」，实物会整批搬到同体系其它发货仓 —— 只查归属仓会把有货的算成 0。
|
||||
// 实测新仓「简尚-横林二仓品牌仓」(16132681，10-13 建仓) 58 个 MKH 成品 / 525 件
|
||||
// 全在它名下、归属仓为 0 → 5 个误报缺货 + 2 个误报预警。白名单见 BRAND_WMS_CO_IDS。
|
||||
// · 现有库存 rpt.jst_inventoryInfo（wms_co_id = 15870495 品牌仓）实时库存；
|
||||
// 该仓对 MKH 成品只覆盖约 256 / 4408 条（2026-09-16 快照；成品总数口径见 ①），
|
||||
// 缺失时回退监控快照 jsStock
|
||||
// · 结余库存 = max(0, 现有库存 − 待发货订单)
|
||||
// ⚠️ 2026-09-18 起：已下单未发货的部分已被占用，**所有口径一律先扣待发订单**
|
||||
@ -218,28 +215,6 @@
|
||||
// 若日后业务反馈「库存大面积停在某个时间点」，**先查 inventoryInfo 的
|
||||
// MAX(updateTime)**，再看箱表的，两者一对即可判断是上游停了还是本页取数问题。
|
||||
//
|
||||
// ── ⑦-e 成品库存多仓合并（2026-10-17 新增）────────────────────────
|
||||
// 业务原话：「MKHDNZ0409260600788 库存在横林二仓品牌仓，**重新加了一个品牌仓库存**，
|
||||
// 需要同步这个仓库库存」。
|
||||
// 🔥 根因：**商品档案的 `other_3` 记录的是「归属仓」，不是「实物所在仓」**。
|
||||
// 归属仓仍是「简尚-崔桥工厂品牌仓」(15870495)，但实物被整批搬到 10-13 新建的
|
||||
// 「简尚-横林二仓品牌仓」(16132681) —— 归属仓库存为 0，新仓有货。
|
||||
// 而 ⑦-d 的取数只看 `wms_co_id = 15870495` 单仓 → 该批商品库存全被算成 0。
|
||||
// 实测：新仓 58 个 SKU 全是 MKH 成品（other_3 全为崔桥品牌仓），合计 525 件；
|
||||
// 线上 49 个 SKU 库存值错误，其中 **5 个误报「缺货」、2 个误报「预警」**。
|
||||
// 规则：`jst_inventoryInfo` / `jst_packInventoryInfo` 都按 **仓白名单 `IN (...)`**
|
||||
// 取数，并 **按 SKU 多仓求和**（同一批货可能同时分散在多仓）。
|
||||
// · 白名单常量：BRAND_WMS_CO_IDS（主仓 + 横林二仓品牌仓）
|
||||
// · ⚠️ 原来的「按 updateTime DESC 取首条」在单仓时是去重，多仓时会**只留一个仓**，
|
||||
// 必须换成 SUM + GROUP BY（本次改动同时修掉这个隐患）。
|
||||
// · ⚠️ 「求和」而非「取最大」：两仓是独立仓位，同一 SKU 同批货不会重复记账
|
||||
// （实测该 SKU 两仓 bin 分别为 `PP01-15-22` 与空，无同箱重复）。
|
||||
// 影响面（2026-10-17 实测）：58 个 SKU 受影响，其中 49 个库存值变化；
|
||||
// 预警 30 → 25、缺货 21 → 16（消除 5 个误报缺货、2 个误报预警）。
|
||||
// ⚠️ 新增同类「成品发货仓-真实库存」时，往 BRAND_WMS_CO_IDS 追加 wms_co_id 即可。
|
||||
// ⚠️ 配件库存**不适用本口径**（配件仍只算 15718196）——新仓一个配件都没有，
|
||||
// 横林三仓/沭阳仓虽有 MKH 配件但归属别的项目，并入会让「配件不足」漏报。
|
||||
//
|
||||
// ── ⑧ 在途加工单（2026-09-17 业务确认口径）────────────────────────
|
||||
// 规则：**只要该 MKH 商品存在未完成的加工单，就不再列入补货预警**
|
||||
// （工厂已经在做了，不重复提示补货），改标为「已排产」。
|
||||
@ -435,17 +410,8 @@ const MKH_WHERE = `s.sku_id LIKE N'MKH%'
|
||||
)`;
|
||||
|
||||
// ── 补货预警参数（见文件头 ⑦）────────────────────────────────────
|
||||
// 成品库存仓白名单（rpt.jst_warehouseInfo 查得）。**多仓求和**：
|
||||
// 商品档案的 other_3 只记录「归属仓」（仍是崔桥工厂品牌仓），但实物会成批搬到
|
||||
// 同体系的其它发货仓，此时库存表里只有新仓有数、归属仓为 0 —— 只查归属仓会把
|
||||
// 有货的商品算成 0（实测 2026-10-17：新仓「简尚-横林二仓品牌仓」10-13 建仓，
|
||||
// 58 个 MKH 成品 / 525 件全部只在它名下，导致 5 个误报缺货 + 2 个误报预警）。
|
||||
// · 15870495 简尚-崔桥工厂品牌仓（归属主仓）
|
||||
// · 16132681 简尚-横林二仓品牌仓（2026-10-13 新增，成品发货仓-真实库存）
|
||||
// ⚠️ 新增同类「成品发货仓-真实库存」时把 wms_co_id 追加进来即可，别再写死单仓。
|
||||
const BRAND_WMS_CO_IDS = Object.freeze([15870495, 16132681]);
|
||||
// 兼容旧引用：主仓仍作为「仓库名」文案与监控快照的 warehouse 过滤值
|
||||
const BRAND_WMS_CO_ID = BRAND_WMS_CO_IDS[0];
|
||||
// 品牌仓 wms_co_id（rpt.jst_warehouseInfo 查得）
|
||||
const BRAND_WMS_CO_ID = 15870495;
|
||||
// 日销统计窗口（天）。见文件头 ⑦：业务最初要 30 天，但全库无 30 天日销数据，
|
||||
// 实测最长只有 fifteenAvgSale(15 天)，经业务确认改用 15 天。
|
||||
// ⚠️ SALE_WINDOW_DAYS 决定页面文案与口径展示，DAILY_SALE_COLUMN 决定实际取数列，
|
||||
@ -571,10 +537,8 @@ const normalizeCode = (value) => {
|
||||
// 筛选 / 排序 / 分页 / 统计全部在内存完成，SQL 侧只负责取数。
|
||||
const REPLENISH_PARAMS = Object.freeze({
|
||||
brandWarehouse: DESIGNATED_WAREHOUSE,
|
||||
brandWmsCoId: BRAND_WMS_CO_ID,
|
||||
});
|
||||
// 成品库存仓白名单的 SQL 片段（纯代码常量插值，不含外部输入）。
|
||||
// 用 `IN (...)` 一条查完多仓，再由应用层按 SKU **求和**分仓结果。
|
||||
const BRAND_WMS_CO_ID_LIST_SQL = BRAND_WMS_CO_IDS.join(',');
|
||||
// 商品集合是主数据、监控快照为日更，10 分钟缓存足够
|
||||
const MKH_CACHE_TTL_MS = 10 * 60 * 1000;
|
||||
let mkhProductCache = null;
|
||||
@ -1793,23 +1757,21 @@ async function loadReplenishIndex() {
|
||||
REPLENISH_PARAMS,
|
||||
{ requestTimeout: 180000 }
|
||||
),
|
||||
// 实时库存（见文件头 ⑦-d）：仓白名单多仓，**按 SKU 求和**（同一批货可能分散在多仓）。
|
||||
// ⚠️ 不能再用「按 updateTime DESC 取首条」——那会只留一个仓的数，正好丢掉新仓。
|
||||
// 实时库存：同一 SKU 可能多行，按 updateTime DESC 取首条
|
||||
cloudDatabase.query(
|
||||
`SELECT i.sku_id AS skuId, SUM(i.qty) AS qty
|
||||
`SELECT i.sku_id AS skuId, i.qty AS qty
|
||||
FROM dbo.jst_inventoryInfo i
|
||||
WHERE i.wms_co_id IN (${BRAND_WMS_CO_ID_LIST_SQL}) AND i.sku_id LIKE N'MKH%'
|
||||
GROUP BY i.sku_id`,
|
||||
WHERE i.wms_co_id = @brandWmsCoId AND i.sku_id LIKE N'MKH%'
|
||||
ORDER BY i.sku_id ASC, i.updateTime DESC`,
|
||||
REPLENISH_PARAMS,
|
||||
{ requestTimeout: 180000 }
|
||||
),
|
||||
// 箱/货位库存（见文件头 ⑦-d）：inventoryInfo 是日更，当日入库当天看不到，
|
||||
// 用小时级的箱表补 0。只取 bin 非空行 —— bin 为空的是装箱记录，不是库存。
|
||||
// 同样按仓白名单多仓求和（见 BRAND_WMS_CO_IDS 注释）。
|
||||
cloudDatabase.query(
|
||||
`SELECT p.sku_id AS skuId, SUM(p.qty) AS qty
|
||||
FROM dbo.jst_packInventoryInfo p
|
||||
WHERE p.wms_co_id IN (${BRAND_WMS_CO_ID_LIST_SQL}) AND p.sku_id LIKE N'MKH%'
|
||||
WHERE p.wms_co_id = @brandWmsCoId AND p.sku_id LIKE N'MKH%'
|
||||
AND NULLIF(LTRIM(RTRIM(p.bin)), N'') IS NOT NULL
|
||||
GROUP BY p.sku_id`,
|
||||
REPLENISH_PARAMS,
|
||||
@ -2720,9 +2682,6 @@ module.exports = {
|
||||
COMPONENT_STOCK_WAREHOUSE,
|
||||
COMPONENT_STOCK_CHUNK_SIZE,
|
||||
COMPONENT_SHORTAGE_MAX_LIST,
|
||||
// ⑦-d 成品库存仓白名单（多仓求和口径）
|
||||
BRAND_WMS_CO_IDS,
|
||||
BRAND_WMS_CO_ID,
|
||||
parseFlag,
|
||||
resolveScope,
|
||||
filterRows,
|
||||
|
||||
@ -4,14 +4,8 @@
|
||||
* 拣选库位动销分析 —— 业务库取数
|
||||
*
|
||||
* 库存：rpt.jst_packInventoryInfo 按 wms_co_id + 仓位 + sku_id 汇总 qty（仓位为空的行不参与）
|
||||
* 范围：只统计真实拣选仓位（pack_type=Bin 且 bin_group 为空）；
|
||||
* 箱记录（pack_type=Pack）与存货位（bin_group=存货）不纳入
|
||||
* 销量（4 个来源分支，均按 send_date 窗口）：
|
||||
* 1) rpt.jst_Orders × jst_OrderItem 普通行（sku_type<>combine），排除 Delete/Cancelled
|
||||
* 2) rpt.jst_Orders 组合装行（sku_id 为 ZH-... 拼接串）→ JOIN jst_comboProductItem 展开为子件×数量
|
||||
* 3) rpt.jst_qmcust_orderlist（全民客户 B2B 分销）普通行，排除 Delete/Cancelled/Split/Question
|
||||
* （Split 是拆单父单，与拆出的子单重复，必须排除）
|
||||
* 4) rpt.jst_qmcust_orderlist 组合装行 → 同样按映射表展开
|
||||
* 范围：只统计拣选位（bin_group 为空）；存货位（bin_group=存货）不纳入
|
||||
* 销量：rpt.jst_Orders × rpt.jst_OrderItem，按 send_date，排除 Delete/Cancelled
|
||||
* 粒度：仓位 × 商品编码（一个仓位有 N 个商品就输出 N 行），列表与导出共用
|
||||
*
|
||||
* 【日销与动销等级口径】按「商品日销」判定，不做仓位分摊：
|
||||
@ -90,8 +84,8 @@ async function fetchPickingBinSkuRows(cloudDb, wmsCoIds, options = {}) {
|
||||
const binIn = buildInClause(wmsCoIds, 'w');
|
||||
const shipIn = buildInClause(wmsCoIds, 'v');
|
||||
|
||||
// 统计范围固定为真实拣选仓位：pack_type=Bin 且 bin_group 为空。
|
||||
// 仅过滤 bin_group 会把同样为空的 Pack 箱记录误标为拣选位。
|
||||
// 统计范围固定为拣选位：直接在仓位库存表上过滤 bin_group 为空，
|
||||
// 存货位（bin_group=存货）不参与动销等级统计。
|
||||
const sqlText = `
|
||||
WITH bin AS (
|
||||
SELECT p.wms_co_id AS wmsCoId,
|
||||
@ -103,7 +97,6 @@ async function fetchPickingBinSkuRows(cloudDb, wmsCoIds, options = {}) {
|
||||
WHERE p.wms_co_id IN (${binIn.clause})
|
||||
AND ISNULL(p.bin, '') <> ''
|
||||
AND ISNULL(p.qty, 0) <> 0
|
||||
AND p.pack_type = N'Bin'
|
||||
AND ISNULL(p.bin_group, '') = ''
|
||||
GROUP BY p.wms_co_id,
|
||||
LTRIM(RTRIM(p.bin)),
|
||||
@ -115,7 +108,6 @@ async function fetchPickingBinSkuRows(cloudDb, wmsCoIds, options = {}) {
|
||||
GROUP BY wmsCoId, skuId, binType
|
||||
),
|
||||
ship AS (
|
||||
-- 1) 线上店铺订单：普通商品行（sku_type<>combine，组合装行在下一分支展开）
|
||||
SELECT o.wms_co_id AS wmsCoId,
|
||||
oi.sku_id AS skuId,
|
||||
SUM(CAST(ISNULL(oi.qty, 0) AS DECIMAL(18, 2))) AS salesQty
|
||||
@ -125,58 +117,7 @@ async function fetchPickingBinSkuRows(cloudDb, wmsCoIds, options = {}) {
|
||||
AND o.send_date >= @shipFrom
|
||||
AND o.send_date < @shipTo
|
||||
AND ISNULL(o.status, '') NOT IN ('Delete', 'Cancelled')
|
||||
AND ISNULL(oi.sku_type, 'normal') <> 'combine'
|
||||
GROUP BY o.wms_co_id, oi.sku_id
|
||||
UNION ALL
|
||||
-- 2) 线上店铺订单：组合装行（sku_id 为 ZH-子件A-N-子件B-M 拼接串）→ 按映射表展开为子件
|
||||
SELECT o.wms_co_id AS wmsCoId,
|
||||
ci.src_sku_id AS skuId,
|
||||
SUM(CAST(ISNULL(oi.qty, 0) * ISNULL(ci.qty, 0) AS DECIMAL(18, 2))) AS salesQty
|
||||
FROM rpt.jst_OrderItem oi
|
||||
JOIN rpt.jst_Orders o ON o.o_id = oi.o_id
|
||||
JOIN rpt.jst_comboProductItem ci ON ci.combine_sku_id = oi.sku_id
|
||||
WHERE o.wms_co_id IN (${shipIn.clause})
|
||||
AND o.send_date >= @shipFrom
|
||||
AND o.send_date < @shipTo
|
||||
AND ISNULL(o.status, '') NOT IN ('Delete', 'Cancelled')
|
||||
AND oi.sku_type = 'combine'
|
||||
GROUP BY o.wms_co_id, ci.src_sku_id
|
||||
UNION ALL
|
||||
-- 3) 全民客户（B2B 分销）订单：普通商品行（拆单父单 Split 与子单重复，需排除）
|
||||
SELECT o.wms_co_id AS wmsCoId,
|
||||
oi.sku_id AS skuId,
|
||||
SUM(CAST(ISNULL(oi.qty, 0) AS DECIMAL(18, 2))) AS salesQty
|
||||
FROM rpt.jst_qmcust_orderlist_item oi
|
||||
JOIN rpt.jst_qmcust_orderlist o ON o.o_id = oi.o_id
|
||||
WHERE o.wms_co_id IN (${shipIn.clause})
|
||||
AND o.send_date >= @shipFrom
|
||||
AND o.send_date < @shipTo
|
||||
AND ISNULL(o.status, '') NOT IN ('Delete', 'Cancelled', 'Split', 'Question')
|
||||
AND ISNULL(oi.sku_type, 'normal') <> 'combine'
|
||||
GROUP BY o.wms_co_id, oi.sku_id
|
||||
UNION ALL
|
||||
-- 4) 全民客户订单：组合装行展开为子件
|
||||
SELECT o.wms_co_id AS wmsCoId,
|
||||
ci.src_sku_id AS skuId,
|
||||
SUM(CAST(ISNULL(oi.qty, 0) * ISNULL(ci.qty, 0) AS DECIMAL(18, 2))) AS salesQty
|
||||
FROM rpt.jst_qmcust_orderlist_item oi
|
||||
JOIN rpt.jst_qmcust_orderlist o ON o.o_id = oi.o_id
|
||||
JOIN rpt.jst_comboProductItem ci ON ci.combine_sku_id = oi.sku_id
|
||||
WHERE o.wms_co_id IN (${shipIn.clause})
|
||||
AND o.send_date >= @shipFrom
|
||||
AND o.send_date < @shipTo
|
||||
AND ISNULL(o.status, '') NOT IN ('Delete', 'Cancelled', 'Split', 'Question')
|
||||
AND oi.sku_type = 'combine'
|
||||
GROUP BY o.wms_co_id, ci.src_sku_id
|
||||
),
|
||||
shipAgg AS (
|
||||
-- 同一个 仓库+商品 可能同时命中多个来源分支（线上普通/线上组合装/全民客户普通/全民客户组合装），
|
||||
-- 必须先按 仓库+商品 汇总成一行再 join，否则一个仓位行会被拆成多行、每行只带某分支的销量。
|
||||
SELECT wmsCoId,
|
||||
skuId,
|
||||
SUM(CAST(salesQty AS DECIMAL(18, 2))) AS salesQty
|
||||
FROM ship
|
||||
GROUP BY wmsCoId, skuId
|
||||
),
|
||||
binAgg AS (
|
||||
SELECT wmsCoId,
|
||||
@ -201,16 +142,13 @@ async function fetchPickingBinSkuRows(cloudDb, wmsCoIds, options = {}) {
|
||||
ON sp.wmsCoId = b.wmsCoId AND sp.skuId = b.skuId AND sp.binType = b.binType
|
||||
JOIN binAgg a
|
||||
ON a.wmsCoId = b.wmsCoId AND a.binName = b.binName AND a.binType = b.binType
|
||||
LEFT JOIN shipAgg s
|
||||
LEFT JOIN ship s
|
||||
ON s.wmsCoId = b.wmsCoId AND s.skuId = b.skuId
|
||||
GROUP BY b.wmsCoId, b.binName, b.binType, b.skuId, a.skuCount, s.salesQty, sp.binCount
|
||||
HAVING ABS(SUM(CAST(b.binSkuQty AS DECIMAL(18, 2)))) > 0.0001
|
||||
ORDER BY b.wmsCoId, b.binType, b.binName, b.skuId`;
|
||||
|
||||
// 该查询 union 了 4 个销量来源（含 qmcust 全渠道扫描），全仓窗口可能超过默认 60s；
|
||||
// mssql 12.x 请求级 timeout 不生效，必须走池级放宽的慢查询入口。
|
||||
const runQuery = typeof cloudDb.querySlow === 'function' ? cloudDb.querySlow : cloudDb.query;
|
||||
const rows = await runQuery(
|
||||
const rows = await cloudDb.query(
|
||||
sqlText,
|
||||
{
|
||||
...binIn.params,
|
||||
|
||||
@ -1,246 +0,0 @@
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* 仓储中心 24 小时发货时效（2026-10-20 新增）
|
||||
* ────────────────────────────────────────────────────────────────────────────
|
||||
* 需求（yanhui 2026-10-20）：
|
||||
* MKH-BOM 列表左侧加一栏「仓储中心24小时发货时效」，下列 11 个仓：
|
||||
* 横林二仓 / 横林三仓 / 横林二仓品牌仓 / 崔桥工厂仓 / 崔桥工厂品牌仓 /
|
||||
* 崔桥工厂半成品仓 / 新苏北仓 / 睢宁仓 / 山东青岗集仓 / 山东品牌仓 / 河南洛宁仓
|
||||
* 从系统库存抓取「已发货订单」与「未发货订单」，按**订单创建时间**算是否及时。
|
||||
* 每天 12:00 核验「当天创建、7:00 前」的订单是否已发货；
|
||||
* 每天 16:00 核验「当天创建、16:00 前」的订单是否已发货。
|
||||
* 展示口径：**只显示超时未发**（业务确认）。
|
||||
*
|
||||
* 业务确认的口径（2026-10-20 AskUserQuestion）：
|
||||
* ① 子仓归属主仓 —— **连子仓一起算**（如 横林二仓 含京东云仓/京东自营仓/运营C专用仓 等）
|
||||
* ② 崔桥工厂半成品仓 —— 系统无同名仓，**先留空占位**（不映射到 15718196）
|
||||
* ③ 展示结构 —— **只显示超时未发**
|
||||
*
|
||||
* ── 数据源 ────────────────────────────────────────────────────────────────
|
||||
* 订单：两张表**店铺互斥，必须都读**（见 mkhBomService 文件头）
|
||||
* rpt.jst_Orders —— 京东 / 拼多多 / 抖音 / 得物 / 唯品会
|
||||
* rpt.jst_qmcust_orderlist —— 天猫 / 淘宝 / 1688
|
||||
* 字段口径：
|
||||
* · 创建时间：`order_date`（订单创建时间，业务要求按此算时效）
|
||||
* · 发货时间：`send_date`（为空 = 未发货）
|
||||
* · 发货仓： `wms_co_id`（订单**发货仓**，不是 SKU 的归属仓）
|
||||
* ⚠️ 用户原话「从系统库存抓取」—— 本实现取的是**订单维度**的仓库归属，
|
||||
* 因为 jst_inventoryInfo 只有「某 SKU 在某仓有多少件」，没有订单记录。
|
||||
*
|
||||
* ── 仓库归属（按名称包含匹配，最长匹配优先）────────────────────────────────
|
||||
* `rpt.jst_warehouseInfo` 实测（2026-10-20）：
|
||||
* 横林二仓 15033302 + 15197138/15301814/15835893/16040225/16132681
|
||||
* 横林三仓 15043561
|
||||
* 横林二仓品牌仓 16132681（**同时命中也属于「横林二仓」，靠最长匹配优先归到品牌仓**）
|
||||
* 崔桥工厂仓 15038426 + 15301815/16040410
|
||||
* 崔桥工厂品牌仓 15870495
|
||||
* 崔桥工厂半成品仓 —— 无同名仓，留空
|
||||
* 新苏北仓 15038347 + 15315031/15301812
|
||||
* 睢宁仓 15032603 + 15051907/15051960/15052203/15301813/15386911
|
||||
* 山东青岗集仓 15137523 + 15283033/15406664/15835935/16040432/16129076
|
||||
* 山东品牌仓 15182705
|
||||
* 河南洛宁仓 15539084
|
||||
* ⟹ 仓库 ID → 主仓 的映射**在启动时从库表读取并缓存**（不用手写 ID 常量，
|
||||
* 避免上游新增子仓后要改代码；新增子仓只要名字里带主仓关键词就会自动归入）。
|
||||
* 缓存 TTL 1 小时，可用 clearWarehouseCache() 手动清。
|
||||
*
|
||||
* ── 时效判定 ──────────────────────────────────────────────────────────────
|
||||
* 截止时刻（每日两轮，取**当前已生效且最晚**的那一轮；未到 12:00 时无截止）：
|
||||
* 12:00 → 核验「当天 00:00 ~ 07:00 创建」的订单
|
||||
* 16:00 → 核验「当天 00:00 ~ 16:00 创建」的订单
|
||||
* 判定：
|
||||
* · 超时未发 = `send_date IS NULL` 且 `order_date <= 截止时刻`
|
||||
* · 按时已发 = `send_date IS NOT NULL` 且 `send_date <= 截止时刻` → **不计入超时**
|
||||
* · 已发但超时 = `send_date > 截止时刻` → 也算超时（已发，但没赶上截止）
|
||||
* 业务只要「超时未发」，所以列表只返回 `send_date IS NULL` 的超时单；
|
||||
* 但 summary 里仍给出 `overdueShipped`，避免「已发但超时」被当成没超时。
|
||||
*
|
||||
* ── 时区 ──────────────────────────────────────────────────────────────────
|
||||
* 订单时间列存的是**东八区本地时间**（实测 `order_date` 与 `created` 相差十几秒，
|
||||
* 均为北京时间）。因此 SQL 里统一用 `CAST(GETDATE() AS date)` 取「今天」，
|
||||
* 服务器与数据库都在东八区；**不要**在 Node 侧用 UTC 日期做判断。
|
||||
*/
|
||||
|
||||
const cloudDatabase = require('../config/cloudDatabase');
|
||||
|
||||
// ── 主仓定义（业务给定的 11 个）──────────────────────────────────────────
|
||||
// keywords：该主仓在 rpt.jst_warehouseInfo.name 里应包含的关键词（任一命中即归属）
|
||||
// 顺序即展示顺序；`match` 用最长关键词优先，所以「横林二仓品牌仓」不会被「横林二仓」抢走。
|
||||
const CENTERS = Object.freeze([
|
||||
{ key: 'HL2', name: '横林二仓', keywords: ['横林二仓'] },
|
||||
{ key: 'HL3', name: '横林三仓', keywords: ['横林三仓'] },
|
||||
{ key: 'HL2_BRAND', name: '横林二仓品牌仓', keywords: ['横林二仓品牌仓'] },
|
||||
{ key: 'CQ', name: '崔桥工厂仓', keywords: ['崔桥工厂仓'] },
|
||||
{ key: 'CQ_BRAND', name: '崔桥工厂品牌仓', keywords: ['崔桥工厂品牌仓'] },
|
||||
// 系统内无同名仓（最接近的「简尚-崔桥工厂半成品包装项目仓」15718196 是配件仓，
|
||||
// 业务确认先留空占位，不并进来）
|
||||
{ key: 'CQ_WIP', name: '崔桥工厂半成品仓', keywords: [], placeholder: true },
|
||||
{ key: 'XSB', name: '新苏北仓', keywords: ['新苏北'] },
|
||||
{ key: 'SN', name: '睢宁仓', keywords: ['睢宁'] },
|
||||
{ key: 'SD_QGJ', name: '山东青岗集仓', keywords: ['山东青岗集'] },
|
||||
{ key: 'SD_BRAND', name: '山东品牌仓', keywords: ['山东品牌仓'] },
|
||||
{ key: 'HN_LN', name: '河南洛宁仓', keywords: ['河南洛宁'] },
|
||||
]);
|
||||
|
||||
// 「横林三仓」与「横林二仓」不含对方，安全；但「崔桥工厂品牌仓」含「崔桥工厂仓」片段，
|
||||
// 靠关键词长度倒序匹配即可（见 resolveCenter）。
|
||||
const SORTED_KEYWORDS = CENTERS
|
||||
.filter((c) => c.keywords.length)
|
||||
.flatMap((c) => c.keywords.map((kw) => ({ kw, center: c })))
|
||||
.sort((a, b) => b.kw.length - a.kw.length);
|
||||
|
||||
// ── 时效轮次（业务给定）──────────────────────────────────────────────────
|
||||
// cutoffHour：当天几点截止；windowEndHour：只核验「创建时间不晚于该时刻」的订单
|
||||
const ROUNDS = Object.freeze([
|
||||
{ key: 'NOON', label: '12:00 轮', cutoffHour: 12, windowEndHour: 7 },
|
||||
{ key: 'AFTERNOON', label: '16:00 轮', cutoffHour: 16, windowEndHour: 16 },
|
||||
]);
|
||||
|
||||
// 只排除取消/合并单；Question 仍计入（与 mkhBomService 待发货口径一致）
|
||||
//
|
||||
// 🔥 Split（拆单）：**必须排除**。拆单是「父单被拆成子单」的中间态，父单本身
|
||||
// 不会发货（`send_date` 永远为空），子单才是真正进仓发货的那一单。
|
||||
// 2026-10-20 实测：不加这个条件，一年前的 Split 父单全被算成「超时未发」，
|
||||
// 全库未发 Split 单占比极高 —— 会让页面变成上万条的垃圾列表。
|
||||
// ⚠️ 与 mkhBomService 的差异：那边是「预警今天要发的货」，Split 父单不带真实
|
||||
// 发货需求，被算进去也无害；这边是「考核仓库时效」，误算就要背锅，必须排除。
|
||||
const EXCLUDED_STATUS_SQL = `ISNULL(o.status, N'') NOT IN (N'Cancelled', N'Merged', N'Split')`;
|
||||
|
||||
const WAREHOUSE_CACHE_TTL_MS = 60 * 60 * 1000;
|
||||
let warehouseCache = { at: 0, rows: [] };
|
||||
|
||||
function toNumber(value) {
|
||||
const n = Number(value);
|
||||
return Number.isFinite(n) ? n : 0;
|
||||
}
|
||||
|
||||
function pad2(n) {
|
||||
return String(n).padStart(2, '0');
|
||||
}
|
||||
|
||||
/**
|
||||
* 用「关键词最长匹配」把仓库名归到主仓。
|
||||
* @returns {object|null} CENTERS 里的元素；无法归属返回 null
|
||||
*/
|
||||
function resolveCenter(warehouseName) {
|
||||
if (!warehouseName) return null;
|
||||
for (const item of SORTED_KEYWORDS) {
|
||||
if (warehouseName.includes(item.kw)) return item.center;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* 拉取仓库表并建立「主仓 → wms_co_id 列表」映射。
|
||||
* 缓存 1 小时；仓库表变更不频繁，且新增子仓会自动被关键词捞到。
|
||||
*/
|
||||
async function loadCenterWarehouseMap(force = false) {
|
||||
const fresh = Date.now() - warehouseCache.at < WAREHOUSE_CACHE_TTL_MS;
|
||||
if (!force && fresh && warehouseCache.rows.length) {
|
||||
return warehouseCache.rows;
|
||||
}
|
||||
// ⚠️ cloudDatabase.query() 直接返回 recordset 数组，不是 {recordset} 对象
|
||||
const rows = (await cloudDatabase.query(
|
||||
`SELECT Id, name, wms_co_id
|
||||
FROM dbo.jst_warehouseInfo`,
|
||||
{},
|
||||
{ requestTimeout: 60000 }
|
||||
)) || [];
|
||||
const byCenter = new Map(CENTERS.map((c) => [c.key, []]));
|
||||
const unmatched = [];
|
||||
for (const row of rows) {
|
||||
const center = resolveCenter(String(row.name || ''));
|
||||
if (center && byCenter.has(center.key)) {
|
||||
byCenter.get(center.key).push({
|
||||
wmsCoId: Number(row.wms_co_id),
|
||||
warehouseId: Number(row.Id),
|
||||
name: String(row.name || ''),
|
||||
});
|
||||
} else {
|
||||
unmatched.push({ wmsCoId: Number(row.wms_co_id), name: String(row.name || '') });
|
||||
}
|
||||
}
|
||||
const list = CENTERS.map((c) => ({
|
||||
key: c.key,
|
||||
name: c.name,
|
||||
placeholder: Boolean(c.placeholder),
|
||||
warehouses: byCenter.get(c.key) || [],
|
||||
}));
|
||||
warehouseCache = { at: Date.now(), rows: list, unmatchedCount: unmatched.length };
|
||||
return list;
|
||||
}
|
||||
|
||||
function clearWarehouseCache() {
|
||||
warehouseCache = { at: 0, rows: [] };
|
||||
}
|
||||
|
||||
/**
|
||||
* 计算「当前已生效」的核验轮次。
|
||||
*
|
||||
* 12:00 之前 → **未到核验时间，返回 null**。
|
||||
* 业务明确要求（2026-10-20 确认）：12:00 之前不做核验，
|
||||
* 前端显示「未到核验时间」，**不要回填昨天的数据** ——
|
||||
* 昨天已结算的结果留到昨天，拿到今天看容易被当成今天的超时。
|
||||
* 12:00~15:59 → 用 12:00 轮（窗口 00:00~07:00）
|
||||
* 16:00 之后 → 用 16:00 轮（窗口 00:00~16:00，覆盖范围更大）
|
||||
*
|
||||
* @param {Date} now 以**东八区本地时间**为准的 Date（生产/本地机器均为东八区）
|
||||
* @returns {object|null} null 表示当前不在任何核验时段内
|
||||
*/
|
||||
function resolveActiveRound(now = new Date()) {
|
||||
const hour = now.getHours();
|
||||
const minute = now.getMinutes();
|
||||
const minutes = hour * 60 + minute;
|
||||
let active = null;
|
||||
for (const round of ROUNDS) {
|
||||
if (minutes >= round.cutoffHour * 60) active = round;
|
||||
}
|
||||
|
||||
// 12:00 前：首轮核验还没开始，不做判定
|
||||
if (!active) return null;
|
||||
|
||||
const y = now.getFullYear();
|
||||
const m = pad2(now.getMonth() + 1);
|
||||
const d = pad2(now.getDate());
|
||||
return {
|
||||
...active,
|
||||
deadline: `${y}-${m}-${d} ${pad2(active.cutoffHour)}:00:00`,
|
||||
windowStart: `${y}-${m}-${d} 00:00:00`,
|
||||
windowEnd: `${y}-${m}-${d} ${pad2(active.windowEndHour)}:00:00`,
|
||||
date: `${y}-${m}-${d}`,
|
||||
settled: false,
|
||||
isPreviousDay: false,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* 取「当天两轮」的完整描述（页面顶部展示用），不论是否已到时间。
|
||||
*/
|
||||
function describeRounds(now = new Date()) {
|
||||
const y = now.getFullYear();
|
||||
const m = pad2(now.getMonth() + 1);
|
||||
const d = pad2(now.getDate());
|
||||
const date = `${y}-${m}-${d}`;
|
||||
return ROUNDS.map((r) => ({
|
||||
key: r.key,
|
||||
label: r.label,
|
||||
date,
|
||||
deadline: `${date} ${pad2(r.cutoffHour)}:00:00`,
|
||||
windowStart: `${date} 00:00:00`,
|
||||
windowEnd: `${date} ${pad2(r.windowEndHour)}:00:00`,
|
||||
active: now.getHours() * 60 + now.getMinutes() >= r.cutoffHour * 60,
|
||||
}));
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
CENTERS,
|
||||
ROUNDS,
|
||||
resolveCenter,
|
||||
loadCenterWarehouseMap,
|
||||
clearWarehouseCache,
|
||||
resolveActiveRound,
|
||||
describeRounds,
|
||||
EXCLUDED_STATUS_SQL,
|
||||
toNumber,
|
||||
};
|
||||
@ -1,528 +0,0 @@
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* 仓储中心 24 小时发货时效 —— 取数/聚合服务（2026-10-20 新增）
|
||||
* ────────────────────────────────────────────────────────────────────────────
|
||||
* 配置与口径定义见 warehouseShipTimelinessRegistry.js（主仓关键词、轮次、时区说明）。
|
||||
*
|
||||
* ── 一次请求做几件事 ──────────────────────────────────────────────────────
|
||||
* ① 读仓库表 → 主仓 → wms_co_id 集合（缓存 1h）
|
||||
* ② 一次 SQL 同时取「超时未发」和「已超时已发」两类，按 wms_co_id 分组
|
||||
* ③ 归并到主仓，返回每仓的 count / orderAmount，以及全量超时明细
|
||||
*
|
||||
* ── SQL 设计要点（踩过的坑）───────────────────────────────────────────────
|
||||
* · 两张订单表**店铺互斥**，用 UNION ALL 合并后一次性分组，不要分别查再在
|
||||
* Node 侧合并 —— 两趟扫描在 rpt 视图上代价翻倍。
|
||||
* · `wms_co_id IN (...)` 直接内联仓库 ID（都是整数，无注入风险），因为仓库
|
||||
* 集合动态生成，用参数化会引入可变数量的 @p0..@pN，反而难维护。
|
||||
* · **不要在 ORDER BY 里对聚合列做算术**（见 MEMORY：会触发灾难计划）。
|
||||
* 这里 SQL 只 GROUP BY 取原始计数/金额，排序与派生字段全在 Node 侧算。
|
||||
* · 时间比较一律用**字面量字符串**（形如 '2026-10-20 16:00:00'），由
|
||||
* resolveActiveRound 在东八区算出；不用 GETDATE() 做相对偏移，避免
|
||||
* 数据库与应用的时区假设不一致。
|
||||
* · 明细行带 `TOP (@limit)`，`@limit` 走参数化，避免界面一次拉几万行。
|
||||
*/
|
||||
|
||||
const cloudDatabase = require('../config/cloudDatabase');
|
||||
const registry = require('./warehouseShipTimelinessRegistry');
|
||||
|
||||
const { CENTERS, EXCLUDED_STATUS_SQL, toNumber } = registry;
|
||||
|
||||
// 明细上限：只用于页面展示，超出部分用 truncated 标记提示
|
||||
const DEFAULT_DETAIL_LIMIT = 500;
|
||||
const MAX_DETAIL_LIMIT = 2000;
|
||||
|
||||
/**
|
||||
* 把 UTC Date / 字符串 统一格式化成 'YYYY-MM-DD HH:mm:ss'（按服务器本地时区）。
|
||||
* mssql 驱动默认把 datetime 解析为 UTC 语义的 Date，这里只做展示，统一成
|
||||
* 与库内一致的东八区墙钟时间。
|
||||
*/
|
||||
function formatDateTime(value) {
|
||||
if (!value) return '';
|
||||
if (typeof value === 'string') return value.replace('T', ' ').slice(0, 19);
|
||||
const d = value instanceof Date ? value : new Date(value);
|
||||
if (Number.isNaN(d.getTime())) return '';
|
||||
const pad = (n) => String(n).padStart(2, '0');
|
||||
return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} `
|
||||
+ `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
|
||||
}
|
||||
|
||||
/** 两个 'YYYY-MM-DD HH:mm:ss' 相差多少分钟（四舍五入） */
|
||||
function diffMinutes(fromText, toText) {
|
||||
const a = new Date(String(fromText).replace(' ', 'T')).getTime();
|
||||
const b = new Date(String(toText).replace(' ', 'T')).getTime();
|
||||
if (!Number.isFinite(a) || !Number.isFinite(b)) return 0;
|
||||
return Math.round((b - a) / 60000);
|
||||
}
|
||||
|
||||
/**
|
||||
* 构造两表合并的子查询。
|
||||
*
|
||||
* 🔥 三条必须同时满足（2026-10-20 实测踩坑）：
|
||||
* ① `order_date >= @windowStart` —— **必须有下界**。只写 `<= @deadline` 会把
|
||||
* 一年前创建、至今未发的历史单全捞进来（实测 13,553 条，最早 2025-09-01）。
|
||||
* ② `order_date <= @deadline` —— 上界：截止时刻后创建的订单不参与本轮考核。
|
||||
* ③ Split 已在 EXCLUDED_STATUS_SQL 里排掉（拆单父单永不发货）。
|
||||
*
|
||||
* @param {number[]} wmsIds 主仓下所有 wms_co_id
|
||||
* @param {string} deadline 截止时刻字面量
|
||||
* @param {'pending'|'shippedLate'} mode 取哪一类
|
||||
*/
|
||||
function buildUnionSql(wmsIds, deadline, mode) {
|
||||
const idList = wmsIds.join(',');
|
||||
// pending：未发货且窗口内已创建 → 超时未发
|
||||
// shippedLate：已发货但发货时间晚于截止时刻 → 已超时已发
|
||||
const cond = mode === 'pending'
|
||||
? `o.send_date IS NULL`
|
||||
: `o.send_date IS NOT NULL AND o.send_date > @deadline`;
|
||||
const branch = (table) => `
|
||||
SELECT N'${table}' AS src, o.o_id, o.so_id, o.shop_name, o.shop_id,
|
||||
o.order_date, o.send_date, o.status, o.shop_status,
|
||||
o.wms_co_id, o.pay_amount, o.labels
|
||||
FROM dbo.${table} o
|
||||
WHERE o.wms_co_id IN (${idList})
|
||||
AND o.order_date >= @windowStart
|
||||
AND o.order_date <= @deadline
|
||||
AND ${cond}
|
||||
AND ${EXCLUDED_STATUS_SQL}`;
|
||||
return `${branch('jst_Orders')}
|
||||
UNION ALL${branch('jst_qmcust_orderlist')}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* 单个主仓的仓库 ID 集合 → 逗号串（用于按主仓分桶时拼 IN 条件）
|
||||
*/
|
||||
function joinIds(ids) {
|
||||
return ids.join(',');
|
||||
}
|
||||
|
||||
/**
|
||||
* 主入口：计算某一天、某一轮次的仓储中心发货时效。
|
||||
*
|
||||
* @param {object} options
|
||||
* @param {string} [options.round] 'NOON' | 'AFTERNOON'，不传则按当前时刻自动判定
|
||||
* @param {Date} [options.now] 仅测试用
|
||||
* @param {number} [options.limit] 明细条数上限
|
||||
* @returns {Promise<object>}
|
||||
*/
|
||||
async function getShipTimeliness(options = {}) {
|
||||
const now = options.now instanceof Date ? options.now : new Date();
|
||||
const limit = Math.min(
|
||||
Math.max(Number(options.limit) || DEFAULT_DETAIL_LIMIT, 1),
|
||||
MAX_DETAIL_LIMIT
|
||||
);
|
||||
|
||||
// ① 主仓 → 仓库映射
|
||||
const centerList = await registry.loadCenterWarehouseMap();
|
||||
const pad2 = (n) => String(n).padStart(2, '0');
|
||||
|
||||
// ② 决定本轮截止时刻
|
||||
const rounds = registry.describeRounds(now);
|
||||
let round = null;
|
||||
if (options.round) {
|
||||
const target = registry.ROUNDS.find((r) => r.key === String(options.round).toUpperCase());
|
||||
if (!target) {
|
||||
const err = new Error(`未知的核验轮次: ${options.round}`);
|
||||
err.statusCode = 400;
|
||||
throw err;
|
||||
}
|
||||
const pad = (n) => String(n).padStart(2, '0');
|
||||
const date = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
|
||||
round = {
|
||||
...target,
|
||||
date,
|
||||
deadline: `${date} ${pad(target.cutoffHour)}:00:00`,
|
||||
windowStart: `${date} 00:00:00`,
|
||||
windowEnd: `${date} ${pad(target.windowEndHour)}:00:00`,
|
||||
active: now.getHours() * 60 + now.getMinutes() >= target.cutoffHour * 60,
|
||||
};
|
||||
} else {
|
||||
round = registry.resolveActiveRound(now);
|
||||
}
|
||||
|
||||
// 🔥 12:00 前没有任何轮次生效（业务口径：12:00 才开始第一轮核验）。
|
||||
// 这里**直接返回「未到核验时间」**，既不查库、也不回填昨天 ——
|
||||
// 让业务清楚知道「现在还没到看数据的时候」，而不是拿旧数字去对仓库。
|
||||
if (!round) {
|
||||
const centerList = await registry.loadCenterWarehouseMap();
|
||||
const nextRound = rounds.find((r) => r.cutoffHour === 12) || rounds[0];
|
||||
return {
|
||||
generatedAt: formatDateTime(now),
|
||||
date: `${now.getFullYear()}-${pad2(now.getMonth() + 1)}-${pad2(now.getDate())}`,
|
||||
round: null,
|
||||
notStarted: true,
|
||||
isPreviousDay: false,
|
||||
rounds,
|
||||
nextRoundAt: nextRound ? nextRound.deadline : '',
|
||||
deadline: '',
|
||||
window: null,
|
||||
summary: emptySummary(),
|
||||
centers: buildEmptyCenters(centerList),
|
||||
orders: [],
|
||||
truncated: false,
|
||||
detailLimit: limit,
|
||||
detailDegraded: false,
|
||||
freshness: null,
|
||||
note: '今日 12:00 首轮核验开始后才展示超时数据',
|
||||
};
|
||||
}
|
||||
|
||||
// 没有归属任何主仓的仓库不用查
|
||||
const allWmsIds = [...new Set(
|
||||
centerList.flatMap((c) => c.warehouses.map((w) => w.wmsCoId)).filter((n) => Number.isFinite(n))
|
||||
)];
|
||||
|
||||
if (!allWmsIds.length) {
|
||||
return {
|
||||
generatedAt: formatDateTime(now),
|
||||
date: round.date,
|
||||
round: { key: round.key, label: round.label },
|
||||
isPreviousDay: Boolean(round.isPreviousDay),
|
||||
rounds,
|
||||
deadline: round.deadline,
|
||||
window: { start: round.windowStart, end: round.windowEnd },
|
||||
summary: emptySummary(),
|
||||
centers: buildEmptyCenters(centerList),
|
||||
orders: [],
|
||||
truncated: false,
|
||||
detailLimit: limit,
|
||||
note: '仓库表中未匹配到任何目标主仓，请检查仓库命名',
|
||||
};
|
||||
}
|
||||
|
||||
// ③ 一趟 SQL 取全量分组结果。原实现拆成「超时未发 / 已超时已发 / 窗口总数」
|
||||
// 三条 SQL，在 rpt 视图上三趟全表扫描实测 213 秒；合并成一趟后按
|
||||
// `src + 是否超时` 打标记再 GROUP BY，只扫一次两表。
|
||||
//
|
||||
// 分组维度：主仓 不直接在 SQL 里 GROUP（仓库→主仓的映射在 Node 侧缓存里），
|
||||
// 所以按 wms_co_id 分组，回 Node 侧累加到主仓。
|
||||
//
|
||||
// 🔥 「算不算已发货」的三态判定（2026-10-20 实测新增）：
|
||||
// 上游 `send_date` 回写**明显滞后** —— 实测 10-20 当天 700 单里只有 100 单
|
||||
// 有 send_date，且都集中在 08:16~08:44（刚回写的那几单）。若只看 send_date，
|
||||
// 中午 12:00 核验时当天早上的单会**全部被判超时**，页面毫无价值。
|
||||
// 因此引入出库表 `rpt.jst_salesOutboundInfo` 作为佐证：
|
||||
// · 判为「已发」= send_date 有值 **或** 出库表能查到该 o_id
|
||||
// · 判为「按时」= send_date <= 截止 **或** 出库行 io_date <= 截止
|
||||
// ⚠️ 出库表同样滞后（每天 04:00 起才有数据，当天往往 0 行，次日凌晨灌），
|
||||
// 所以它只能**减少误判**（把「已发的判成没发」纠正过来），
|
||||
// 不能凭空补出「没发的单已经发了」。最终仍可能有误报，故返回值里带
|
||||
// `freshness` 让前端明示「数据可能滞后」。
|
||||
// ⚠️ 出库表 `qty` 列全表恒 0（见 MEMORY），判断有无出库**只看行数 / io_date**。
|
||||
//
|
||||
// 每条订单归属哪一类（互斥）：
|
||||
// pending —— 两源都查不到发货痕迹 → 超时未发
|
||||
// shippedLate —— 有发货痕迹但发货时间 > 截止 → 已发但超时
|
||||
// onTime —— 发货时间 <= 截止 → 按时已发
|
||||
// ⚠️ OUTER APPLY 里只取 `io_date`，用「io_date 是否为 NULL」判断出库表有无命中。
|
||||
// 别在外面引用 `ob.o_id` —— APPLY 子查询只 SELECT 了 io_date，引用不存在的列
|
||||
// 会报 `Invalid column name 'o_id'`（2026-10-20 已踩）。
|
||||
//
|
||||
// ⚡ 性能关键（2026-10-20 实测）：
|
||||
// · 原实现「汇总 SQL + 明细 SQL」各扫一遍窗口，合计 108 秒；
|
||||
// · 窗口内订单只有几百条（实测 420 条），所以改成**一趟取回全部窗口订单明细**，
|
||||
// 汇总与明细都在 Node 里算 —— 少一次大表扫描。
|
||||
// · 返回列加上 pay_amount / status，供 Node 侧分桶。
|
||||
//
|
||||
// 🔥🔥 两表**不能 UNION ALL 成一条 SQL**（2026-10-20 实测，这是本文件最大的坑）：
|
||||
// · `jst_qmcust_orderlist` 是**宽视图**（上百列），拆开单独跑很快，但一旦参与
|
||||
// UNION ALL + 派生表 + OUTER APPLY 的嵌套，优化器会放弃谓词下推，
|
||||
// 变成先物化整表再过滤 —— 实测单条 SQL 跑 200~320 秒。
|
||||
// · 两表**分别查、Node 侧合并**：jst_Orders 5.5 秒、jst_qmcust_orderlist 35 秒，
|
||||
// 合计约 40 秒，比合并版快 5~8 倍。
|
||||
// · 两表店铺完全互斥（京东/拼多多/抖音/得物/唯品会 vs 天猫/淘宝/1688），
|
||||
// o_id 不会有交集，直接拼接即可，不需要再按 o_id 去重（仍保留一次去重兜底）。
|
||||
//
|
||||
// 🔥 `jst_qmcust_orderlist` 单表也有 35 秒，而同样条件的 `jst_Orders` 只要 2 秒。
|
||||
// 曾尝试把它的窗口过滤换成 `created`（实测快 10 倍），但**已证伪，不能用**：
|
||||
// · 2026-10-20 实测 2,581 行里，`order_date` 与 `created` 完全相等的只有 4 行，
|
||||
// 相差 >1 小时的有 412 行，最大差 24.7 天，**198 行甚至跨日**；
|
||||
// · 典型形态：`order_date=10-18 23:58` 而 `created=10-19 04:00:08` ——
|
||||
// 上游每天凌晨 4 点批量补录，`created` 是**灌库时间**不是下单时间；
|
||||
// · 同一窗口下 `created` 比 `order_date` 多命中 30 单（全是补录单）。
|
||||
// 业务口径是「按**订单创建时间**算是否及时」，只有 `order_date` 是对的。
|
||||
// 所以：**两表都用 `order_date`**，性能只能靠「两表分开查 + Node 侧合并」。
|
||||
// ⚠️ 换回 `created` 之前必须先跑 `.workbuddy/tmp/probe-od-vs-created.cjs` 复测。
|
||||
const windowBranch = (table) => `
|
||||
SELECT N'${table}' AS src,
|
||||
o.wms_co_id, o.o_id, o.so_id, o.shop_name, o.order_date,
|
||||
o.send_date, o.status, o.shop_status, o.pay_amount, o.labels,
|
||||
ob.io_date AS ob_io_date
|
||||
FROM dbo.${table} o
|
||||
OUTER APPLY (
|
||||
SELECT TOP 1 s.io_date
|
||||
FROM dbo.jst_salesOutboundInfo s
|
||||
WHERE s.o_id = o.o_id
|
||||
ORDER BY s.io_date ASC
|
||||
) ob
|
||||
WHERE o.wms_co_id IN (${joinIds(allWmsIds)})
|
||||
AND o.order_date >= @windowStart
|
||||
AND o.order_date <= @deadline
|
||||
AND ${EXCLUDED_STATUS_SQL}`;
|
||||
|
||||
const params = { deadline: round.deadline, windowStart: round.windowStart };
|
||||
// ⚠️ 超时给足：qmcust 单表实测 35~80 秒（视图谓词下推较差），
|
||||
// 不能按 jst_Orders 的 5 秒去设，否则会被误杀成 500。
|
||||
const queryOpts = { requestTimeout: 300000, connectRequestTimeoutMs: 320000 };
|
||||
|
||||
// 两表并行查（互不依赖），Node 侧合并
|
||||
const [ordersRows, qmcustRows] = await Promise.allSettled([
|
||||
cloudDatabase.query(windowBranch('jst_Orders'), params, queryOpts),
|
||||
cloudDatabase.query(windowBranch('jst_qmcust_orderlist'), params, queryOpts),
|
||||
]);
|
||||
|
||||
// 🔥 用 allSettled 而不是 all：一张表超时/报错时，另一张表的数据仍然可用，
|
||||
// 否则整页变空白。降级情况记录在 detailDegraded + note 里。
|
||||
const mergeWarnings = [];
|
||||
const windowRows = [];
|
||||
if (ordersRows.status === 'fulfilled') {
|
||||
windowRows.push(...(ordersRows.value || []));
|
||||
} else {
|
||||
mergeWarnings.push(`jst_Orders 查询失败：${ordersRows.reason?.message || '未知错误'}`);
|
||||
}
|
||||
if (qmcustRows.status === 'fulfilled') {
|
||||
windowRows.push(...(qmcustRows.value || []));
|
||||
} else {
|
||||
mergeWarnings.push(`jst_qmcust_orderlist 查询失败：${qmcustRows.reason?.message || '未知错误'}`);
|
||||
}
|
||||
if (!windowRows.length && mergeWarnings.length) {
|
||||
// 两表全挂 —— 这才是真正的失败，直接抛给上层
|
||||
const err = new Error(mergeWarnings.join('；'));
|
||||
err.statusCode = 502;
|
||||
throw err;
|
||||
}
|
||||
|
||||
// ④ 数据新鲜度：出库表最新 io_date。
|
||||
// ⚠️ 只用于「提示用户数据可能滞后」，不参与超时判定。
|
||||
// 两个源都滞后时（出库表当天 0 行 + send_date 昨天就停了），说明上游还没灌数，
|
||||
// 此时「超时未发」的准确性无法保证 —— 前端必须显式告警，不能让业务拿着
|
||||
// 一份假数据去考核仓库。
|
||||
const freshness = await loadShipFreshness(round);
|
||||
|
||||
// ⑤ 三态归类（在 Node 侧做，SQL 只负责取数）
|
||||
const wmsToCenter = new Map();
|
||||
for (const c of centerList) {
|
||||
for (const w of c.warehouses) wmsToCenter.set(w.wmsCoId, c.key);
|
||||
}
|
||||
|
||||
const acc = new Map(centerList.map((c) => [c.key, {
|
||||
pendingCount: 0,
|
||||
pendingAmount: 0,
|
||||
shippedLateCount: 0,
|
||||
onTimeCount: 0,
|
||||
}]));
|
||||
|
||||
const pendingRows = [];
|
||||
// 两表店铺互斥、o_id 理论不重叠，但历史上出现过同一 o_id 被两边都收录的情况，
|
||||
// 按 `${src}-${o_id}` 去重（跨表同 o_id 也算重复，取先到的 jst_Orders）。
|
||||
const seenKey = new Set();
|
||||
for (const row of windowRows || []) {
|
||||
const bucket = acc.get(wmsToCenter.get(Number(row.wms_co_id)));
|
||||
if (!bucket) continue;
|
||||
const dedupeKey = String(row.o_id || '');
|
||||
if (dedupeKey) {
|
||||
if (seenKey.has(dedupeKey)) continue;
|
||||
seenKey.add(dedupeKey);
|
||||
}
|
||||
const kind = bucketOf(row, round.deadline);
|
||||
if (kind === 'pending') {
|
||||
bucket.pendingCount += 1;
|
||||
bucket.pendingAmount += toNumber(row.pay_amount);
|
||||
pendingRows.push(row);
|
||||
} else if (kind === 'shippedLate') {
|
||||
bucket.shippedLateCount += 1;
|
||||
} else {
|
||||
bucket.onTimeCount += 1;
|
||||
}
|
||||
}
|
||||
|
||||
// 明细：只要「超时未发」，最早创建的最急，排前面
|
||||
// 用 formatDateTime 转成 'YYYY-MM-DD HH:mm:ss' 再比字符串 —— 字典序与时间序一致，
|
||||
// 且不受 mssql 驱动把 datetime 解析成 UTC Date 的影响（见文件头时区说明）。
|
||||
pendingRows.sort((a, b) => {
|
||||
const x = formatDateTime(a.order_date);
|
||||
const y = formatDateTime(b.order_date);
|
||||
if (x < y) return -1;
|
||||
if (x > y) return 1;
|
||||
return 0;
|
||||
});
|
||||
const detailRows = pendingRows.slice(0, limit);
|
||||
|
||||
const centers = centerList.map((c) => {
|
||||
const b = acc.get(c.key) || { pendingCount: 0, pendingAmount: 0, shippedLateCount: 0, onTimeCount: 0 };
|
||||
const totalCount = b.pendingCount + b.shippedLateCount + b.onTimeCount;
|
||||
return {
|
||||
key: c.key,
|
||||
name: c.name,
|
||||
placeholder: c.placeholder,
|
||||
warehouseCount: c.warehouses.length,
|
||||
warehouses: c.warehouses.map((w) => ({ wmsCoId: w.wmsCoId, name: w.name })),
|
||||
// 列表主展示：超时未发
|
||||
overdueUnshipped: b.pendingCount,
|
||||
overdueUnshippedAmount: Math.round(b.pendingAmount * 100) / 100,
|
||||
// 辅助信息
|
||||
overdueShipped: b.shippedLateCount,
|
||||
windowOrderCount: totalCount,
|
||||
onTimeRate: totalCount > 0
|
||||
? Math.round((b.onTimeCount / totalCount) * 1000) / 10
|
||||
: null,
|
||||
};
|
||||
});
|
||||
|
||||
const orders = (detailRows || []).map((r) => {
|
||||
const orderDate = formatDateTime(r.order_date);
|
||||
const center = centerList.find((c) => c.key === wmsToCenter.get(Number(r.wms_co_id)));
|
||||
const warehouse = center && center.warehouses.find((w) => w.wmsCoId === Number(r.wms_co_id));
|
||||
return {
|
||||
oId: String(r.o_id || ''),
|
||||
soId: String(r.so_id || ''),
|
||||
source: r.src === 'jst_qmcust_orderlist' ? 'qmcust' : 'orders',
|
||||
shopName: String(r.shop_name || ''),
|
||||
orderDate,
|
||||
sendDate: formatDateTime(r.send_date),
|
||||
status: String(r.status || ''),
|
||||
shopStatus: String(r.shop_status || ''),
|
||||
wmsCoId: Number(r.wms_co_id),
|
||||
warehouseName: warehouse ? warehouse.name : '',
|
||||
centerKey: center ? center.key : '',
|
||||
centerName: center ? center.name : '',
|
||||
payAmount: toNumber(r.pay_amount),
|
||||
labels: String(r.labels || ''),
|
||||
// 相对截止时刻的超时时长（分钟）
|
||||
overdueMinutes: diffMinutes(orderDate, round.deadline),
|
||||
};
|
||||
});
|
||||
|
||||
const summary = centers.reduce((acc2, c) => {
|
||||
acc2.overdueUnshipped += c.overdueUnshipped;
|
||||
acc2.overdueShipped += c.overdueShipped;
|
||||
acc2.overdueUnshippedAmount += c.overdueUnshippedAmount;
|
||||
acc2.windowOrderCount += c.windowOrderCount;
|
||||
if (c.overdueUnshipped > 0) acc2.overdueCenterCount += 1;
|
||||
return acc2;
|
||||
}, emptySummary());
|
||||
summary.overdueUnshippedAmount = Math.round(summary.overdueUnshippedAmount * 100) / 100;
|
||||
// 按时率统一口径：按时 = 窗口内总数 - 超时未发 - 已发超时
|
||||
// （与各仓算法完全一致，避免两处各算一遍算出不同数字）
|
||||
summary.onTimeRate = summary.windowOrderCount > 0
|
||||
? Math.round(((summary.windowOrderCount - summary.overdueUnshipped - summary.overdueShipped)
|
||||
/ summary.windowOrderCount) * 1000) / 10
|
||||
: null;
|
||||
|
||||
const totalPending = summary.overdueUnshipped;
|
||||
|
||||
return {
|
||||
generatedAt: formatDateTime(now),
|
||||
date: round.date,
|
||||
// ⚠️ 前端要展示「核验 07:00 / 16:00 前」，必须把 windowEnd 一起带出去。
|
||||
// 早先只回了 key/label，前端拿不到 cutoff，页面就渲染成「核验 前」。
|
||||
round: {
|
||||
key: round.key,
|
||||
label: round.label,
|
||||
cutoffHour: round.cutoffHour,
|
||||
windowEnd: round.windowEnd,
|
||||
},
|
||||
// 12:00 前不会走到这里（见上方 notStarted 分支），留着兼容显式指定 round 的调用
|
||||
notStarted: false,
|
||||
isPreviousDay: false,
|
||||
rounds,
|
||||
deadline: round.deadline,
|
||||
window: { start: round.windowStart, end: round.windowEnd },
|
||||
summary,
|
||||
centers,
|
||||
orders,
|
||||
truncated: totalPending > orders.length,
|
||||
detailLimit: limit,
|
||||
// 任一张订单表查询失败 → 数字不完整，前端要显式告警（不能拿残缺数据考核仓库）
|
||||
detailDegraded: mergeWarnings.length > 0,
|
||||
freshness,
|
||||
note: mergeWarnings.length ? `${mergeWarnings.join('；')}（数据不完整）` : '',
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* 计算发货数据新鲜度。
|
||||
*
|
||||
* 🔥 业务上这是**最容易被误判成系统 bug** 的地方（见 MEMORY 入口 1）：
|
||||
* 上游 send_date / 出库表都滞后，「超时未发」数量会虚高。
|
||||
* 这里只如实报告滞后程度，不做任何「猜测补数」。
|
||||
*
|
||||
* @returns {Promise<{outboundMaxIo: string, sendDateMax: string, stale: boolean, hint: string}>}
|
||||
*/
|
||||
async function loadShipFreshness(round) {
|
||||
try {
|
||||
const rows = await cloudDatabase.query(
|
||||
`SELECT CONVERT(varchar(19), MAX(io_date), 120) AS outbound_max
|
||||
FROM dbo.jst_salesOutboundInfo`,
|
||||
{},
|
||||
{ requestTimeout: 60000 }
|
||||
);
|
||||
const outboundMaxIo = rows && rows[0] ? String(rows[0].outbound_max || '') : '';
|
||||
// 出库表最新一行早于今天 → 当天发货数据尚未灌入
|
||||
const outboundStale = !outboundMaxIo || outboundMaxIo.slice(0, 10) < round.date;
|
||||
return {
|
||||
outboundMaxIo,
|
||||
stale: outboundStale,
|
||||
hint: outboundStale
|
||||
? `出库表最新数据 ${outboundMaxIo || '暂无'}，今天（${round.date}）的发货记录尚未灌入，`
|
||||
+ '「超时未发」可能偏多，请以仓库实际发货情况为准'
|
||||
: '',
|
||||
};
|
||||
} catch (e) {
|
||||
// 新鲜度查询失败绝不能影响主结果
|
||||
console.warn('[ShipTimeliness] 取新鲜度失败:', e.message);
|
||||
return { outboundMaxIo: '', stale: true, hint: '发货数据新鲜度未知' };
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 单条订单的三态归类（与服务层口径一一对应）：
|
||||
* pending —— send_date 为空 **且** 出库表无命中 → 超时未发
|
||||
* shippedLate —— 有发货痕迹但发货时间晚于截止 → 已发但超时
|
||||
* onTime —— 发货时间不晚于截止 → 按时已发
|
||||
*
|
||||
* 「发货时间」取值优先级：send_date 有值就用 send_date，否则用出库表 io_date。
|
||||
* （两个都滞后时以 send_date 为准，因为它是订单系统自己的回写，语义最直接。）
|
||||
*
|
||||
* @param {object} row 含 send_date / ob_io_date
|
||||
* @param {string} deadline 'YYYY-MM-DD HH:mm:ss'
|
||||
*/
|
||||
function bucketOf(row, deadline) {
|
||||
const sendDate = formatDateTime(row.send_date);
|
||||
const ioDate = formatDateTime(row.ob_io_date);
|
||||
if (!sendDate && !ioDate) return 'pending';
|
||||
const shippedAt = sendDate || ioDate;
|
||||
return shippedAt > deadline ? 'shippedLate' : 'onTime';
|
||||
}
|
||||
|
||||
function emptySummary() {
|
||||
return {
|
||||
overdueUnshipped: 0,
|
||||
overdueShipped: 0,
|
||||
overdueUnshippedAmount: 0,
|
||||
overdueCenterCount: 0,
|
||||
windowOrderCount: 0,
|
||||
onTimeRate: null,
|
||||
};
|
||||
}
|
||||
|
||||
function buildEmptyCenters(centerList) {
|
||||
return centerList.map((c) => ({
|
||||
key: c.key,
|
||||
name: c.name,
|
||||
placeholder: c.placeholder,
|
||||
warehouseCount: c.warehouses.length,
|
||||
warehouses: c.warehouses.map((w) => ({ wmsCoId: w.wmsCoId, name: w.name })),
|
||||
overdueUnshipped: 0,
|
||||
overdueUnshippedAmount: 0,
|
||||
overdueShipped: 0,
|
||||
windowOrderCount: 0,
|
||||
onTimeRate: null,
|
||||
}));
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
getShipTimeliness,
|
||||
DEFAULT_DETAIL_LIMIT,
|
||||
MAX_DETAIL_LIMIT,
|
||||
};
|
||||
@ -525,74 +525,6 @@ test('replenish index: hourly box/pallet stock surfaces same-day inbound (⑦-d)
|
||||
}
|
||||
});
|
||||
|
||||
// ⑦-e 成品库存多仓合并（2026-10-17）：
|
||||
// 实物搬到「简尚-横林二仓品牌仓」(16132681) 时，归属仓 (15870495) 为 0，
|
||||
// 只查归属仓会把有货的成品算成 0（本次 5 个误报缺货 + 2 个误报预警）。
|
||||
test('replenish index: sums stock across brand warehouse whitelist (⑦-e)', async () => {
|
||||
const cloudDatabase = require('../src/config/cloudDatabase');
|
||||
const svc = require('../src/services/mkhBomService');
|
||||
const originalQuery = cloudDatabase.query;
|
||||
const originalGetPool = cloudDatabase.getPool;
|
||||
const captured = [];
|
||||
|
||||
cloudDatabase.query = async (sql) => {
|
||||
captured.push(sql);
|
||||
if (sql.includes('jst_packInventoryInfo')) {
|
||||
// 箱表：同样的「老仓 0 / 新仓 10」格局
|
||||
return [{ skuId: 'MKHDNZ0409260600788', qty: 10 }];
|
||||
}
|
||||
if (sql.includes('jst_inventoryInfo')) {
|
||||
// 关键：SUM 之后返回的是**多仓合计**。旧口径只查单仓时这里拿不到这笔货。
|
||||
return [{ skuId: 'MKHDNZ0409260600788', qty: 10 }];
|
||||
}
|
||||
if (sql.includes('pm_stockMonitor')) {
|
||||
return [{
|
||||
skuId: 'MKHDNZ0409260600788',
|
||||
fifteenAvgSale: 1,
|
||||
monitorStock: 0,
|
||||
safetyDays: 3,
|
||||
suggestStock: 0,
|
||||
monitorDate: new Date('2026-10-17T00:00:00Z'),
|
||||
}];
|
||||
}
|
||||
if (sql.includes('jst_salesOutboundInfo') || sql.includes('jst_qmcust_salesoutbound')) return [];
|
||||
if (sql.includes('jst_qmcust_orderlist')) return [];
|
||||
return [];
|
||||
};
|
||||
cloudDatabase.getPool = async () => ({
|
||||
request: () => ({ input() {}, query: async () => ({ recordset: [] }) }),
|
||||
});
|
||||
|
||||
try {
|
||||
const index = await svc._private.loadReplenishIndex();
|
||||
const row = index.bySku.get('MKHDNZ0409260600788');
|
||||
assert.equal(row.stock, 10, '多仓求和后必须看到新仓的 10 件，不能是 0');
|
||||
|
||||
// SQL 层必须真的按白名单多仓取数，而不是退回单仓
|
||||
const invSql = captured.find((s) => s.includes('jst_inventoryInfo'));
|
||||
assert.ok(invSql.includes('IN (15870495,16132681)'),
|
||||
`实时库存必须按仓白名单取数，实际: ${invSql}`);
|
||||
assert.ok(invSql.includes('GROUP BY') && invSql.includes('SUM('),
|
||||
'实时库存必须多仓 SUM + GROUP BY（旧版是 ORDER BY updateTime DESC 取首条）');
|
||||
const packSql = captured.find((s) => s.includes('jst_packInventoryInfo'));
|
||||
assert.ok(packSql.includes('IN (15870495,16132681)'),
|
||||
`箱表必须按同一份仓白名单取数，实际: ${packSql}`);
|
||||
} finally {
|
||||
cloudDatabase.query = originalQuery;
|
||||
cloudDatabase.getPool = originalGetPool;
|
||||
svc.clearMkhBomCache();
|
||||
}
|
||||
});
|
||||
|
||||
// 白名单常量本身要被导出（新增同类仓时改这一处即可）
|
||||
test('replenish index: brand warehouse whitelist contains main + Henglin No.2 brand warehouse', () => {
|
||||
const svc = require('../src/services/mkhBomService');
|
||||
const ids = svc._private.BRAND_WMS_CO_IDS;
|
||||
assert.ok(Array.isArray(ids), 'BRAND_WMS_CO_IDS 必须是数组');
|
||||
assert.ok(ids.includes(15870495), '必须含崔桥工厂品牌仓（归属主仓）');
|
||||
assert.ok(ids.includes(16132681), '必须含横林二仓品牌仓（2026-10-13 新增）');
|
||||
});
|
||||
|
||||
test('order index: reads both channel tables, merges and dedupes by o_id', async () => {
|
||||
const cloudDatabase = require('../src/config/cloudDatabase');
|
||||
const svc = require('../src/services/mkhBomService');
|
||||
|
||||
@ -116,48 +116,23 @@ test('fetchPickingBinSkuRows 按仓位×商品输出，等级与日销来自商
|
||||
// 商品销量按占用仓位数分摊（供求和），但等级依据的是未分摊的商品销量
|
||||
assert.ok(captured.sqlText.includes('/ NULLIF(sp.binCount, 0)'));
|
||||
assert.ok(captured.sqlText.includes('ISNULL(s.salesQty, 0) / @days AS DECIMAL(18, 4)'));
|
||||
// 统计范围固定为真实拣选仓位：pack_type=Bin 且 bin_group 为空；只统计有库存的行
|
||||
assert.ok(captured.sqlText.includes("p.pack_type = N'Bin'"));
|
||||
// 统计范围固定为拣选位：bin_group 为空；只统计有库存的行
|
||||
assert.ok(captured.sqlText.includes("ISNULL(p.bin_group, '') = ''"));
|
||||
assert.ok(captured.sqlText.includes('ISNULL(p.qty, 0) <> 0'));
|
||||
assert.ok(captured.sqlText.includes('HAVING ABS(SUM(CAST(b.binSkuQty AS DECIMAL(18, 2)))) > 0.0001'));
|
||||
});
|
||||
|
||||
test('fetchPickingBinSkuRows 只统计真实拣选仓位，排除 Pack 箱记录且不带类型参数', async () => {
|
||||
test('fetchPickingBinSkuRows 只统计拣选位，不带类型参数', async () => {
|
||||
let captured = null;
|
||||
const db = {
|
||||
query: async (sqlText, params) => { captured = { sqlText, params }; return []; },
|
||||
};
|
||||
await fetchPickingBinSkuRows(db, [101], { shipFrom: 'a', shipTo: 'b', days: 15 });
|
||||
// Pack 箱记录和存货位被排除，且不再有 binType IN (...) 的可变过滤
|
||||
assert.ok(captured.sqlText.includes("p.pack_type = N'Bin'"));
|
||||
// 存货位（bin_group=存货）被排除，且不再有 binType IN (...) 的可变过滤
|
||||
assert.ok(captured.sqlText.includes("ISNULL(p.bin_group, '') = ''"));
|
||||
assert.ok(!captured.sqlText.includes('b.binType IN'));
|
||||
assert.equal(captured.params.t0, undefined);
|
||||
assert.equal(captured.params.binTypes, undefined);
|
||||
// 多来源 union 后必须再按 仓库+商品 汇总，否则同一仓位行会被拆成多行
|
||||
assert.ok(captured.sqlText.includes('shipAgg AS ('));
|
||||
assert.ok(captured.sqlText.includes('LEFT JOIN shipAgg s'));
|
||||
assert.ok(!captured.sqlText.includes('LEFT JOIN ship s'));
|
||||
});
|
||||
|
||||
test('销量覆盖 4 个来源：线上普通行 + 组合装展开 + 全民客户普通行 + 全民客户组合装展开', async () => {
|
||||
let captured = null;
|
||||
const db = {
|
||||
query: async (sqlText, params) => { captured = { sqlText, params }; return []; },
|
||||
};
|
||||
await fetchPickingBinSkuRows(db, [101], { shipFrom: 'a', shipTo: 'b', days: 30 });
|
||||
|
||||
// ① 线上店铺订单普通行
|
||||
assert.ok(captured.sqlText.includes('FROM rpt.jst_OrderItem'), '缺少 jst_OrderItem 普通行分支');
|
||||
// ② 线上订单组合装行按映射表展开为子件
|
||||
assert.ok(captured.sqlText.includes('JOIN rpt.jst_comboProductItem'), '缺少组合装展开分支');
|
||||
assert.ok(captured.sqlText.includes("oi.sku_type = 'combine'"), '缺少组合装行识别条件');
|
||||
// ③ 全民客户（B2B 分销）渠道普通行，排除拆单父单 Split 与问题单
|
||||
assert.ok(captured.sqlText.includes('FROM rpt.jst_qmcust_orderlist_item'), '缺少 qmcust 分支');
|
||||
assert.ok(captured.sqlText.includes("'Split', 'Question'"), 'qmcust 未排除拆单父单/问题单');
|
||||
// 四个分支共用同一发货窗口
|
||||
assert.equal(captured.sqlText.split('o.send_date >= @shipFrom').length, 5);
|
||||
});
|
||||
|
||||
test('gradeKey 缺失时兜底为 zero', async () => {
|
||||
|
||||
@ -1,233 +0,0 @@
|
||||
/**
|
||||
* 仓储中心 24 小时发货时效 —— 口径回归测试（2026-10-20 新增）
|
||||
*
|
||||
* 这个功能最容易出错的是「口径」，不是 SQL 语法。本文件锁定四条关键语义：
|
||||
* ① 主仓归属用**关键词最长匹配** —— 「横林二仓品牌仓」不能被「横林二仓」抢走，
|
||||
* 否则品牌仓的订单会被重复计入两个仓；
|
||||
* ② 核验轮次的时刻选择 —— 12:00 前**不做核验（返回 null）**、12:00~15:59 用
|
||||
* 7:00 窗口、16:00 后用 16:00 窗口；
|
||||
* ③ 状态排除表 —— Cancelled / Merged / Split 必须排除（Split 是拆单父单，
|
||||
* 永不发货，不排除会把一年前的单全算成超时未发）；
|
||||
* ④ 服务层分桶算术 —— pending/shippedLate/onTime 三态互斥，按时率不为负。
|
||||
*
|
||||
* ⚠️ 本文件**不连数据库**，纯逻辑测试。
|
||||
*/
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
|
||||
const registry = require('../src/services/warehouseShipTimelinessRegistry');
|
||||
|
||||
// ── ① 主仓归属：最长匹配 ────────────────────────────────────────────────
|
||||
test('resolveCenter 用最长关键词匹配，品牌仓不会被主仓抢走', () => {
|
||||
assert.equal(registry.resolveCenter('简尚-横林二仓品牌仓').key, 'HL2_BRAND');
|
||||
assert.equal(registry.resolveCenter('简尚-横林二仓').key, 'HL2');
|
||||
assert.equal(registry.resolveCenter('简尚-崔桥工厂品牌仓').key, 'CQ_BRAND');
|
||||
assert.equal(registry.resolveCenter('简尚-崔桥工厂仓').key, 'CQ');
|
||||
assert.equal(registry.resolveCenter('简尚-山东品牌仓').key, 'SD_BRAND');
|
||||
assert.equal(registry.resolveCenter('简尚-山东青岗集仓').key, 'SD_QGJ');
|
||||
});
|
||||
|
||||
test('resolveCenter 能捞到各种命名的子仓', () => {
|
||||
const cases = [
|
||||
['京仓-横林二仓京东云仓', 'HL2'],
|
||||
['简尚-运营C横林二仓专用仓', 'HL2'],
|
||||
['简尚-横林二仓京东仓', 'HL2'],
|
||||
['简尚-崔桥工厂仓唯品仓', 'CQ'],
|
||||
['简尚-运营C崔桥工厂仓专用仓', 'CQ'],
|
||||
['简尚-新苏北临时仓', 'XSB'],
|
||||
['简尚-分销部睢宁专用仓', 'SN'],
|
||||
['京仓-山东青岗集京东仓储', 'SD_QGJ'],
|
||||
['简尚-山东青岗集仓马来海外仓', 'SD_QGJ'],
|
||||
['简尚-河南洛宁仓', 'HN_LN'],
|
||||
];
|
||||
for (const [name, expected] of cases) {
|
||||
assert.equal(registry.resolveCenter(name)?.key, expected, name);
|
||||
}
|
||||
});
|
||||
|
||||
test('resolveCenter 不会把无关代发仓误并入（山东/河南是高频前缀）', () => {
|
||||
// 这是最容易翻车的地方：仓库表里有上百个「工厂-山东XX代发仓」，
|
||||
// 如果关键词写成「山东」就会全被并进山东品牌仓/青岗集仓。
|
||||
const shouldBeNull = [
|
||||
'工厂-山东菏泽森美代发仓',
|
||||
'工厂-山东恒思代发仓',
|
||||
'工厂-河南千优代发仓',
|
||||
'工厂-河北霸州派雅世佳代发仓',
|
||||
'简尚-苏州福利品仓',
|
||||
'简尚-崔桥工厂半成品包装项目仓',
|
||||
];
|
||||
for (const name of shouldBeNull) {
|
||||
assert.equal(registry.resolveCenter(name), null, `${name} 不应归属任何主仓`);
|
||||
}
|
||||
});
|
||||
|
||||
test('崔桥工厂半成品仓是占位仓：没有关键词、匹配不到任何仓', () => {
|
||||
const c = registry.CENTERS.find((x) => x.key === 'CQ_WIP');
|
||||
assert.ok(c, 'CQ_WIP 必须存在（业务要求列出来）');
|
||||
assert.equal(c.placeholder, true);
|
||||
assert.deepEqual(c.keywords, []);
|
||||
});
|
||||
|
||||
// ── ② 核验轮次 ──────────────────────────────────────────────────────────
|
||||
const at = (h, m) => new Date(2026, 9, 20, h, m, 0); // 2026-10-20 本机时区（东八区）
|
||||
|
||||
test('12:00 前不做核验，返回 null（不回填昨日数据）', () => {
|
||||
// 业务口径（2026-10-20 确认）：中午 12:00 才开始第一轮核验，
|
||||
// 12:00 之前页面显示「未到核验时间」，**不能用昨天的结算结果冒充今天**。
|
||||
assert.equal(registry.resolveActiveRound(at(9, 30)), null);
|
||||
assert.equal(registry.resolveActiveRound(at(11, 59)), null);
|
||||
assert.equal(registry.resolveActiveRound(at(0, 5)), null);
|
||||
});
|
||||
|
||||
test('12:00~15:59 用 12:00 轮，核验窗口是当天 00:00~07:00', () => {
|
||||
const r = registry.resolveActiveRound(at(12, 0));
|
||||
assert.ok(r);
|
||||
assert.equal(r.key, 'NOON');
|
||||
assert.equal(r.deadline, '2026-10-20 12:00:00');
|
||||
assert.equal(r.windowStart, '2026-10-20 00:00:00');
|
||||
assert.equal(r.windowEnd, '2026-10-20 07:00:00');
|
||||
});
|
||||
|
||||
test('16:00 之后用 16:00 轮，核验窗口扩到当天 00:00~16:00', () => {
|
||||
const r = registry.resolveActiveRound(at(16, 0));
|
||||
assert.equal(r.key, 'AFTERNOON');
|
||||
assert.equal(r.deadline, '2026-10-20 16:00:00');
|
||||
assert.equal(r.windowEnd, '2026-10-20 16:00:00');
|
||||
|
||||
// 深夜仍沿用当天 16:00 轮（午夜后又回到新的一天）
|
||||
assert.equal(registry.resolveActiveRound(at(23, 59)).key, 'AFTERNOON');
|
||||
});
|
||||
|
||||
// ── ③ 状态排除 ──────────────────────────────────────────────────────────
|
||||
test('排除 Cancelled / Merged / Split，但保留 Question（仍算待发）', () => {
|
||||
const sql = registry.EXCLUDED_STATUS_SQL;
|
||||
assert.match(sql, /Cancelled/);
|
||||
assert.match(sql, /Merged/);
|
||||
assert.match(sql, /Split/);
|
||||
assert.doesNotMatch(sql, /Question/);
|
||||
});
|
||||
|
||||
// ── ④ 服务层分桶（注入假查询，不连库）──
|
||||
function stubDb(dbPath, realDb) {
|
||||
const wmsId = 15038426;
|
||||
// 重构后服务层是「一趟取回窗口内全部订单，Node 侧分桶」，
|
||||
// 所以 stub 要返回**明细行**而不是聚合行。三态各造几条：
|
||||
// · 超时未发 3 单 / 合计 300
|
||||
// · 已发但超时 1 单（send_date 晚于 16:00）
|
||||
// · 按时 6 单（send_date 早于 16:00）
|
||||
const mk = (sendDate, amount, oId) => ({
|
||||
src: 'jst_Orders',
|
||||
wms_co_id: wmsId,
|
||||
o_id: oId,
|
||||
so_id: String(oId),
|
||||
shop_name: '测试店',
|
||||
order_date: '2026-10-20 01:00:00',
|
||||
send_date: sendDate,
|
||||
status: 'Delivering',
|
||||
shop_status: '',
|
||||
pay_amount: amount,
|
||||
labels: '',
|
||||
ob_io_date: null,
|
||||
});
|
||||
|
||||
const stubRows = [
|
||||
mk(null, 100, 1), mk(null, 100, 2), mk(null, 100, 3),
|
||||
mk('2026-10-20 18:30:00', 50, 4),
|
||||
mk('2026-10-20 09:00:00', 100, 5), mk('2026-10-20 09:00:00', 100, 6),
|
||||
mk('2026-10-20 10:00:00', 100, 7), mk('2026-10-20 10:00:00', 100, 8),
|
||||
mk('2026-10-20 11:00:00', 100, 9), mk('2026-10-20 11:00:00', 100, 10),
|
||||
];
|
||||
|
||||
// 记录业务表被查了几次 —— 12:00 前应当为 0
|
||||
// ⚠️ 现在是**两表并行分别查**（jst_Orders + jst_qmcust_orderlist），
|
||||
// 所以两表都返回同一批 stubRows；服务层按 o_id 去重后仍应算 10 条，
|
||||
// 这也顺带验证了「跨表同 o_id 去重」逻辑。
|
||||
const calls = { order: 0 };
|
||||
require.cache[dbPath] = {
|
||||
id: dbPath,
|
||||
filename: dbPath,
|
||||
loaded: true,
|
||||
exports: {
|
||||
query: async (sql) => {
|
||||
if (/jst_warehouseInfo/u.test(sql)) {
|
||||
return [{ Id: 1, name: '简尚-崔桥工厂仓', wms_co_id: wmsId }];
|
||||
}
|
||||
if (/jst_salesOutboundInfo/u.test(sql) && /MAX\(io_date\)/u.test(sql)) {
|
||||
// 新鲜度查询：返回空，走 stale 分支也不影响主结果
|
||||
return [{ outbound_max: '2026-10-19 23:00:00' }];
|
||||
}
|
||||
calls.order += 1;
|
||||
return stubRows;
|
||||
},
|
||||
},
|
||||
};
|
||||
void realDb;
|
||||
return { calls, wmsId };
|
||||
}
|
||||
|
||||
test('服务层三态分桶互斥，按时率不为负', async () => {
|
||||
const dbPath = require.resolve('../src/config/cloudDatabase');
|
||||
const realDb = require.cache[dbPath];
|
||||
stubDb(dbPath, realDb);
|
||||
delete require.cache[require.resolve('../src/services/warehouseShipTimelinessService')];
|
||||
delete require.cache[require.resolve('../src/services/warehouseShipTimelinessRegistry')];
|
||||
|
||||
try {
|
||||
const svc = require('../src/services/warehouseShipTimelinessService');
|
||||
const data = await svc.getShipTimeliness({ now: at(16, 5), limit: 10 });
|
||||
const c = data.centers.find((x) => x.key === 'CQ');
|
||||
assert.ok(c, '应能归到崔桥工厂仓');
|
||||
assert.equal(c.overdueUnshipped, 3);
|
||||
assert.equal(c.overdueShipped, 1);
|
||||
assert.equal(c.windowOrderCount, 10, '总数 = pending + shippedLate + onTime');
|
||||
assert.equal(c.onTimeRate, 60, '按时 6/10 = 60%（跨表重复 o_id 必须去重，否则总数会翻倍）');
|
||||
|
||||
// 汇总口径与各仓一致，且按时率不会是负数
|
||||
assert.equal(data.summary.overdueUnshipped, 3);
|
||||
assert.equal(data.summary.windowOrderCount, 10);
|
||||
assert.equal(data.summary.onTimeRate, 60);
|
||||
assert.ok(data.summary.onTimeRate >= 0);
|
||||
|
||||
// 前端要展示「核验 16:00 前」，round 必须带出 windowEnd ——
|
||||
// 只回 key/label 的话页面会渲染成「核验 前」（2026-10-20 真渲染时抓到）
|
||||
assert.ok(data.round, 'round 不能为空');
|
||||
assert.equal(data.round.key, 'AFTERNOON');
|
||||
assert.equal(data.round.cutoffHour, 16);
|
||||
assert.match(String(data.round.windowEnd), /16:00:00$/, 'round.windowEnd 必须带出截止时刻');
|
||||
} finally {
|
||||
// 还原，避免污染同进程内其它测试
|
||||
if (realDb) require.cache[dbPath] = realDb;
|
||||
else delete require.cache[dbPath];
|
||||
delete require.cache[require.resolve('../src/services/warehouseShipTimelinessService')];
|
||||
delete require.cache[require.resolve('../src/services/warehouseShipTimelinessRegistry')];
|
||||
}
|
||||
});
|
||||
|
||||
test('服务层 12:00 前返回 notStarted，且不去查订单表', async () => {
|
||||
const dbPath = require.resolve('../src/config/cloudDatabase');
|
||||
const realDb = require.cache[dbPath];
|
||||
const { calls } = stubDb(dbPath, realDb);
|
||||
delete require.cache[require.resolve('../src/services/warehouseShipTimelinessService')];
|
||||
delete require.cache[require.resolve('../src/services/warehouseShipTimelinessRegistry')];
|
||||
|
||||
try {
|
||||
const svc = require('../src/services/warehouseShipTimelinessService');
|
||||
const data = await svc.getShipTimeliness({ now: at(9, 30), limit: 10 });
|
||||
assert.equal(data.notStarted, true);
|
||||
assert.equal(data.round, null);
|
||||
assert.equal(data.orders.length, 0);
|
||||
assert.equal(data.summary.overdueUnshipped, 0);
|
||||
// 11 个主仓仍然列出来（结构不能塌），但数字全为 0
|
||||
assert.equal(data.centers.length, registry.CENTERS.length);
|
||||
assert.ok(data.centers.every((c) => c.overdueUnshipped === 0));
|
||||
assert.equal(calls.order, 0, '未到核验时间不应扫订单表');
|
||||
assert.match(data.note, /12:00/);
|
||||
// 下一轮核验时刻要告诉前端，方便提示「12:00 开始」
|
||||
assert.equal(data.nextRoundAt, '2026-10-20 12:00:00');
|
||||
} finally {
|
||||
if (realDb) require.cache[dbPath] = realDb;
|
||||
else delete require.cache[dbPath];
|
||||
delete require.cache[require.resolve('../src/services/warehouseShipTimelinessService')];
|
||||
delete require.cache[require.resolve('../src/services/warehouseShipTimelinessRegistry')];
|
||||
}
|
||||
});
|
||||
@ -1,23 +0,0 @@
|
||||
import request from './request';
|
||||
|
||||
// 发货时效要扫两张订单表 + 出库表（rpt 下全是视图），冷启动实测 40~50 秒，
|
||||
// 超时必须放大到 3 分钟，否则前端会先断开、后端还在跑。
|
||||
const TIMELINESS_TIMEOUT_MS = 3 * 60 * 1000;
|
||||
|
||||
// 仓储中心 24 小时发货时效：每个主仓「超时未发」数量 + 超时订单明细
|
||||
// params.round 'NOON' | 'AFTERNOON'（不传按当前时刻自动判定）
|
||||
// params.limit 明细条数上限
|
||||
export const getWarehouseShipTimeliness = (params = {}) => request.get(
|
||||
'/api/warehouse-ship-timeliness/list',
|
||||
{
|
||||
params,
|
||||
timeout: TIMELINESS_TIMEOUT_MS,
|
||||
headers: { 'Cache-Control': 'no-cache' },
|
||||
}
|
||||
);
|
||||
|
||||
// 仅取今日两轮核验的描述（不打订单表，秒回），用于顶部提示
|
||||
export const getWarehouseShipTimelinessRounds = () => request.get(
|
||||
'/api/warehouse-ship-timeliness/rounds',
|
||||
{ timeout: 30000 }
|
||||
);
|
||||
@ -11,11 +11,6 @@ export const PICKING_BIN_COLUMNS = [
|
||||
label: '仓位',
|
||||
tip: '系统仓位编码（jst_packInventoryInfo.bin）；同一仓位有多个商品时会出现多行',
|
||||
},
|
||||
{
|
||||
key: 'binType',
|
||||
label: '类型',
|
||||
tip: '统计范围固定为真实拣选仓位（pack_type=Bin 且 bin_group 为空）；箱记录和存货位不纳入动销分析',
|
||||
},
|
||||
{
|
||||
key: 'skuId',
|
||||
label: '商品编码',
|
||||
@ -29,7 +24,7 @@ export const PICKING_BIN_COLUMNS = [
|
||||
{
|
||||
key: 'salesQty',
|
||||
label: '商品销量',
|
||||
tip: '近 N 天该商品的销量（整档，不按仓位分摊）：含线上订单、组合装子件拆分、全民客户(B2B分销)渠道；同一商品占几个仓位，这几行显示的销量都一样，所以这一列不能直接按行求和',
|
||||
tip: '近 N 天该商品的销量（整档，不按仓位分摊）：同一商品占几个仓位，这几行显示的销量都一样，所以这一列不能直接按行求和',
|
||||
},
|
||||
{
|
||||
key: 'dailySales',
|
||||
@ -63,7 +58,7 @@ export const PICKING_BIN_GRADE_COLORS = {
|
||||
};
|
||||
|
||||
export const PICKING_BIN_DESCRIPTION = [
|
||||
'【统计范围】只统计真实拣选仓位（pack_type=Bin 且 bin_group 为空）；箱记录（pack_type=Pack）和存货位不纳入动销分析。',
|
||||
'【统计范围】只统计拣选位（bin_group 为空的仓位）；存货位不纳入动销分析。',
|
||||
'',
|
||||
'【粒度】一行 = 一个「仓位 × 商品编码」组合。一个仓位放了 N 个商品就显示 N 行，列表与导出一致。',
|
||||
' 库存数量 = 该商品在这个仓位上的实际库存（同一仓位多行相加 = 仓位总库存）。',
|
||||
@ -85,7 +80,6 @@ export const PICKING_BIN_DESCRIPTION = [
|
||||
' 注意它小于全仓销量：jst_packInventoryInfo 只覆盖部分 SKU 的仓位数据，无仓位记录的 SKU 销量不计入任何库位。',
|
||||
'',
|
||||
'数据来源：库存取 rpt.jst_packInventoryInfo（按仓库 + 仓位 + 商品汇总）；',
|
||||
'销量按 send_date 窗口统计 4 个来源：① jst_Orders 普通商品行；② jst_Orders 组合装行（ZH-拼接编码）按组合装映射展开为子件；',
|
||||
'③ jst_qmcust_orderlist 全民客户(B2B分销)普通行（排除拆单父单 Split）；④ qmcust 组合装行同样展开。',
|
||||
'统计范围：只取 pack_type=Bin 且 bin_group 为空的真实拣选仓位，箱记录（pack_type=Pack）和存货位（bin_group=存货）不参与统计。',
|
||||
'销量取 rpt.jst_Orders × rpt.jst_OrderItem（按 send_date，排除 Delete/Cancelled），与「每日进销存」发货口径一致。',
|
||||
'统计范围：只取 bin_group 为空的拣选位，存货位（bin_group=存货）不参与统计。',
|
||||
];
|
||||
|
||||
@ -1,146 +0,0 @@
|
||||
import React from 'react';
|
||||
import { Tooltip } from 'antd';
|
||||
|
||||
/**
|
||||
* 仓储中心 24 小时发货时效 —— 列表左侧侧栏
|
||||
* ────────────────────────────────────────────────────────────────────────────
|
||||
* 业务需求（yanhui 2026-10-20）：
|
||||
* 「在列表左侧加一栏仓储中心24小时发货时效，下面列 11 个仓…只显示超时未发」
|
||||
*
|
||||
* 设计取舍：
|
||||
* · **只显示超时未发** —— 数量为 0 的仓也保留一行（浅色显示「—」），
|
||||
* 这样业务能一眼看出「这个仓今天全发完了」，比直接隐藏更有信息量；
|
||||
* · 点击某个仓 → 把该仓的超时订单筛到右侧表格里（不跳页，避免业务来回切）；
|
||||
* · 崔桥工厂半成品仓系统里没有同名仓，`placeholder=true` 时显示「未接入」。
|
||||
*
|
||||
* 数据来自 getWarehouseShipTimeliness，字段见后端 warehouseShipTimelinessService。
|
||||
*/
|
||||
function WarehouseShipTimelinessSidebar({
|
||||
data, loading, error, activeCenter, onSelectCenter, collapsed, onToggleCollapse,
|
||||
}) {
|
||||
const centers = data && Array.isArray(data.centers) ? data.centers : [];
|
||||
const summary = data && data.summary ? data.summary : null;
|
||||
const round = data && data.round ? data.round : null;
|
||||
const freshness = data && data.freshness ? data.freshness : null;
|
||||
const totalOverdue = summary ? summary.overdueUnshipped : 0;
|
||||
const hasRound = Boolean(round);
|
||||
// 12:00 之前后端返回 round=null + notStarted=true：
|
||||
// 业务口径是「12:00 才开始第一轮核验」，此时**不展示任何超时数字**，
|
||||
// 也不回填昨天的结算结果（否则会被误当成今天的超时）。
|
||||
const notStarted = Boolean(data && data.notStarted);
|
||||
// 核验截止时刻：12:00 轮截止 07:00、16:00 轮截止 16:00，直接展示，业务不用换算
|
||||
const cutoffText = String((round && round.windowEnd) || '').slice(11, 16);
|
||||
|
||||
return (
|
||||
<aside className={`mkh-ship-side${collapsed ? ' mkh-ship-side--collapsed' : ''}`}>
|
||||
<div className="mkh-ship-side__head">
|
||||
<div className="mkh-ship-side__title">
|
||||
<span>仓储中心24小时发货时效</span>
|
||||
<button
|
||||
type="button"
|
||||
className="mkh-ship-side__collapse"
|
||||
onClick={onToggleCollapse}
|
||||
title={collapsed ? '展开侧栏' : '收起侧栏'}
|
||||
>
|
||||
{collapsed ? '»' : '«'}
|
||||
</button>
|
||||
</div>
|
||||
{collapsed ? null : (
|
||||
<>
|
||||
<div className="mkh-ship-side__meta">
|
||||
{hasRound ? (
|
||||
<>
|
||||
<span className="mkh-ship-side__round">{round.label}</span>
|
||||
<span>核验 {cutoffText} 前</span>
|
||||
</>
|
||||
) : (
|
||||
<span className="mkh-ship-side__round mkh-ship-side__round--idle">未到核验时间</span>
|
||||
)}
|
||||
</div>
|
||||
<div className="mkh-ship-side__total">
|
||||
<span className="mkh-ship-side__total-num" data-zero={totalOverdue === 0}>
|
||||
{notStarted ? '—' : totalOverdue}
|
||||
</span>
|
||||
<span className="mkh-ship-side__total-label">单超时未发</span>
|
||||
</div>
|
||||
</>
|
||||
)}
|
||||
</div>
|
||||
|
||||
{collapsed ? null : (
|
||||
<>
|
||||
<ul className="mkh-ship-side__list">
|
||||
{centers.map((c) => {
|
||||
const isActive = activeCenter === c.key;
|
||||
const empty = !c.overdueUnshipped;
|
||||
// 12:00 前未开始核验时，所有仓都不能点（点了也筛不出东西，
|
||||
// 反而让人以为「这个仓没问题」）
|
||||
const disabled = c.placeholder || notStarted;
|
||||
return (
|
||||
<li key={c.key}>
|
||||
<Tooltip
|
||||
placement="right"
|
||||
title={c.placeholder
|
||||
? '系统仓库表中暂无同名仓，待上游建仓后自动接入'
|
||||
: notStarted
|
||||
? '今日 12:00 首轮核验开始后才展示超时数据'
|
||||
: `${c.name}：超时未发 ${c.overdueUnshipped} 单`
|
||||
+ `（已发但超时 ${c.overdueShipped}，窗口订单 ${c.windowOrderCount}`
|
||||
+ `${c.onTimeRate === null ? '' : `，按时率 ${c.onTimeRate}%`}）`
|
||||
+ (c.warehouseCount > 1 ? `\n含子仓 ${c.warehouseCount} 个` : '')}
|
||||
>
|
||||
<button
|
||||
type="button"
|
||||
className={[
|
||||
'mkh-ship-side__item',
|
||||
isActive ? 'is-active' : '',
|
||||
empty ? 'is-empty' : '',
|
||||
disabled ? 'is-disabled' : '',
|
||||
].filter(Boolean).join(' ')}
|
||||
onClick={() => {
|
||||
if (disabled) return;
|
||||
onSelectCenter?.(isActive ? '' : c.key);
|
||||
}}
|
||||
>
|
||||
<span className="mkh-ship-side__name">{c.name}</span>
|
||||
{c.placeholder ? (
|
||||
<span className="mkh-ship-side__badge mkh-ship-side__badge--none">未接入</span>
|
||||
) : (
|
||||
<span className={`mkh-ship-side__badge${c.overdueUnshipped > 0 ? ' is-warn' : ''}`}>
|
||||
{c.overdueUnshipped > 0 ? c.overdueUnshipped : '—'}
|
||||
</span>
|
||||
)}
|
||||
</button>
|
||||
</Tooltip>
|
||||
</li>
|
||||
);
|
||||
})}
|
||||
</ul>
|
||||
|
||||
{error ? (
|
||||
<div className="mkh-ship-side__warn" title={error}>时效数据加载失败</div>
|
||||
) : null}
|
||||
|
||||
{freshness && freshness.stale ? (
|
||||
<div className="mkh-ship-side__warn" title={freshness.hint}>
|
||||
发货数据可能滞后
|
||||
</div>
|
||||
) : null}
|
||||
|
||||
{/* 12:00 前：首轮核验还没开始，明确告诉业务「几点开始看」，
|
||||
而不是拿昨天的结算数字冒充今天。 */}
|
||||
{notStarted ? (
|
||||
<div className="mkh-ship-side__hint">
|
||||
{String(data.nextRoundAt || '').slice(11, 16) || '12:00'} 开始首轮核验
|
||||
（核验当日 07:00 前创建的订单）
|
||||
</div>
|
||||
) : null}
|
||||
|
||||
{loading ? <div className="mkh-ship-side__loading">加载中…</div> : null}
|
||||
</>
|
||||
)}
|
||||
</aside>
|
||||
);
|
||||
}
|
||||
|
||||
export default WarehouseShipTimelinessSidebar;
|
||||
@ -19,8 +19,6 @@ import {
|
||||
} from '../../api/mkhBom';
|
||||
import { createRequestGate } from '../../utils/requestGate';
|
||||
import { requireMkhFreshContract } from '../../utils/mkhFreshContract';
|
||||
import WarehouseShipTimelinessSidebar from './WarehouseShipTimelinessSidebar';
|
||||
import { getWarehouseShipTimeliness } from '../../api/warehouseShipTimeliness';
|
||||
import { exportTableFile } from '../../utils/tableExport';
|
||||
import './style.css';
|
||||
|
||||
@ -35,16 +33,6 @@ const number = (value, digits = 0) => (value === null || value === undefined ||
|
||||
|
||||
const text = (value) => (value === null || value === undefined || value === '' ? '--' : value);
|
||||
|
||||
// 超时时长（分钟）→ 「3小时20分」。业务看的是「晚了多久」，不是精确到分钟的秒数。
|
||||
const formatOverdue = (minutes) => {
|
||||
const m = Number(minutes);
|
||||
if (!Number.isFinite(m) || m <= 0) return '—';
|
||||
if (m < 60) return `${m} 分钟`;
|
||||
const h = Math.floor(m / 60);
|
||||
const rest = m % 60;
|
||||
return rest ? `${h} 小时 ${rest} 分` : `${h} 小时`;
|
||||
};
|
||||
|
||||
const EMPTY_FILTERS = { keyword: '', scope: 'warning' };
|
||||
// 页面长时打开时定期重读。后端共享 10 分钟索引缓存，因此多个页面的轮询
|
||||
// 会合并为每个缓存周期一次业务库读取，不会每 2 分钟重复扫远程大表。
|
||||
@ -312,28 +300,6 @@ const MkhBomData = () => {
|
||||
const autoRefreshPendingRef = useRef(false);
|
||||
const [bodyHeight, setBodyHeight] = useState(420);
|
||||
|
||||
// ── 仓储中心 24 小时发货时效（左侧侧栏）────────────────────────────────
|
||||
// 与 MKH 列表**完全独立**的两套数据：列表来自 BOM/库存，侧栏来自订单+出库表。
|
||||
// 所以侧栏单独 load、单独失败，不能因为发货时效查询慢就把整个列表拖住。
|
||||
const [shipTimeliness, setShipTimeliness] = useState(null);
|
||||
const [shipLoading, setShipLoading] = useState(false);
|
||||
const [shipError, setShipError] = useState('');
|
||||
const [shipCollapsed, setShipCollapsed] = useState(false);
|
||||
// 选中的主仓：非空时右侧表格只显示该仓的超时订单
|
||||
const [shipCenter, setShipCenter] = useState('');
|
||||
|
||||
// 当前选中主仓的名字 + 该仓的超时订单（从同一次快照里筛，保证与侧栏数字一致）
|
||||
const shipCenterName = useMemo(() => {
|
||||
if (!shipCenter || !shipTimeliness) return '';
|
||||
const hit = (shipTimeliness.centers || []).find((c) => c.key === shipCenter);
|
||||
return hit ? hit.name : shipCenter;
|
||||
}, [shipCenter, shipTimeliness]);
|
||||
|
||||
const shipCenterOrders = useMemo(() => {
|
||||
if (!shipCenter || !shipTimeliness) return [];
|
||||
return (shipTimeliness.orders || []).filter((o) => o.centerKey === shipCenter);
|
||||
}, [shipCenter, shipTimeliness]);
|
||||
|
||||
const beginRefreshProgress = useCallback((title) => {
|
||||
refreshProgressGenerationRef.current += 1;
|
||||
const generation = refreshProgressGenerationRef.current;
|
||||
@ -438,33 +404,6 @@ const MkhBomData = () => {
|
||||
|
||||
useEffect(() => { load(); }, [load]);
|
||||
|
||||
// ── 发货时效侧栏加载 ────────────────────────────────────────────────────
|
||||
// 注意：这个接口要扫两张订单表 + 出库表（rpt 全是视图），冷启动实测 40~50 秒，
|
||||
// 所以**不能**跟着列表每 2 分钟的轮询一起跑，否则后端一直被打。
|
||||
// 独立节奏：进页面拉一次，之后每 10 分钟一次（核验点只有 12:00 / 16:00 两个）。
|
||||
const loadShipTimeliness = useCallback(async () => {
|
||||
setShipLoading(true);
|
||||
setShipError('');
|
||||
try {
|
||||
const result = await getWarehouseShipTimeliness({ limit: 500 });
|
||||
if (!result || result.success === false) {
|
||||
setShipError(result?.error || '加载发货时效失败');
|
||||
return;
|
||||
}
|
||||
setShipTimeliness(result.data || null);
|
||||
} catch (shipLoadError) {
|
||||
setShipError(shipLoadError?.response?.data?.error || shipLoadError?.message || '加载发货时效失败');
|
||||
} finally {
|
||||
setShipLoading(false);
|
||||
}
|
||||
}, []);
|
||||
|
||||
useEffect(() => {
|
||||
loadShipTimeliness();
|
||||
const timer = window.setInterval(loadShipTimeliness, 10 * 60 * 1000);
|
||||
return () => window.clearInterval(timer);
|
||||
}, [loadShipTimeliness]);
|
||||
|
||||
// 页面保持打开时自动更新；从后台切回且数据已超过轮询周期时立即重读。
|
||||
// 后台刷新保留当前表格，不显示全页加载态；请求门仍会阻止旧响应覆盖新数据。
|
||||
useEffect(() => {
|
||||
@ -1047,73 +986,6 @@ const MkhBomData = () => {
|
||||
</div>
|
||||
</header>
|
||||
|
||||
{/*
|
||||
左侧「仓储中心24小时发货时效」侧栏 + 右侧原有内容，横向两栏。
|
||||
侧栏收起时只留一条窄条，主区自动占满 —— 用 flex，不用固定宽度判断。
|
||||
*/}
|
||||
<div className="mkh-with-side">
|
||||
<WarehouseShipTimelinessSidebar
|
||||
data={shipTimeliness}
|
||||
loading={shipLoading}
|
||||
error={shipError}
|
||||
activeCenter={shipCenter}
|
||||
onSelectCenter={setShipCenter}
|
||||
collapsed={shipCollapsed}
|
||||
onToggleCollapse={() => setShipCollapsed((v) => !v)}
|
||||
/>
|
||||
|
||||
<div className="mkh-with-side__main">
|
||||
{/*
|
||||
超时明细：只有点了左侧某个仓才展开。
|
||||
明细来自同一次 list 接口（已按 order_date 升序，最早的最急），
|
||||
不再单独请求 —— 两套数据必须同源同快照，否则数字对不上。
|
||||
*/}
|
||||
{shipCenter && shipTimeliness ? (
|
||||
<Card
|
||||
bordered={false}
|
||||
className="mkh-ship-detail"
|
||||
title={(
|
||||
<span>
|
||||
超时未发订单 · <b>{shipCenterName}</b>
|
||||
<span className="mkh-ship-detail__count">
|
||||
{shipCenterOrders.length} 单
|
||||
{shipTimeliness.truncated && shipCenterOrders.length >= (shipTimeliness.detailLimit || 0)
|
||||
? `（已截断，仅显示前 ${shipTimeliness.detailLimit} 条）`
|
||||
: ''}
|
||||
</span>
|
||||
</span>
|
||||
)}
|
||||
extra={<button type="button" className="mkh-ship-detail__clear" onClick={() => setShipCenter('')}>关闭</button>}
|
||||
>
|
||||
<Table
|
||||
rowKey={(r) => `${r.source}-${r.oId}`}
|
||||
size="small"
|
||||
pagination={{ pageSize: 10, size: 'small', showSizeChanger: false }}
|
||||
dataSource={shipCenterOrders}
|
||||
columns={[
|
||||
{ title: '订单号', dataIndex: 'oId', width: 110 },
|
||||
{ title: '店铺', dataIndex: 'shopName', width: 190, ellipsis: true },
|
||||
{ title: '发货仓', dataIndex: 'warehouseName', width: 190, ellipsis: true },
|
||||
{ title: '创建时间', dataIndex: 'orderDate', width: 150 },
|
||||
{
|
||||
title: '超时时长',
|
||||
dataIndex: 'overdueMinutes',
|
||||
width: 96,
|
||||
render: (v) => <span className="mkh-ship-detail__overdue">{formatOverdue(v)}</span>,
|
||||
},
|
||||
{
|
||||
title: '金额',
|
||||
dataIndex: 'payAmount',
|
||||
width: 96,
|
||||
align: 'right',
|
||||
render: (v) => `¥${number(v, 2)}`,
|
||||
},
|
||||
{ title: '状态', dataIndex: 'status', width: 110 },
|
||||
]}
|
||||
/>
|
||||
</Card>
|
||||
) : null}
|
||||
|
||||
<Card className="mkh-filter-card" bordered={false}>
|
||||
<Space wrap size={[12, 12]}>
|
||||
<Input
|
||||
@ -1474,8 +1346,6 @@ const MkhBomData = () => {
|
||||
</div>
|
||||
</Spin>
|
||||
</Modal>
|
||||
</div>
|
||||
</div>
|
||||
</SycmPage>
|
||||
);
|
||||
};
|
||||
|
||||
@ -391,280 +391,3 @@
|
||||
.mkh-alert-form--inner {
|
||||
margin-top: 4px;
|
||||
}
|
||||
|
||||
/* ============ 仓储中心 24 小时发货时效（左侧侧栏，2026-10-20）============ */
|
||||
/* 左侧固定宽侧栏 + 右侧自适应主区。不用 float，避免表格宽度塌陷。
|
||||
侧栏 sticky 贴顶：表格很长时侧栏跟着滚走会看不到告警数，业务要一直看得见。 */
|
||||
.mkh-with-side {
|
||||
display: flex;
|
||||
align-items: flex-start;
|
||||
gap: 14px;
|
||||
}
|
||||
|
||||
.mkh-with-side__main {
|
||||
flex: 1 1 auto;
|
||||
min-width: 0;
|
||||
}
|
||||
|
||||
.mkh-ship-side {
|
||||
flex: none;
|
||||
align-self: flex-start;
|
||||
width: 208px;
|
||||
/* 11 个仓 + 头部合计约 400px，给足高度；超出才滚动。
|
||||
不加 max-height 会被 flex 拉伸/压缩，撑开后又不该无限长（表格很长时）。 */
|
||||
max-height: calc(100vh - 40px);
|
||||
overflow-y: auto;
|
||||
padding: 12px 10px 14px;
|
||||
border: 1px solid var(--sycm-border-color);
|
||||
border-radius: 10px;
|
||||
background: var(--sycm-bg-container);
|
||||
box-sizing: border-box;
|
||||
position: sticky;
|
||||
top: 8px;
|
||||
}
|
||||
|
||||
.mkh-ship-side--collapsed {
|
||||
width: 44px;
|
||||
padding: 12px 6px;
|
||||
}
|
||||
|
||||
.mkh-ship-side__head {
|
||||
margin-bottom: 10px;
|
||||
}
|
||||
|
||||
.mkh-ship-side__title {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: space-between;
|
||||
gap: 6px;
|
||||
font-size: 13px;
|
||||
font-weight: 600;
|
||||
line-height: 1.4;
|
||||
color: var(--sycm-text-strong);
|
||||
}
|
||||
|
||||
.mkh-ship-side--collapsed .mkh-ship-side__title > span {
|
||||
writing-mode: vertical-rl;
|
||||
letter-spacing: 2px;
|
||||
font-size: 12px;
|
||||
}
|
||||
|
||||
.mkh-ship-side__collapse {
|
||||
flex: none;
|
||||
width: 18px;
|
||||
height: 18px;
|
||||
padding: 0;
|
||||
border: 1px solid var(--sycm-border-color);
|
||||
border-radius: 4px;
|
||||
background: transparent;
|
||||
color: var(--sycm-text-tertiary);
|
||||
font-size: 11px;
|
||||
line-height: 1;
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
.mkh-ship-side__collapse:hover {
|
||||
color: var(--sycm-text-primary);
|
||||
border-color: var(--sycm-text-tertiary);
|
||||
}
|
||||
|
||||
.mkh-ship-side__meta {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: 4px 8px;
|
||||
margin-top: 6px;
|
||||
font-size: 11px;
|
||||
color: var(--sycm-text-tertiary);
|
||||
}
|
||||
|
||||
.mkh-ship-side__round {
|
||||
padding: 0 5px;
|
||||
border-radius: 3px;
|
||||
background: rgba(22, 119, 255, 0.12);
|
||||
color: #0958d9;
|
||||
}
|
||||
|
||||
.mkh-ship-side__round--idle {
|
||||
background: rgba(136, 135, 128, 0.14);
|
||||
color: var(--sycm-text-tertiary);
|
||||
}
|
||||
|
||||
.mkh-ship-side__total {
|
||||
display: flex;
|
||||
align-items: baseline;
|
||||
gap: 6px;
|
||||
margin-top: 8px;
|
||||
padding-top: 8px;
|
||||
border-top: 1px dashed var(--sycm-border-color);
|
||||
}
|
||||
|
||||
.mkh-ship-side__total-num {
|
||||
font-size: 22px;
|
||||
font-weight: 700;
|
||||
line-height: 1;
|
||||
color: #cf1322;
|
||||
font-variant-numeric: tabular-nums;
|
||||
}
|
||||
|
||||
.mkh-ship-side__total-num[data-zero='true'] {
|
||||
color: var(--sycm-text-tertiary);
|
||||
}
|
||||
|
||||
.mkh-ship-side__total-label {
|
||||
font-size: 11px;
|
||||
color: var(--sycm-text-tertiary);
|
||||
}
|
||||
|
||||
.mkh-ship-side__list {
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
list-style: none;
|
||||
}
|
||||
|
||||
.mkh-ship-side__item {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: space-between;
|
||||
gap: 6px;
|
||||
width: 100%;
|
||||
padding: 5px 7px;
|
||||
margin-bottom: 2px;
|
||||
border: 1px solid transparent;
|
||||
border-radius: 6px;
|
||||
background: transparent;
|
||||
font-size: 12px;
|
||||
text-align: left;
|
||||
color: var(--sycm-text-primary);
|
||||
cursor: pointer;
|
||||
transition: background 0.12s ease;
|
||||
}
|
||||
|
||||
.mkh-ship-side__item:hover {
|
||||
background: var(--sycm-bg-subtle);
|
||||
}
|
||||
|
||||
.mkh-ship-side__item.is-active {
|
||||
border-color: rgba(22, 119, 255, 0.45);
|
||||
background: rgba(22, 119, 255, 0.08);
|
||||
}
|
||||
|
||||
.mkh-ship-side__item.is-empty .mkh-ship-side__name {
|
||||
color: var(--sycm-text-tertiary);
|
||||
}
|
||||
|
||||
.mkh-ship-side__item.is-disabled {
|
||||
cursor: not-allowed;
|
||||
opacity: 0.6;
|
||||
}
|
||||
|
||||
.mkh-ship-side__name {
|
||||
overflow: hidden;
|
||||
white-space: nowrap;
|
||||
text-overflow: ellipsis;
|
||||
}
|
||||
|
||||
.mkh-ship-side__badge {
|
||||
flex: none;
|
||||
min-width: 22px;
|
||||
padding: 0 5px;
|
||||
border-radius: 9px;
|
||||
background: rgba(136, 135, 128, 0.12);
|
||||
font-size: 11px;
|
||||
font-weight: 600;
|
||||
line-height: 16px;
|
||||
text-align: center;
|
||||
color: var(--sycm-text-tertiary);
|
||||
font-variant-numeric: tabular-nums;
|
||||
}
|
||||
|
||||
.mkh-ship-side__badge.is-warn {
|
||||
background: rgba(255, 77, 79, 0.16);
|
||||
color: #cf1322;
|
||||
}
|
||||
|
||||
.mkh-ship-side__badge--none {
|
||||
font-weight: 400;
|
||||
}
|
||||
|
||||
.mkh-ship-side__warn {
|
||||
margin-top: 10px;
|
||||
padding: 6px 8px;
|
||||
border-radius: 6px;
|
||||
background: rgba(250, 173, 20, 0.14);
|
||||
font-size: 11px;
|
||||
line-height: 1.6;
|
||||
color: #ad4e00;
|
||||
cursor: help;
|
||||
}
|
||||
|
||||
.mkh-ship-side__hint {
|
||||
margin-top: 10px;
|
||||
font-size: 11px;
|
||||
line-height: 1.6;
|
||||
color: var(--sycm-text-tertiary);
|
||||
}
|
||||
|
||||
.mkh-ship-side__loading {
|
||||
margin-top: 8px;
|
||||
font-size: 11px;
|
||||
color: var(--sycm-text-tertiary);
|
||||
}
|
||||
|
||||
/* 窄屏兜底（<1100px）：此时右侧表格已经放不下，侧栏整体铺到上方。
|
||||
* ⚠️ 1100~1500px 之间**保持左侧竖栏** —— 那是业务最常用的笔记本分辨率
|
||||
* （1366×768 / 1440×900），侧栏必须还在左边，否则「列表左侧加一栏」的需求就不成立。
|
||||
* 列表始终竖向排列，绝不横排（横排后 11 个仓挤成一行完全没法读）。 */
|
||||
@media (max-width: 1100px) {
|
||||
.mkh-with-side {
|
||||
flex-direction: column;
|
||||
}
|
||||
|
||||
.mkh-ship-side,
|
||||
.mkh-ship-side--collapsed {
|
||||
position: static;
|
||||
width: 100%;
|
||||
max-height: none;
|
||||
}
|
||||
|
||||
.mkh-ship-side--collapsed .mkh-ship-side__title > span {
|
||||
writing-mode: horizontal-tb;
|
||||
}
|
||||
}
|
||||
|
||||
/* 中窄屏（1100~1500px，含 1366×768 笔记本）：侧栏仍在左侧，只是收窄 */
|
||||
@media (max-width: 1500px) and (min-width: 1101px) {
|
||||
.mkh-ship-side {
|
||||
width: 176px;
|
||||
}
|
||||
|
||||
.mkh-ship-side__name {
|
||||
font-size: 12px;
|
||||
}
|
||||
}
|
||||
|
||||
/* 超时明细卡（点左侧某个仓才出现） */
|
||||
.mkh-ship-detail {
|
||||
margin-bottom: 12px;
|
||||
}
|
||||
|
||||
.mkh-ship-detail__count {
|
||||
margin-left: 8px;
|
||||
font-size: 12px;
|
||||
font-weight: 400;
|
||||
color: var(--sycm-text-tertiary);
|
||||
}
|
||||
|
||||
.mkh-ship-detail__clear {
|
||||
padding: 0;
|
||||
border: none;
|
||||
background: transparent;
|
||||
color: #0958d9;
|
||||
font-size: 12px;
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
.mkh-ship-detail__overdue {
|
||||
color: #cf1322;
|
||||
font-weight: 600;
|
||||
font-variant-numeric: tabular-nums;
|
||||
}
|
||||
|
||||
@ -92,7 +92,7 @@ const PickingBinSalesAnalysis = () => {
|
||||
title: <TipTitle tip={col.tip}>{col.label}</TipTitle>,
|
||||
key: col.key,
|
||||
dataIndex: col.key,
|
||||
align: ['warehouse', 'binName', 'binType', 'skuId', 'gradeKey'].includes(col.key) ? 'left' : 'right',
|
||||
align: ['warehouse', 'binName', 'skuId', 'gradeKey'].includes(col.key) ? 'left' : 'right',
|
||||
width: col.key === 'warehouse' ? 240
|
||||
: (col.key === 'gradeKey' ? 170 : (col.key === 'skuId' ? 150 : 110)),
|
||||
sorter: ['stockQty', 'salesQty', 'dailySales'].includes(col.key)
|
||||
@ -103,7 +103,7 @@ const PickingBinSalesAnalysis = () => {
|
||||
const g = gradeMap.get(value);
|
||||
return <Tag color={PICKING_BIN_GRADE_COLORS[value] || 'default'}>{g?.label || value}</Tag>;
|
||||
}
|
||||
if (col.key === 'binType' || col.key === 'skuId') return <Text>{value || '—'}</Text>;
|
||||
if (col.key === 'skuId') return <Text>{value || '—'}</Text>;
|
||||
if (col.key === 'dailySales') return num(value, 2);
|
||||
if (col.key === 'salesQty') return num(value, 2);
|
||||
if (col.key === 'stockQty') return int(value);
|
||||
@ -191,7 +191,7 @@ const PickingBinSalesAnalysis = () => {
|
||||
<Tooltip title="跳过 5 分钟缓存，重新扫描订单与仓位明细重算（约 5~20 秒）">
|
||||
<Button onClick={() => load({ force: true })} loading={loading}>强制重算</Button>
|
||||
</Tooltip>
|
||||
<Tooltip title="导出当前筛选下的明细（仓库 / 仓位 / 类型 / 商品编码 / 库存数量 / 仓位SKU数 / 商品销量 / 分摊销量 / 商品日销 / 动销等级），仅含拣选位。按「仓位 × 商品编码」拆行；商品销量为整档销量（同一商品跨仓位重复，不可直接求和），需要求和请用「分摊销量」列；动销等级按商品日销判定">
|
||||
<Tooltip title="导出当前筛选下的明细（仓库 / 仓位 / 商品编码 / 库存数量 / 仓位SKU数 / 商品销量 / 分摊销量 / 商品日销 / 动销等级），仅含拣选位。按「仓位 × 商品编码」拆行；商品销量为整档销量（同一商品跨仓位重复，不可直接求和），需要求和请用「分摊销量」列；动销等级按商品日销判定">
|
||||
<Button icon={<DownloadOutlined />} onClick={handleExport} loading={exporting}>导出明细</Button>
|
||||
</Tooltip>
|
||||
</Space>
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user