WMS_MAIN/script/tmp-verify-intercept-order-dev.cjs
liufumingren c3f1c67592 chore(script): 沉淀波次池/报表/库存/订单本地排查脚本
新增一批一次性排查脚本(script/tmp-*.cjs),与仓库既有 script/tmp- 约定保持一致,
覆盖波次池边界与优先级核对、库位/出库报表核对、订单状态与更新范围核验等场景
2026-09-13 15:31:27 +08:00

229 lines
9.9 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use strict';
/**
* 临时端到端校验脚本(开发库,只读):库内确定拦截订单明细报表类型 interceptOrder。
*
* 校验两条链路(不做任何数据库写操作):
* A. 真实查询器链路:以 egg 真实上下文(含 orderExport 服务与配送表模型)
* 调用查询器,验证 dispatch 表位/模型解析、dispath_time 区间 SQL、meta 口径可正常执行;
* 开发库历史拦截单 dispath_time 均为 NULL(该列 2026-09-07 才上线),因此预期 0 行。
* B. 真实数据映射链路(对照 A 的非空场景):以「仅 intercept_status 过滤(不限时间)」
* 调用 orderExport.buildOrderExportPage(mode=item),取真实拦截订单明细行,
* 经 pickReportRow 裁剪后用 renderSheetByType 渲染,核对表头 46 列与数据行。
*
* 运行:node script/tmp-verify-intercept-order-dev.cjs
*/
const path = require('node:path');
const mm = require('egg-mock');
const projectRoot = path.resolve(__dirname, '..');
const interceptOrder = require(path.join(projectRoot, 'app/service/systems/report/queries/interceptOrder.js'));
const { renderSheetByType } = require(path.join(projectRoot, 'app/lib/report/render.js'));
const WAREHOUSE_ID = 100000;
let failed = 0;
const check = (condition, label, detail = '') => {
if (condition) {
console.log(` ✔ ${label}${detail ? ` | ${detail}` : ''}`);
return;
}
failed += 1;
console.log(` ✘ ${label}${detail ? ` | ${detail}` : ''}`);
};
(async () => {
mm.env('local');
const app = mm.app({ baseDir: projectRoot });
await app.ready();
const ctx = app.createAnonymousContext();
ctx.user = { store_id: WAREHOUSE_ID };
const orderExport = ctx.service.systems.orderExport;
try {
console.log('\n[A] 查询器真实链路(warehouse=%s,昨日自然日)', WAREHOUSE_ID);
const yesterdayDate = new Date();
yesterdayDate.setDate(yesterdayDate.getDate() - 1);
const bizDate = `${yesterdayDate.getFullYear()}-${String(yesterdayDate.getMonth() + 1).padStart(2, '0')}`
+ `-${String(yesterdayDate.getDate()).padStart(2, '0')}`;
const result = await interceptOrder({
ctx,
storeId: null,
warehouseId: WAREHOUSE_ID,
params: { bizDate },
});
console.log(' meta=' + JSON.stringify(result.meta));
console.log(' rows=' + result.rows.length);
check(result.meta.bizDate === bizDate, 'meta.bizDate 与入参一致', result.meta.bizDate);
check(result.meta.timeField === 'dispath_time', 'meta.timeField=dispath_time');
check(
result.meta.interceptStatus === 'intercepted_at_warehouse',
'meta.interceptStatus=intercepted_at_warehouse'
);
check(result.meta.rowCount === result.rows.length, 'meta.rowCount 与行数一致');
check(Array.isArray(result.windows) && result.windows.length === 0, 'windows 为空(无展开列)');
check(
result.meta.startTime === `${bizDate} 00:00:00` && result.meta.endTime > result.meta.startTime,
'统计区间为指定自然日整天(左闭右开)',
`${result.meta.startTime} ~ ${result.meta.endTime}`
);
// 开发库历史拦截单 dispath_time 多数为 NULL(仅补测的几单有值),此处校验口径一致性
const distinctOrderCount = new Set(result.rows.map(row => Number(row.id))).size;
check(
distinctOrderCount === result.meta.orderCount,
'meta.orderCount = 明细行去重订单数',
`orders=${distinctOrderCount}/${result.meta.orderCount}`
);
console.log('\n[B] 真实拦截订单明细映射链路(忽略时间过滤,仅验证列与取值)');
const target = orderExport.resolveExportTarget({ tableType: 'dispatch' });
const orderModel = await orderExport.getOrderModelByTableType('dispatch', WAREHOUSE_ID);
const pageResult = await orderExport.buildOrderExportPage({
page: 1,
pageSize: 5,
queryWhere: { intercept_status: 'intercepted_at_warehouse' },
order: [[ 'id', 'ASC' ]],
orderModel,
target,
warehouseId: WAREHOUSE_ID,
mode: 'item',
});
console.log(` 命中订单=${pageResult.orderCount},导出行=${pageResult.exportRows.length}`);
check(pageResult.orderCount > 0, '开发库存在库内确定拦截订单(用于映射验证)', String(pageResult.orderCount));
const reportRows = pageResult.exportRows.map(row => interceptOrder.pickReportRow(row));
const sample = reportRows[0] || {};
console.log(' 明细首行抽样=' + JSON.stringify({
id: sample.id,
delivery_order_code: sample.delivery_order_code,
item_name: sample.item_name,
item_quantity: sample.item_quantity,
waybill_code: sample.waybill_code,
outbound_status: sample.outbound_status,
create_channel: sample.create_channel,
}, null, 2));
check(
reportRows.every(row => Object.keys(row).length === interceptOrder.fields.length),
'每行键数=注册字段数',
String(interceptOrder.fields.length)
);
check(
reportRows.every(row => !Object.prototype.hasOwnProperty.call(row, 'item_image')),
'行不含商品图片列'
);
check(
reportRows.some(row => Number(row.item_quantity) > 0) || reportRows.length > 0,
'存在数据行'
);
console.log('\n[C] 渲染链路(renderSheetByType)');
const sheet = renderSheetByType({
type: 'interceptOrder',
title: '库内确定拦截订单明细',
fields: interceptOrder.fields.map(field => ({ ...field })),
rows: reportRows,
windows: [],
});
const header = sheet.rows[0];
console.log(' 表头列数=' + header.length + ',总行数=' + sheet.rows.length);
check(sheet.name === '库内确定拦截订单明细', 'sheet 名称为报表标题', sheet.name);
check(header.length === interceptOrder.fields.length, '表头列数与注册字段一致', String(header.length));
check(header[0] === '订单ID' && header[header.length - 2] === '通知拦截时间'
&& header[header.length - 1] === '库内确定拦截时间', '表头首列与末尾两列拦截时间正确');
check(sheet.rows.length === reportRows.length + 1, '单行表头 + 数据行(无展开列)');
check(
Array.isArray(sheet.merges) && sheet.merges.length === 0,
'无展开列时不需要表头合并'
);
check(
!Object.prototype.hasOwnProperty.call(sheet, 'textColumns'),
'未声明 asText,不输出 textColumns(与订单导出一致)'
);
console.log('\n[D] 附加列富化(平台交易单号 + 两列拦截时间,真实数据交叉核对)');
const sampleOrders = await orderModel.findAll({
where: { intercept_status: 'intercepted_at_warehouse' },
attributes: [ 'id', 'source_order_codes', 'intercept_time', 'dispath_time' ],
order: [[ 'id', 'DESC' ]],
limit: 5,
raw: true,
});
const timeRows = sampleOrders.map(row => ({
id: Number(row.id),
source_order_codes: '',
intercept_notice_time: '',
intercept_confirm_time: '',
}));
await interceptOrder.enrichInterceptFields({
ctx,
app: ctx.app,
orderModel,
warehouseId: WAREHOUSE_ID,
rows: timeRows,
});
const sampleIds = timeRows.map(row => String(row.id));
const logRows = await ctx.model.query(
`SELECT business_id, MIN(created_at) AS notice_time
FROM wms_operation_log
WHERE business_type = 'order'
AND operation_code = 'ORDER_INTERCEPT_REQUEST'
AND warehouse_id = :warehouseId
AND business_id IN (:ids)
GROUP BY business_id`,
{
replacements: { warehouseId: WAREHOUSE_ID, ids: sampleIds },
type: ctx.model.QueryTypes.SELECT,
}
);
const logMap = new Map((Array.isArray(logRows) ? logRows : []).map(row => [ String(row.business_id), row.notice_time ]));
const formatExpected = value => {
if (value === null || value === undefined || value === '') {
return '';
}
const date = new Date(value);
return Number.isNaN(date.getTime()) ? '' : ctx.app.formatDate(date);
};
for (const row of timeRows) {
const orderRow = sampleOrders.find(item => Number(item.id) === row.id) || {};
const expectedNotice = formatExpected(orderRow.intercept_time) || formatExpected(logMap.get(String(row.id)));
const expectedConfirm = formatExpected(orderRow.dispath_time);
const expectedSourceOrderCodes = orderRow.source_order_codes === null || orderRow.source_order_codes === undefined
? ''
: String(orderRow.source_order_codes);
console.log(
` id=${row.id} 平台交易单号=${row.source_order_codes || '(空)'} / 期望=${expectedSourceOrderCodes || '(空)'}`
+ ` | 通知拦截时间=${row.intercept_notice_time || '(空)'} / 期望=${expectedNotice || '(空)'}`
+ ` | 库内确定拦截时间=${row.intercept_confirm_time || '(空)'} / 期望=${expectedConfirm || '(空)'}`
);
check(
row.source_order_codes === expectedSourceOrderCodes,
`id=${row.id} 平台交易单号=配送表 source_order_codes 一致`
);
check(
row.intercept_notice_time === expectedNotice,
`id=${row.id} 通知拦截时间=intercept_time(为空时回落 ORDER_INTERCEPT_REQUEST 日志)一致`
);
check(
row.intercept_confirm_time === expectedConfirm,
`id=${row.id} 库内确定拦截时间=配送表 dispath_time 一致`
);
}
check(
timeRows.every(row => typeof row.source_order_codes === 'string'
&& typeof row.intercept_notice_time === 'string'
&& typeof row.intercept_confirm_time === 'string'),
'附加列均为字符串(时间列为 YYYY-MM-DD HH:mm:ss 或空串)'
);
} finally {
await app.close();
}
console.log(failed === 0 ? '\n全部校验通过' : `\n校验失败 ${failed} 项`);
process.exit(failed === 0 ? 0 : 1);
})().catch(error => {
console.error('脚本执行异常:', error && error.stack ? error.stack : error);
process.exit(1);
});