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

275 lines
10 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';
/**
* 订单池边界验证(重做版):
* 1. 取消所有活跃任务(释放订单回池);
* 2. 重建混合池:满足抓取口径且未分配波次的候选,保留 8 条同结构今日前订单,其余全部改为今天;
* 3. 第一轮抓取:预期仅抓 8 条今日前订单,不用今天订单填充到 20;
* 4. 第二轮抓取:第一池清空后回落第二池,抓满 20 条今天订单;
* 5. 输出验证结论。
*
* @return {Promise<void>}
*/
const mysql = require('mysql2/promise');
const BASE_URL = 'http://127.0.0.1:6060';
const DB_CONFIG = {
host: '127.0.0.1',
port: 3307,
user: 'wms',
password: 'dspxmRwRdRbWtbm7',
database: 'wms',
};
const TODAY_TIME = '2026-09-06 12:00:00';
const KEEP_COUNT = 8;
const TODAY_START_UTC = Date.UTC(2026, 8, 5, 16, 0, 0); // 2026-09-06 00:00 +08:00
/**
* 发送 /system POST 请求。
*
* @param {string} token 登录令牌。
* @param {string} method 方法名。
* @param {Object} data 请求体。
* @return {Promise<Object>} 响应 JSON。
*/
async function sysCall(token, method, data) {
const qs = `method=${encodeURIComponent(method)}&v=1.0&timestamp=${Math.floor(Date.now() / 1000)}`;
const headers = {
'Content-Type': 'application/json',
platform: 'web',
project: 'wms',
...(token ? { Authorization: `Bearer ${token}` } : {}),
};
const res = await fetch(`${BASE_URL}/system?${qs}`, {
method: 'POST',
headers,
body: JSON.stringify(data),
});
const text = await res.text();
try {
return JSON.parse(text);
} catch (error) {
return { raw: text };
}
}
/**
* 深度优先查找对象中第一个匹配 key 的非空值。
*
* @param {*} target 待查找对象。
* @param {string} key 目标字段名。
* @return {*} 匹配值或 undefined。
*/
function deepFind(target, key) {
if (target === null || target === undefined) {
return undefined;
}
if (Array.isArray(target)) {
for (const item of target) {
const found = deepFind(item, key);
if (found !== undefined) {
return found;
}
}
return undefined;
}
if (typeof target === 'object') {
for (const [ currentKey, value ] of Object.entries(target)) {
if (currentKey === key && value !== null && value !== undefined && value !== '') {
return value;
}
}
for (const value of Object.values(target)) {
const found = deepFind(value, key);
if (found !== undefined) {
return found;
}
}
}
return undefined;
}
/**
* 取消指定任务(不存在/已取消时静默)。
*
* @param {string} token 登录令牌。
* @param {number} taskId 任务 ID。
* @return {Promise<void>}
*/
async function cancelTask(token, taskId) {
const res = await sysCall(token, 'order.wave.wavePickTaskCancelSelf', { task_id: taskId });
const count = Number(deepFind(res, 'cancelled_count') || 0);
console.log(` 取消任务 ${taskId}: cancelled_count=${count}`);
}
/**
* 执行一轮抓取(存在未完成任务时取消后重试)。
*
* @param {string} token 登录令牌。
* @param {number} round 轮次。
* @return {Promise<number>} 任务 ID。
*/
async function fetchOnce(token, round) {
const res = await sysCall(token, 'order.wave.waveStrategyFetchPda', { strategy_id: 7 });
let state = Number(deepFind(res, 'fetch_state') || 0);
let taskId = Number(deepFind(res, 'task_id') || 0);
if (state === 3 && taskId > 0) {
await cancelTask(token, taskId);
const retry = await sysCall(token, 'order.wave.waveStrategyFetchPda', { strategy_id: 7 });
state = Number(deepFind(retry, 'fetch_state') || 0);
taskId = Number(deepFind(retry, 'task_id') || 0);
}
if (state !== 1 || taskId <= 0) {
throw new Error(`第${round}轮抓取失败: state=${state}`);
}
return taskId;
}
/**
* 读取任务抓取订单的 create_at。
*
* @param {Object} connection 数据库连接。
* @param {number} taskId 任务 ID。
* @return {Promise<Array<Object>>} 订单行。
*/
async function readTaskOrders(connection, taskId) {
const [ taskOrderRows ] = await connection.query(
`SELECT order_id FROM wms_wave_pick_task_order WHERE task_id = ? ORDER BY box_no ASC`,
[ taskId ]
);
const orderIds = taskOrderRows.map(row => Number(row.order_id));
if (orderIds.length === 0) {
return [];
}
const [ orderRows ] = await connection.query(
`SELECT id, create_at FROM wms_order_delivery_100000 WHERE id IN (?) ORDER BY id ASC`,
[ orderIds ]
);
return orderRows;
}
/**
* 主流程入口。
*
* @return {Promise<void>}
*/
async function main() {
const login = await sysCall(null, 'user.login', {
username: 'liufumingren',
password: '111111',
});
const token = deepFind(login, 'token');
if (!token) {
throw new Error(`登录失败: ${JSON.stringify(login)}`);
}
console.log('[1] 登录成功');
const connection = await mysql.createConnection(DB_CONFIG);
try {
// 2. 取消所有活跃任务
const [ activeTasks ] = await connection.query(
`SELECT id FROM wms_wave_pick_task WHERE warehouse_id = 100000 AND status IN (0, 1)`
);
for (const row of activeTasks) {
await cancelTask(token, Number(row.id));
}
console.log('[2] 已取消全部活跃任务');
// 3. 重建混合池
const [ rows ] = await connection.query(
`SELECT o.id, o.create_at, o.items_hash
FROM wms_order_wave_strategy_match m
INNER JOIN wms_order_delivery_100000 o
ON o.id = m.order_id
WHERE m.warehouse_id = 100000
AND m.strategy_id = 7
AND o.wave_id = 0
AND o.step != 0
AND o.post_status = 'fin'
AND o.storage_status = 'fin'
AND o.print_status != 'fin'
AND o.status != 'cancel'
AND o.outbound_status != 'padding'
AND o.intercept_status = 'none'
AND o.lock_status = 'none'
ORDER BY o.id ASC`
);
const beforeToday = rows.filter(row => new Date(row.create_at).getTime() < TODAY_START_UTC);
console.log(`[3] 候选总数: ${rows.length},其中今日前: ${beforeToday.length}`);
const hashGroups = new Map();
for (const row of beforeToday) {
const key = String(row.items_hash || '').trim();
if (!key) continue;
if (!hashGroups.has(key)) hashGroups.set(key, []);
hashGroups.get(key).push(row);
}
// 策略 7 max_same_structure=12(仓库下调),须选同结构总数 2~12 的组
let keepGroup = null;
for (const list of hashGroups.values()) {
const groupHash = String(list[0] && list[0].items_hash || '').trim();
const [ countRows ] = await connection.query(
`SELECT COUNT(1) AS cnt FROM wms_order_delivery_100000
WHERE items_hash = ? AND wave_id = 0 AND step != 0 AND post_status = 'fin'
AND storage_status = 'fin' AND print_status != 'fin' AND status != 'cancel'
AND outbound_status != 'padding' AND intercept_status = 'none' AND lock_status = 'none'`,
[ groupHash ]
);
const totalCount = Number(countRows && countRows[0] && countRows[0].cnt || 0);
if (totalCount >= KEEP_COUNT && totalCount <= 12) {
keepGroup = list;
console.log(`[3] 选中保留组: hash=${groupHash.slice(0, 12)} 同结构总数=${totalCount}`);
break;
}
}
if (!keepGroup) {
console.log('未找到同结构总数 8~12 的今日前分组');
keepGroup = beforeToday.slice(0, KEEP_COUNT);
}
const keepIds = keepGroup.slice(0, KEEP_COUNT).map(row => Number(row.id));
const keepSet = new Set(keepIds);
const moveIds = rows.map(row => Number(row.id)).filter(id => !keepSet.has(id));
if (moveIds.length > 0) {
const [ updateResult ] = await connection.query(
`UPDATE wms_order_delivery_100000 SET create_at = ? WHERE id IN (?)`,
[ TODAY_TIME, moveIds ]
);
console.log(`[3] 保留今日前订单 ${keepIds.length} 条: [${keepIds.join(', ')}]`);
console.log(`[3] 其余 ${updateResult.affectedRows} 条已改为今天 ${TODAY_TIME}`);
}
// 4. 第一轮抓取
const firstTaskId = await fetchOnce(token, 1);
const firstOrders = await readTaskOrders(connection, firstTaskId);
const firstBeforeToday = firstOrders.filter(row => new Date(row.create_at).getTime() < TODAY_START_UTC);
const firstPassed = firstOrders.length === KEEP_COUNT && firstBeforeToday.length === KEEP_COUNT;
console.log(`[4] 第一轮任务 ${firstTaskId} 抓取订单数: ${firstOrders.length}`);
console.log(` 今日前订单数: ${firstBeforeToday.length}, 订单ID: [${firstOrders.map(row => row.id).join(', ')}]`);
console.log(` 验证(不足20不填充): ${firstPassed ? '✅ 仅抓 8 条今日前订单,未用今天订单填充' : '❌ 行为与预期不符'}`);
// 5. 第二轮抓取
const secondTaskId = await fetchOnce(token, 2);
const secondOrders = await readTaskOrders(connection, secondTaskId);
const secondToday = secondOrders.filter(row => new Date(row.create_at).getTime() >= TODAY_START_UTC);
const secondPassed = secondOrders.length === 20 && secondToday.length === 20;
console.log(`[5] 第二轮任务 ${secondTaskId} 抓取订单数: ${secondOrders.length}`);
console.log(` 今天订单数: ${secondToday.length}, 订单ID: [${secondOrders.map(row => row.id).join(', ')}]`);
console.log(` 验证(第一池清空后抓满20条今天订单): ${secondPassed ? '✅ 回落第二池并抓满 20' : '❌ 行为与预期不符'}`);
console.log('==================== 总结 ====================');
console.log(`第一轮(第一池8条): 实际 ${firstOrders.length} 条 -> ${firstPassed ? 'PASS' : 'FAIL'}`);
console.log(`第二轮(第二池今天): 实际 ${secondOrders.length} 条 -> ${secondPassed ? 'PASS' : 'FAIL'}`);
console.log(`结论: ${firstPassed && secondPassed ? '✅ 边界行为符合预期: 不足20不填充;第一池抓完才抓第二池' : '❌ 存在与预期不符的环节,请排查'}`);
} finally {
await connection.end();
}
}
main().catch(error => {
console.error(`验证失败: ${error.message}`);
process.exit(1);
});