feat(wave): PDA按策略抓取增加订单池按今日0点分割,今日前订单优先出库

- getWaveStrategyFetchCandidateOrders 增加可选 createdBefore 上限过滤(不传时行为不变)

- autoPopulateWaveStrategyFetchSelections 先抓今日前订单池,清空后回落第二池;日志补充池阶段信息

- 新增 normalizeWaveStrategyFetchCreatedBefore / buildWaveStrategyFetchTodayStart

- 附带:resolveWaveScopeByWaveMeta 单品单件 wave_scope=4 映射与 pickMode 传递

- 新增边拣边分联调脚本与订单池完整验证脚本
This commit is contained in:
liufumingren 2026-09-06 02:31:07 +08:00
parent 95067aeb8a
commit 1d65d26500
3 changed files with 850 additions and 4 deletions

View File

@ -761,16 +761,21 @@ class WaveService extends OrderBaseService {
* 口径:
* - wave_type=1 且 source=0 → 1(大团购);
* - wave_type=1 且 source=2 → 3(小团购);
* - wave_type=2 且 pickMode=2 → 4(单品单件);
* - 其余(散单等)→ 2(散单)。
* 未分配波次(wave_id=0)由调用方直接置 0。
*
* @param {number|string} waveType 波次类型(1-团购 2-散单)。
* @param {number|string} source 波次来源(0-普通 1-管理后台策略 2-PDA策略)。
* @return {number} wave_scope:1-大团购 2-散单 3-小团购。
* @param {number|string} [pickMode] 拣货模式(1-小团购 2-单品单件 3-先拣后分 4-边拣边分 5-大团购)。
* @return {number} wave_scope:1-大团购 2-散单 3-小团购 4-单品单件。
*/
resolveWaveScopeByWaveMeta(waveType, source) {
resolveWaveScopeByWaveMeta(waveType, source, pickMode) {
const normalizedWaveType = Number(waveType) === 2 ? 2 : 1;
const normalizedSource = [ 0, 1, 2 ].includes(Number(source)) ? Number(source) : 0;
const normalizedPickMode = [ 1, 2, 3, 4, 5 ].includes(Number(pickMode))
? Number(pickMode)
: 0;
if (normalizedWaveType === 1 && normalizedSource === 0) {
return 1;
@ -780,6 +785,10 @@ class WaveService extends OrderBaseService {
return 3;
}
if (normalizedWaveType === 2 && normalizedPickMode === 2) {
return 4;
}
return 2;
}
@ -10692,6 +10701,40 @@ class WaveService extends OrderBaseService {
}
}
/**
* 归一化候选订单查询的创建时间上限(不含)。
*
* @param {Date|string|null} [createdBefore=null] 创建时间上限。
* @return {Date|null} 归一化后的 Date;非法输入返回 null(表示不限制)。
*/
normalizeWaveStrategyFetchCreatedBefore(createdBefore = null) {
if (createdBefore instanceof Date && !Number.isNaN(createdBefore.getTime())) {
return createdBefore;
}
if (typeof createdBefore === 'string' && createdBefore.trim()) {
const parsed = new Date(createdBefore.trim());
if (!Number.isNaN(parsed.getTime())) {
return parsed;
}
}
return null;
}
/**
* 计算今日 0 点(本地时区),作为订单池分割的时间边界。
*
* 第一订单池 = 创建时间早于今日 0 点的订单(前一天及更早订单);
* 第二订单池 = 其余订单(今日订单)。
*
* @return {Date} 今日 0 点时间。
*/
buildWaveStrategyFetchTodayStart() {
const now = new Date();
return new Date(now.getFullYear(), now.getMonth(), now.getDate());
}
/**
* 查询策略自动分流候选订单(命中策略且未分配波次)。
*
@ -10703,6 +10746,8 @@ class WaveService extends OrderBaseService {
* @param {number|string} params.strategyId 策略ID。
* @param {number|string|null} [params.minSameStructure=0] 最小同结构数量。
* @param {number|string|null} [params.maxSameStructure=null] 最大同结构数量。
* @param {Date|string|null} [params.createdBefore=null] 创建时间上限(不含),
* 仅命中创建时间早于该值的订单,用于分割第一/第二订单池;为 null 时不限制。
* @return {Promise<Array<Object>>} 候选订单数组(按 order_id 升序)。
*/
async getWaveStrategyFetchCandidateOrders(params = {}) {
@ -10717,6 +10762,7 @@ class WaveService extends OrderBaseService {
? Math.floor(maxSameStructureRaw)
: null;
const requireSameExpress = Number(params.requireSameExpress ?? 0) === 1;
const createdBefore = this.normalizeWaveStrategyFetchCreatedBefore(params.createdBefore);
const orderModel = await this.getOrderModel('pendingOrder', warehouseId);
const orderTableName = this.getModelTableSqlName(orderModel);
@ -10747,6 +10793,7 @@ class WaveService extends OrderBaseService {
AND o.outbound_status != 'padding'
AND o.intercept_status = 'none'
AND o.lock_status = 'none'
AND (:createdBefore IS NULL OR o.create_at < :createdBefore)
INNER JOIN (
SELECT
${structureExpr('src')} AS structure_key${requireSameExpress ? `, ${expressExpr('src')} AS express_key` : ''},
@ -10776,6 +10823,7 @@ class WaveService extends OrderBaseService {
strategyId,
minSameStructure,
maxSameStructure,
createdBefore,
},
type: this.ctx.model.QueryTypes.SELECT,
});
@ -11004,6 +11052,8 @@ class WaveService extends OrderBaseService {
* @param {number|string} params.waveType 波次类型(1-团购,2-散单)。
* @param {string} params.wavePrefix 波次前缀。
* @param {number|string} [params.source=0] 波次来源。
* @param {number|string} [params.pickMode] 拣货模式(1-小团购 2-单品单件 3-先拣后分 4-边拣边分 5-大团购),
* 用于散单波次区分单品单件(pickMode=2 时订单 wave_scope 写入 4)。
* @param {string} [params.claimOperator] 抓取人姓名:抓取波次(source=1/2)无需领料,
* 将该值冗余写入波次表领料人字段(claim_operator)。
* @param {Object} params.transaction 事务对象。
@ -11015,6 +11065,8 @@ class WaveService extends OrderBaseService {
const wavePrefix = String(params.wavePrefix || '').trim() || (waveType === 2 ? 'A' : 'B');
const sourceInput = Number(params.source);
const source = [ 0, 1, 2 ].includes(sourceInput) ? sourceInput : 0;
const pickModeInput = Number(params.pickMode);
const pickMode = [ 1, 2, 3, 4, 5 ].includes(pickModeInput) ? pickModeInput : 0;
const claimOperator = String(params.claimOperator || '').trim() || null;
const claimOperatorId = Number(params.claimOperatorId || 0) > 0
? Number(params.claimOperatorId)
@ -11078,7 +11130,7 @@ class WaveService extends OrderBaseService {
await orderModel.update({
wave_id: waveId,
wave_no: waveNo,
wave_scope: this.resolveWaveScopeByWaveMeta(waveType, source),
wave_scope: this.resolveWaveScopeByWaveMeta(waveType, source, pickMode),
grab_operator_id: claimOperatorId,
grab_operator: claimOperator,
}, {
@ -11169,6 +11221,11 @@ class WaveService extends OrderBaseService {
*
* 仅用于 PDA 按策略抓取场景,内部按 strategy_type + pick_mode 执行分流。
*
* 候选订单按创建时间分割为两个订单池:
* - 第一订单池:创建时间早于今日 0 点(前一天及更早订单);
* - 第二订单池:其余订单(今日订单)。
* 只有第一订单池抓取完毕(候选为空)才会抓取第二订单池,确保前一天的订单优先出库。
*
* @param {Object} params 自动分流参数。
* @param {Object} params.plan 抓取计划。
* @param {Object} params.strategyRow 策略行。
@ -11198,13 +11255,32 @@ class WaveService extends OrderBaseService {
transaction,
});
const candidateRows = await this.getWaveStrategyFetchCandidateOrders({
const candidateQueryParams = {
warehouseId,
strategyId,
minSameStructure: strategyRow.min_same_structure,
maxSameStructure: strategyRow.max_same_structure,
requireSameExpress: Number(strategyRow.require_same_express || 0),
};
// 订单池分割:第一订单池 = 创建时间早于今日 0 点(前一天及更早订单),
// 只有第一订单池抓取完毕(候选为空)才允许抓取第二订单池,
// 确保前一天的订单可以优先出库。
const todayStart = this.buildWaveStrategyFetchTodayStart();
const firstPoolRows = await this.getWaveStrategyFetchCandidateOrders({
...candidateQueryParams,
createdBefore: todayStart,
});
let candidateRows;
let candidatePoolStage = 'second';
if (firstPoolRows.length > 0) {
candidateRows = firstPoolRows;
candidatePoolStage = 'first';
} else {
candidateRows = await this.getWaveStrategyFetchCandidateOrders(candidateQueryParams);
}
const candidateCount = candidateRows.length;
if (candidateCount <= 0) {
throw new Error('未找到符合策略且未分配波次的候选订单');
@ -11220,6 +11296,8 @@ class WaveService extends OrderBaseService {
selected_order_ids: [],
removed_order_ids: [],
candidate_count: candidateCount,
candidate_pool_stage: candidatePoolStage,
first_pool_candidate_count: firstPoolRows.length,
grouped_count: groupedRows.length,
wave_prefix: '',
wave_prefix_source: '',
@ -11323,6 +11401,7 @@ class WaveService extends OrderBaseService {
waveType: 2,
wavePrefix: wavePrefixResolution.wavePrefix,
source: waveBatchSource,
pickMode,
claimOperator,
claimOperatorId,
transaction,
@ -11348,6 +11427,9 @@ class WaveService extends OrderBaseService {
wave_prefix: result.wave_prefix,
wave_prefix_source: result.wave_prefix_source,
candidate_count: result.candidate_count,
candidate_pool_stage: result.candidate_pool_stage,
first_pool_candidate_count: result.first_pool_candidate_count,
today_start: todayStart,
removed_count: result.removed_order_ids.length,
selected_count: result.selected_order_ids.length,
selected_wave_count: result.selected_wave_ids.length,
@ -11380,6 +11462,8 @@ class WaveService extends OrderBaseService {
const warehouseId = this.normalizeRequiredPositiveInteger(plan.warehouse_id, 'warehouse_id');
const strategyId = this.normalizeRequiredPositiveInteger(plan.strategy_id, 'strategy_id');
const strategyType = Number(strategyRow.strategy_type || plan.strategy_type || 0);
const pickModeInput = Number(plan.pick_mode || 0);
const pickMode = [ 1, 2, 3, 4, 5 ].includes(pickModeInput) ? pickModeInput : 0;
const operatorInfo = this.isPlainObject(plan.operator) ? plan.operator : {};
const claimOperator = String(operatorInfo.operator_name || operatorInfo.name || '').trim() || null;
const claimOperatorId = Number((operatorInfo.operator_id ?? operatorInfo.id) || 0) > 0
@ -11459,6 +11543,7 @@ class WaveService extends OrderBaseService {
waveType: 2,
wavePrefix: wavePrefixResolution.wavePrefix,
source: waveBatchSource,
pickMode,
claimOperator,
claimOperatorId,
transaction,

View File

@ -0,0 +1,234 @@
'use strict';
/**
* 完整流程验证(按正规接口):
* 1. 恢复 8 条今日前订单(1552 等)为未分配(wave_id=0),构成第一池;
* 2. 取消活跃任务;
* 3. 抓取 -> 新任务仅抓 8 条今日前订单(不足20不填充);
* 4. pickCart.bindTaskCart 绑定拣货车;
* 5. pick.wavePickTaskComplete 提交拣货完成 -> 订单不回池;
* 6. 再次抓取 -> 第一池已空,回落第二池抓满 20 条今天订单。
*
* @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_START_UTC = Date.UTC(2026, 8, 5, 16, 0, 0);
const KEEP_ORDER_IDS = [ 1552, 1757, 1859, 2229, 2555, 4705, 6260, 6488 ];
/**
* 发送 /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} 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 sysCall(token, 'order.wave.wavePickTaskCancelSelf', { task_id: 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, wave_id 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 {
// 1. 恢复 8 条今日前订单为未分配
await connection.query(
'UPDATE wms_order_delivery_100000 SET wave_id = 0 WHERE id IN (?)',
[ KEEP_ORDER_IDS ]
);
console.log(`[2] 已恢复 8 条今日前订单为未分配: [${KEEP_ORDER_IDS.join(', ')}]`);
// 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 sysCall(token, 'order.wave.wavePickTaskCancelSelf', { task_id: Number(row.id) });
}
console.log(`[3] 已取消活跃任务: [${activeTasks.map(row => row.id).join(', ')}]`);
// 3. 第一轮抓取
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 === 8 && firstBeforeToday.length === 8;
console.log(`[4] 第一轮任务 ${firstTaskId} 抓取订单数: ${firstOrders.length}`);
console.log(` 今日前订单数: ${firstBeforeToday.length}, 订单ID: [${firstOrders.map(row => row.id).join(', ')}]`);
console.log(` 验证(不足20不填充): ${firstPassed ? '✅ 仅抓 8 条今日前订单' : '❌ 与预期不符'}`);
// 4. 找一台可用拣货车并绑车
const [ cartRows ] = await connection.query(
`SELECT id, cart_code FROM wms_pick_cart
WHERE warehouse_id = 100000 AND status = 1
ORDER BY id ASC LIMIT 1`
);
if (cartRows.length === 0) {
throw new Error('仓库 100000 无可用拣货车');
}
const cartId = Number(cartRows[0].id);
const bindRes = await sysCall(token, 'pickCart.bindTaskCart', {
task_id: firstTaskId,
cart_id: cartId,
});
console.log(`[5] 绑车(cart_id=${cartId})响应: ${JSON.stringify(bindRes).slice(0, 300)}`);
// 5. 提交拣货完成(订单不回池)
const completeRes = await sysCall(token, 'pick.wavePickTaskComplete', {
task_id: firstTaskId,
mode: 1,
});
console.log(`[6] wavePickTaskComplete 响应: ${JSON.stringify(completeRes).slice(0, 400)}`);
const [ afterCompleteOrders ] = await connection.query(
'SELECT id, wave_id FROM wms_order_delivery_100000 WHERE id IN (?)',
[ KEEP_ORDER_IDS ]
);
const stayOutOfPool = afterCompleteOrders.every(row => Number(row.wave_id) > 0);
console.log(`[7] 拣货完成后订单 wave_id 保持非0(不回池): ${stayOutOfPool ? '✅' : '❌'}`);
// 6. 第二轮抓取(第一池已空,回落第二池)
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(`[8] 第二轮任务 ${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(`拣货完成不回池: ${stayOutOfPool ? 'PASS' : 'FAIL'}`);
console.log(`第二轮(第二池今天): 实际 ${secondOrders.length} 条 -> ${secondPassed ? 'PASS' : 'FAIL'}`);
console.log(`结论: ${firstPassed && stayOutOfPool && secondPassed ? '✅ 全部通过: 不足20不填充;拣货完成后订单不回池;第一池清空后回落第二池抓满20' : '❌ 存在与预期不符的环节'}`);
} finally {
await connection.end();
}
}
main().catch(error => {
console.error(`验证失败: ${error.message}`);
process.exit(1);
});

View File

@ -0,0 +1,527 @@
'use strict';
/**
* 边拣边分(batch_mode=3)策略 HTTP 联调脚本(含货主配置 OTHER 场景)。
*
* 通过 /system 入口按顺序完成:
* 1. user.login 登录获取 token(请使用仓库账号,策略配置仅仓库主体可维护);
* 2. 探测签约关系 id(优先环境变量 WMS_TEST_CONTRACT_ID,否则从签约列表自动查找);
* 3. storeWarehouse.store.getPolicyConfig 读取当前货主配置;
* 4. storeWarehouse.store.savePolicyConfig 修改货主配置:
* 默认平台 default_platform_code = OTHER(其他平台)、默认快递 default_express_code = OTHER(其他快递);
* 5. order.wave.waveStrategyCreate 创建散单-边拣边分策略;
* 6. order.pendingOrder.createOrder 创建 N 条同商品结构订单(显式 OTHER 平台 + OTHER 快递,items_hash 相同);
* 7. order.reviewOrder.reviewOrder 审核(仅当订单创建后 step=0);
* 8. order.pendingOrder.allocateExpressCode 分配快递并轮询进度(OTHER+OTHER 应成功);
* 9. order.pendingOrder.allocateStorage 分配储位并轮询进度;
* 10. order.wave.waveStrategyQuickScan 触发策略快速扫描并轮询进度;
* 11. order.wave.waveStrategyFetchPda 提交按策略抓取任务(存在未完成任务时自动取消本人任务后重试);
* 12. 负向验证:临时把货主默认快递改为非 OTHER 快递(默认 STO)→ 创建订单并分配快递,
* 预期分配不了运单号(该仓库仅有 QT+OTHER 接口配置);验证后还原货主默认快递为 OTHER。
*
* 用法(PowerShell 示例):
* $env:WMS_TEST_USERNAME='仓库账号'; $env:WMS_TEST_PASSWORD='密码';
* $env:WMS_TEST_STORE_ID='货主ID'; $env:WMS_TEST_ITEM_ID='商品库存ID';
* node .\script\tmp-wave-edge-pick-http-test.cjs
*
* 可选环境变量:
* WMS_BASE_URL 服务地址(默认 http://127.0.0.1:6060)
* WMS_TEST_CONTRACT_ID 签约关系 ID(不传则自动从签约列表探测)
* WMS_TEST_PLATFORM_CODE 货主默认平台编码(默认 OTHER)
* WMS_TEST_EXPRESS_CODE 货主默认快递编码(默认 OTHER)
* WMS_TEST_ORDER_COUNT 同结构订单数量(默认 2)
* WMS_TEST_PLAN_QTY 每条明细计划数量(默认 1)
* WMS_TEST_MIN_SAME_STRUCTURE 策略最小同结构订单数(默认 2,需 <= 订单数量)
* WMS_TEST_NEGATIVE_EXPRESS 负向验证快递编码(默认 STO)
*/
const BASE_URL = process.env.WMS_BASE_URL || 'http://127.0.0.1:6060';
const USERNAME = process.env.WMS_TEST_USERNAME || '';
const PASSWORD = process.env.WMS_TEST_PASSWORD || '';
const STORE_ID = Number(process.env.WMS_TEST_STORE_ID || 0);
const ITEM_ID = Number(process.env.WMS_TEST_ITEM_ID || 0);
const CONTRACT_ID = Number(process.env.WMS_TEST_CONTRACT_ID || 0);
const PLATFORM_CODE = String(process.env.WMS_TEST_PLATFORM_CODE || 'OTHER').trim() || 'OTHER';
const EXPRESS_CODE = String(process.env.WMS_TEST_EXPRESS_CODE || 'OTHER').trim() || 'OTHER';
const NEGATIVE_EXPRESS = String(process.env.WMS_TEST_NEGATIVE_EXPRESS || 'STO').trim() || 'STO';
const PLAN_QTY = Number(process.env.WMS_TEST_PLAN_QTY || 1);
const ORDER_COUNT = Number(process.env.WMS_TEST_ORDER_COUNT || 2);
const MIN_SAME_STRUCTURE = Number(process.env.WMS_TEST_MIN_SAME_STRUCTURE || 2);
const POLL_TIMEOUT_MS = 90 * 1000;
const POLL_INTERVAL_MS = 1500;
/**
* 发送 /system POST 请求。
*
* @param {string} method 方法名(如 order.wave.waveStrategyCreate)。
* @param {Object} [data={}] 请求体参数。
* @param {string|null} [token=null] 登录令牌。
* @return {Promise<Object>} { httpStatus, json } 响应结果。
*/
async function callSystem(method, data = {}, token = null) {
const url = `${BASE_URL}/system?method=${encodeURIComponent(method)}&v=1.0&timestamp=${Math.floor(Date.now() / 1000)}`;
const headers = {
'Content-Type': 'application/json',
};
if (token) {
headers.Authorization = `Bearer ${token}`;
}
const controller = new AbortController();
const timer = setTimeout(() => controller.abort(), 30 * 1000);
try {
const response = await fetch(url, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
platform: 'web',
project: 'wms',
...(token ? { Authorization: `Bearer ${token}` } : {}),
},
body: JSON.stringify(data),
signal: controller.signal,
});
const text = await response.text();
let json = null;
try {
json = JSON.parse(text);
} catch (error) {
json = { raw: text };
}
return { httpStatus: response.status, json };
} finally {
clearTimeout(timer);
}
}
/**
* 深度优先查找对象中第一个匹配 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 {Object} json 响应 JSON。
* @param {Function} matcher 匹配函数,接收 list 项返回 boolean。
* @return {Object|null} 命中的记录或 null。
*/
function findListRecord(json, matcher) {
const list = deepFind(json, 'list');
if (!Array.isArray(list)) {
return null;
}
return list.find(item => typeof matcher === 'function' && matcher(item)) || null;
}
/**
* 按条件轮询异步任务直到完成或超时。
*
* @param {Function} pollFn 轮询函数,返回 { done:boolean, payload:* }。
* @param {number} timeoutMs 超时毫秒数。
* @param {number} intervalMs 轮询间隔毫秒数。
* @return {Promise<Object>} { ok, payload } 最终结果。
*/
async function pollUntilDone(pollFn, timeoutMs = POLL_TIMEOUT_MS, intervalMs = POLL_INTERVAL_MS) {
const startedAt = Date.now();
let lastPayload = null;
while (Date.now() - startedAt < timeoutMs) {
const result = await pollFn();
lastPayload = result.payload;
if (result.done) {
return { ok: true, payload: lastPayload };
}
await new Promise(resolve => setTimeout(resolve, intervalMs));
}
return { ok: false, payload: lastPayload };
}
/**
* 校验脚本运行所需环境变量。
*
* @return {void}
*/
function ensureEnv() {
const missingList = [];
if (!USERNAME) {
missingList.push('WMS_TEST_USERNAME');
}
if (!PASSWORD) {
missingList.push('WMS_TEST_PASSWORD');
}
if (!Number.isInteger(STORE_ID) || STORE_ID <= 0) {
missingList.push('WMS_TEST_STORE_ID');
}
if (!Number.isInteger(ITEM_ID) || ITEM_ID <= 0) {
missingList.push('WMS_TEST_ITEM_ID');
}
if (missingList.length > 0) {
throw new Error(`缺少环境变量: ${missingList.join(', ')}`);
}
}
/**
* 探测货主在当前仓库下的签约关系 ID。
*
* 优先使用 WMS_TEST_CONTRACT_ID;否则依次从仓库侧签约列表与货主侧签约列表查找。
*
* @param {string} token 登录令牌。
* @return {Promise<number>} 签约关系 ID。
*/
async function resolveContractId(token) {
if (Number.isInteger(CONTRACT_ID) && CONTRACT_ID > 0) {
return CONTRACT_ID;
}
const warehouseListRes = await callSystem('storeWarehouse.warehouse.list', {
page: 1,
page_size: 100,
}, token);
const warehouseSide = findListRecord(warehouseListRes.json, item => Number(item && item.store_id) === STORE_ID);
if (warehouseSide && Number(warehouseSide.id) > 0) {
return Number(warehouseSide.id);
}
const storeListRes = await callSystem('storeWarehouse.store.list', {
page: 1,
page_size: 100,
}, token);
const storeSide = findListRecord(storeListRes.json, item => Number(item && item.warehouse_id) > 0);
if (storeSide && Number(storeSide.id) > 0) {
return Number(storeSide.id);
}
throw new Error(`未能从签约列表自动探测货主 ${STORE_ID} 的签约关系,请设置 WMS_TEST_CONTRACT_ID`);
}
/**
* 创建一条测试订单。
*
* @param {string} token 登录令牌。
* @param {Object} [options={}] 订单参数。
* @param {string} [options.platformCode] 系统平台编码(默认取 PLATFORM_CODE)。
* @param {string} [options.logisticsCode] 快递编码(默认取 EXPRESS_CODE)。
* @param {number} [options.suffix=0] 收件人手机与地址后缀。
* @return {Promise<number>} 订单 ID。
*/
async function createTestOrder(token, options = {}) {
const platformCode = String(options.platformCode || PLATFORM_CODE).trim();
const hasLogisticsCode = options.logisticsCode !== undefined && options.logisticsCode !== null;
const logisticsCode = hasLogisticsCode ? String(options.logisticsCode).trim() : '';
const suffix = Number(options.suffix || 0);
const items = [{ item_id: ITEM_ID, plan_qty: PLAN_QTY }];
const body = {
store_id: STORE_ID,
name: '联调测试收件人',
mobile: `1380000${String(suffix).padStart(4, '0')}`,
detail_address: `联调测试地址${suffix + 1}号`,
province: '广东省',
city: '广州市',
area: '天河区',
sys_platform_code: platformCode,
items,
};
if (hasLogisticsCode) {
body.logistics_code = logisticsCode;
}
const orderRes = await callSystem('order.pendingOrder.createOrder', body, token);
const orderId = Number(deepFind(orderRes.json, 'order_id') || 0);
if (!Number.isInteger(orderId) || orderId <= 0) {
throw new Error(`订单创建失败,响应: ${JSON.stringify(orderRes.json)}`);
}
return orderId;
}
/**
* 主流程入口。
*
* @return {Promise<void>}
*/
async function main() {
ensureEnv();
console.log(`[联调] 目标服务: ${BASE_URL}`);
console.log(`[联调] 货主ID: ${STORE_ID},商品ID: ${ITEM_ID},订单数: ${ORDER_COUNT}`);
console.log(`[联调] 目标平台: ${PLATFORM_CODE},目标快递: ${EXPRESS_CODE},负向快递: ${NEGATIVE_EXPRESS}`);
// 1. 登录
const loginRes = await callSystem('user.login', {
username: USERNAME,
password: PASSWORD,
});
const token = deepFind(loginRes.json, 'token');
if (!token) {
throw new Error(`登录失败,响应: ${JSON.stringify(loginRes.json)}`);
}
console.log('[1/12] 登录成功,已获取 token');
// 2. 探测签约关系 ID
const contractId = await resolveContractId(token);
console.log(`[2/12] 签约关系 ID: ${contractId}`);
// 3. 读取当前货主配置
const configRes = await callSystem('storeWarehouse.store.getPolicyConfig', { id: contractId }, token);
const currentPolicy = deepFind(configRes.json, 'policy_config');
const currentPolicyObject = currentPolicy && typeof currentPolicy === 'object' && !Array.isArray(currentPolicy)
? currentPolicy
: {};
console.log(`[3/12] 当前货主配置: ${JSON.stringify(currentPolicyObject).slice(0, 300)}`);
// 4. 修改货主配置:默认平台/默认快递改为 OTHER(其他平台/其他快递)
const updatedPolicy = {
...currentPolicyObject,
default_platform_code: PLATFORM_CODE,
default_express_code: EXPRESS_CODE,
};
const saveConfigRes = await callSystem('storeWarehouse.store.savePolicyConfig', {
id: contractId,
policy_config: updatedPolicy,
}, token);
const savedPolicy = deepFind(saveConfigRes.json, 'policy_config');
const savedDefaultPlatform = String(savedPolicy && savedPolicy.default_platform_code || '').trim();
const savedDefaultExpress = String(savedPolicy && savedPolicy.default_express_code || '').trim();
console.log(`[4/12] 货主配置已更新: 默认平台=${savedDefaultPlatform}, 默认快递=${savedDefaultExpress}`);
if (savedDefaultPlatform !== PLATFORM_CODE || savedDefaultExpress !== EXPRESS_CODE) {
console.warn(`[4/12] 警告: 保存结果与预期不一致,响应: ${JSON.stringify(saveConfigRes.json)}`);
}
// 5. 创建边拣边分策略
const strategyName = `HTTP联调-边拣边分-${Date.now()}`;
const strategyRes = await callSystem('order.wave.waveStrategyCreate', {
strategy_name: strategyName,
strategy_type: 1,
batch_mode: 3,
status: 1,
min_same_structure: MIN_SAME_STRUCTURE,
require_same_express: false,
batch_max_orders: 20,
batch_max_skus: 50,
description: 'HTTP 联调用边拣边分策略',
}, token);
const strategyId = Number(deepFind(strategyRes.json, 'id') || 0);
if (!Number.isInteger(strategyId) || strategyId <= 0) {
throw new Error(`策略创建失败,响应: ${JSON.stringify(strategyRes.json)}`);
}
console.log(`[5/12] 策略创建成功: id=${strategyId}, name=${strategyName}`);
// 6. 创建同结构订单(显式 OTHER 平台 + OTHER 快递)
const orderIds = [];
for (let index = 0; index < ORDER_COUNT; index += 1) {
const orderId = await createTestOrder(token, {
platformCode: PLATFORM_CODE,
logisticsCode: EXPRESS_CODE,
suffix: index,
});
orderIds.push(orderId);
}
console.log(`[6/12] 同结构订单创建成功: order_ids=[${orderIds.join(', ')}]`);
// 7. 若存在待审核订单则审核
let needReview = false;
for (const orderId of orderIds) {
const detailRes = await callSystem('order.pendingOrder.detail', { id: orderId }, token);
const step = Number(deepFind(detailRes.json, 'step') || 0);
if (step === 0) {
needReview = true;
break;
}
}
if (needReview) {
const reviewRes = await callSystem('order.reviewOrder.reviewOrder', { ids: orderIds }, token);
console.log(`[7/12] 订单审核完成: ${JSON.stringify(reviewRes.json)}`);
} else {
console.log('[7/12] 订单无需审核(step 已非 0),跳过');
}
// 8. 分配快递并轮询(OTHER 平台 + OTHER 快递应成功)
const expressRes = await callSystem('order.pendingOrder.allocateExpressCode', { ids: orderIds }, token);
const expressTaskId = deepFind(expressRes.json, 'task_id');
if (!expressTaskId) {
throw new Error(`快递分配提交失败,响应: ${JSON.stringify(expressRes.json)}`);
}
const expressPoll = await pollUntilDone(async () => {
const progressRes = await callSystem('order.pendingOrder.allocateExpressCodeTaskProgress', { task_id: expressTaskId }, token);
const status = String(deepFind(progressRes.json, 'status') || '');
const progress = Number(deepFind(progressRes.json, 'progress') || 0);
return {
done: [ 'success', 'failed', 'error', 'finish' ].includes(status) || progress >= 100,
payload: progressRes.json,
};
});
if (!expressPoll.ok) {
console.warn('[8/12] 快递分配轮询超时,可能仍在中途,请稍后复查');
} else {
console.log(`[8/12] 快递分配任务结束: ${JSON.stringify(expressPoll.payload).slice(0, 300)}`);
}
// 9. 分配储位并轮询
const storageRes = await callSystem('order.pendingOrder.allocateStorage', { order_ids: orderIds }, token);
const requestId = deepFind(storageRes.json, 'request_id');
if (!requestId) {
throw new Error(`储位分配提交失败,响应: ${JSON.stringify(storageRes.json)}`);
}
const storagePoll = await pollUntilDone(async () => {
const progressRes = await callSystem('order.pendingOrder.allocateStorageProgress', { request_id: requestId }, token);
const status = String(deepFind(progressRes.json, 'status') || '');
const progress = Number(deepFind(progressRes.json, 'progress') || 0);
return {
done: [ 'success', 'failed', 'error', 'finish' ].includes(status) || progress >= 100,
payload: progressRes.json,
};
});
if (!storagePoll.ok) {
console.warn('[9/12] 储位分配轮询超时,可能仍在中途,请稍后复查');
} else {
console.log(`[9/12] 储位分配任务结束: ${JSON.stringify(storagePoll.payload).slice(0, 300)}`);
}
// 10. 快速扫描并轮询
const scanRes = await callSystem('order.wave.waveStrategyQuickScan', {}, token);
const scanTaskId = deepFind(scanRes.json, 'task_id');
if (!scanTaskId) {
throw new Error(`快速扫描提交失败,响应: ${JSON.stringify(scanRes.json)}`);
}
const scanPoll = await pollUntilDone(async () => {
const progressRes = await callSystem('order.wave.waveStrategyQuickScanTaskProgress', { task_id: scanTaskId }, token);
const state = String(deepFind(progressRes.json, 'state') || '');
return {
done: [ 'success', 'failed' ].includes(state),
payload: progressRes.json,
};
});
if (!scanPoll.ok) {
throw new Error(`快速扫描超时: ${JSON.stringify(scanPoll.payload)}`);
}
const matchedCount = Number(deepFind(scanPoll.payload, 'matched_order_count') || 0);
const unmatchedCount = Number(deepFind(scanPoll.payload, 'unmatched_order_count') || 0);
console.log(`[10/12] 快速扫描完成: matched=${matchedCount}, unmatched=${unmatchedCount}`);
if (matchedCount <= 0) {
console.warn('[10/12] 提示: matched=0。订单可能已被自动扫描(wave_strategy_version 与当前一致,不在扫描范围),以 PDA 抓取结果为准');
}
// 11. PDA 按策略抓取(存在未完成任务时先取消本人任务再重试)
let fetchRes = await callSystem('order.wave.waveStrategyFetchPda', { strategy_id: strategyId }, token);
let flag = String(deepFind(fetchRes.json, 'flag') || '');
let fetchState = Number(deepFind(fetchRes.json, 'fetch_state') || 0);
let taskId = deepFind(fetchRes.json, 'task_id');
let taskNo = deepFind(fetchRes.json, 'task_no');
if (fetchState === 3 && Number(taskId) > 0) {
console.log(`[11/12] 检测到未完成任务 ${taskId}(${taskNo || ''}),先取消本人任务后重试`);
const cancelRes = await callSystem('order.wave.wavePickTaskCancelSelf', { task_id: Number(taskId) }, token);
console.log(`[11/12] 取消任务响应: ${JSON.stringify(cancelRes.json).slice(0, 300)}`);
fetchRes = await callSystem('order.wave.waveStrategyFetchPda', { strategy_id: strategyId }, token);
flag = String(deepFind(fetchRes.json, 'flag') || '');
fetchState = Number(deepFind(fetchRes.json, 'fetch_state') || 0);
taskId = deepFind(fetchRes.json, 'task_id');
taskNo = deepFind(fetchRes.json, 'task_no');
}
console.log(`[11/12] PDA 抓取响应: ${JSON.stringify(fetchRes.json)}`);
// 12. 负向验证:临时把货主默认快递改为非 OTHER 快递,预期分配不了运单号
let negativeAllocated = null;
try {
console.log(`[12/12] 负向验证开始: 临时改货主默认快递为 ${NEGATIVE_EXPRESS}`);
const negativeConfigRes = await callSystem('storeWarehouse.store.savePolicyConfig', {
id: contractId,
policy_config: {
...currentPolicyObject,
default_platform_code: PLATFORM_CODE,
default_express_code: NEGATIVE_EXPRESS,
},
}, token);
const negativeDefaultExpress = String(deepFind(negativeConfigRes.json, 'default_express_code') || '').trim();
if (negativeDefaultExpress !== NEGATIVE_EXPRESS) {
throw new Error(`负向配置切换失败: ${JSON.stringify(negativeConfigRes.json)}`);
}
const negativeOrderId = await createTestOrder(token, {
platformCode: PLATFORM_CODE,
logisticsCode: null,
suffix: ORDER_COUNT + 99,
});
const negativeDetailRes = await callSystem('order.pendingOrder.detail', { id: negativeOrderId }, token);
const negativeStep = Number(deepFind(negativeDetailRes.json, 'step') || 0);
if (negativeStep === 0) {
await callSystem('order.reviewOrder.reviewOrder', { ids: [ negativeOrderId ] }, token);
}
const negativeExpressRes = await callSystem('order.pendingOrder.allocateExpressCode', { ids: [ negativeOrderId ] }, token);
const negativeTaskId = deepFind(negativeExpressRes.json, 'task_id');
if (!negativeTaskId) {
throw new Error(`负向订单快递分配提交失败: ${JSON.stringify(negativeExpressRes.json)}`);
}
const negativePoll = await pollUntilDone(async () => {
const progressRes = await callSystem('order.pendingOrder.allocateExpressCodeTaskProgress', { task_id: negativeTaskId }, token);
const status = String(deepFind(progressRes.json, 'status') || '');
const progress = Number(deepFind(progressRes.json, 'progress') || 0);
return {
done: [ 'success', 'failed', 'error', 'finish' ].includes(status) || progress >= 100,
payload: progressRes.json,
};
});
const negativeStatus = String(deepFind(negativePoll.payload, 'status') || '');
negativeAllocated = negativePoll.ok && negativeStatus === 'success';
console.log(`[12/12] 负向订单(${PLATFORM_CODE}+${NEGATIVE_EXPRESS})分配结果: ${JSON.stringify(negativePoll.payload).slice(0, 300)}`);
} catch (error) {
console.warn(`[12/12] 负向验证执行异常(不影响主流程): ${error.message}`);
} finally {
await callSystem('storeWarehouse.store.savePolicyConfig', {
id: contractId,
policy_config: {
...currentPolicyObject,
default_platform_code: PLATFORM_CODE,
default_express_code: EXPRESS_CODE,
},
}, token).catch(error => {
console.warn(`[12/12] 还原货主配置失败: ${error.message}`);
});
console.log(`[12/12] 货主配置已还原: 默认平台=${PLATFORM_CODE}, 默认快递=${EXPRESS_CODE}`);
}
console.log('==================== 联调总结 ====================');
console.log(`策略ID: ${strategyId}(batch_mode=3 边拣边分)`);
console.log(`订单: [${orderIds.join(', ')}]`);
console.log(`快速扫描命中订单数: ${matchedCount}`);
console.log(`PDA 抓取: flag=${flag}, fetch_state=${fetchState}, task_id=${taskId || '无'}, task_no=${taskNo || '无'}`);
const passed = flag === 'success' && (fetchState === 1 || fetchState === 3);
console.log(`结论: ${passed ? '策略命中,抓取任务创建成功 ✅' : '未达成预期,请根据上述响应排查 ❌'}`);
if (negativeAllocated !== null) {
console.log(`负向验证: ${PLATFORM_CODE}+${NEGATIVE_EXPRESS} ${negativeAllocated ? '居然分配成功(与预期不符,需排查)❌' : '分配不了运单号(符合预期)✅'}`);
}
}
main().catch(error => {
console.error(`[联调] 执行失败: ${error.message}`);
process.exit(1);
});