From 2555f3bb4df9c89c2fdde2c03cf4625a6e1f2ef7 Mon Sep 17 00:00:00 2001 From: liufumingren Date: Sun, 13 Sep 2026 15:29:51 +0800 Subject: [PATCH] =?UTF-8?q?fix(openapi):=20deliveryorder.confirm=20?= =?UTF-8?q?=E5=9B=9E=E8=B0=83=20appKey=20=E6=8C=89=E8=B4=A7=E4=B8=BB?= =?UTF-8?q?=E5=90=88=E7=BA=A6=E5=8F=8D=E6=9F=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 背景:order_storage_allocation 构造的 routeContext 不含 appKey, finalizeLocalChannelOrdersInternal 的 if(appKey) 门禁导致 API 同步链路的 deliveryorder.confirm 从未真正发出;订单表 from_key 也兜不住 (normalizeOrderFromKey 仅接受整数,字符串 app_key 被归一化为 null) - order_async.js 新增 resolveOpenApiAppByStoreInternal:口径与入库单 _sendOpenApiCallback 对齐(wms_store_warehouse auth_status=2 → wms_api_app is_enabled=1 且 callback_url 非空) - notifyApiDeliveryOrderConfirmsInternal 逐单解析 appKey:context.appKey 非空优先 (不触发反查),缺失时按 orderRow.store_id 反查并按货主缓存(同批次无 N+1); 解析不到 appKey 的订单 warn 后跳过、不发请求 - 补充回调成功 info 日志(含 appKey) - 文档:methods/openapi_callback.json 1.2.0 → 1.3.0、变更记录 methods/changes/openapi_callback.json、docs/openapi-callback-events.md、 AI_METHOD_ROUTING.md 同步 - test: order_async.openapi.callback.test.js 覆盖 context.appKey 为空时反查发送 --- AI_METHOD_ROUTING.md | 2 +- app/service/systems/order_async.js | 156 +++++++-- docs/openapi-callback-events.md | 3 +- methods/changes/openapi_callback.json | 14 + methods/openapi_callback.json | 7 +- .../order_async.openapi.callback.test.js | 320 +++++++++++++++++- 6 files changed, 472 insertions(+), 30 deletions(-) diff --git a/AI_METHOD_ROUTING.md b/AI_METHOD_ROUTING.md index f3f7429..ae5e9ab 100644 --- a/AI_METHOD_ROUTING.md +++ b/AI_METHOD_ROUTING.md @@ -229,7 +229,7 @@ rg "class .*Service|module.exports" app/service/qimenMethods |---|---|---|---| | `entry_order_direct_inbound_completed` | `entryorder.confirm` | 直入入库(API 来源,`source_type=API`)完成后回传 | `app/service/systems/inbound_direct_log.js`(`qimenEntrySync` → `_sendOpenApiCallback`,约 1470 行) | | `entry_order_receiving_matched` | `entryorder.match` | 入库单匹配收货单完成后回传(API 来源) | `app/service/systems/receiving_entry_match.js`(`_sendCallback` → `_sendOpenApiCallback`,约 1864 行) | -| `order_completed` | `deliveryorder.confirm` | API 渠道订单同步(出库)完成后逐单触发(仅对 `syncResults` 中 `status==='success'` 的订单,成功 N 单 = N 次回调;fire-and-forget,失败仅 warn) | `app/service/systems/order_async.js`(`finalizeLocalChannelOrdersInternal` → `notifyApiDeliveryOrderConfirmsInternal`) | +| `order_completed` | `deliveryorder.confirm` | API 渠道订单同步(出库)完成后逐单触发(仅对 `syncResults` 中 `status==='success'` 的订单,成功 N 单 = N 次回调;fire-and-forget,失败仅 warn)。发送用 appKey 优先取调用上下文 `context.appKey`,缺失时按订单货主(`store_id`+`warehouse_id`)合约反查 `wms_store_warehouse(auth_status=2)` → `wms_api_app(is_enabled=1 且 callback_url 非空)` 的 `self_app_key`(同批次按货主缓存),解析不到则跳过该订单不发(此前 routeContext 缺 appKey 导致该回调从未发出,2026-09-13 已修复) | `app/service/systems/order_async.js`(`finalizeLocalChannelOrdersInternal` → `notifyApiDeliveryOrderConfirmsInternal`) | | `stockout_completed` | `stockout.confirm` | 出库单确认回传(API 来源,`source_type=API`) | `app/service/systems/order_async.js`(`notifyStockoutExternalInternal` → `buildStockoutConfirmDataInternal`) | | `order_cancelled` | `deliveryorder.cancel` | 订单取消成功后触发(fire-and-forget;出站事件名与入站方法 `order.cancel` 区分,避免 `callback_url` 误指向 `/openapi` 时被路由到取消单据接口;**无奇门对应接口**,按 `deliveryOrder` 节点约定自定义,`status` 固定 `CANCELED`) | `app/service/openapiMethods/order.js`(`cancel`,约 296 行) | diff --git a/app/service/systems/order_async.js b/app/service/systems/order_async.js index 58dc38c..418c84c 100644 --- a/app/service/systems/order_async.js +++ b/app/service/systems/order_async.js @@ -857,6 +857,80 @@ async function processManualOrderInternal(service, orderModel, orderItemsModel, }; } +/** + * 按订单货主合约反查可用的 OpenAPI 应用配置(ApiApp)。 + * + * 口径与入库单回调 _sendOpenApiCallback 对齐: + * 先按 store_id + warehouse_id + auth_status=2 查 StoreWarehouse 授权关系, + * 再按 contract_id 查启用(is_enabled=1)且配置了 callback_url 的 ApiApp。 + * 未找到授权关系 / 无可用 ApiApp 配置时返回 null 并记录 warn 日志。 + * + * @param {Object} service 订单异步服务实例。 + * @param {number|string} storeId 货主 ID。 + * @param {number|string} warehouseId 仓库 ID。 + * @return {Promise} { appKey, selfAppSecret, callbackUrl },未找到可用配置时返回 null。 + */ +async function resolveOpenApiAppByStoreInternal(service, storeId, warehouseId) { + const normalizedStoreId = Number(storeId || 0); + const normalizedWarehouseId = Number(warehouseId || 0); + const storeWarehouseModel = service.ctx.model && service.ctx.model.StoreWarehouse; + const apiAppModel = service.ctx.model && service.ctx.model.ApiApp; + + if (!Number.isFinite(normalizedStoreId) || normalizedStoreId <= 0 + || !Number.isFinite(normalizedWarehouseId) || normalizedWarehouseId <= 0 + || !storeWarehouseModel || typeof storeWarehouseModel.findOne !== 'function' + || !apiAppModel || typeof apiAppModel.findOne !== 'function') { + service.ctx.logger.warn('[OrderAsyncService.resolveOpenApiAppByStore] 缺少货主/仓库上下文或数据模型不可用,无法反查 ApiApp', { + storeId: normalizedStoreId, + warehouseId: normalizedWarehouseId, + }); + return null; + } + + const { Op } = service.app.Sequelize; + + const storeWarehouse = await storeWarehouseModel.findOne({ + where: { + store_id: normalizedStoreId, + warehouse_id: normalizedWarehouseId, + auth_status: 2, + }, + attributes: [ 'id' ], + raw: true, + }); + + if (!storeWarehouse) { + service.ctx.logger.warn(`[OrderAsyncService] OpenAPI回调:未找到授权关系 storeId=${normalizedStoreId} warehouseId=${normalizedWarehouseId}`); + return null; + } + + const apiApp = await apiAppModel.findOne({ + where: { + contract_id: storeWarehouse.id, + is_enabled: 1, + callback_url: { + [Op.and]: [ + { [Op.ne]: null }, + { [Op.ne]: '' }, + ], + }, + }, + attributes: [ 'self_app_key', 'self_app_secret', 'callback_url' ], + raw: true, + }); + + if (!apiApp || !apiApp.callback_url) { + service.ctx.logger.warn(`[OrderAsyncService] OpenAPI回调:未找到有效ApiApp配置 storeId=${normalizedStoreId} warehouseId=${normalizedWarehouseId} contractId=${storeWarehouse.id}`); + return null; + } + + return { + appKey: String(apiApp.self_app_key || '').trim(), + selfAppSecret: String(apiApp.self_app_secret || '').trim(), + callbackUrl: String(apiApp.callback_url || '').trim(), + }; +} + /** * 逐单发送 API 渠道订单确认回调(deliveryorder.confirm)。 * @@ -865,11 +939,14 @@ async function processManualOrderInternal(service, orderModel, orderItemsModel, * 每个同步成功的订单发送一次 OpenAPI 回调;单订单组装/发送失败 * 仅记录 warn 日志,不影响其他订单与主流程。 * + * appKey 解析优先级:context.appKey 非空时优先使用(不触发合约反查); + * 缺失时按订单货主(orderRow.store_id)合约反查 ApiApp 的 self_app_key。 + * 解析不到 appKey 的订单仅 warn 后跳过,不发请求(保持既有门禁语义)。 + * * @param {Object} service 订单异步服务实例。 * @param {Object} options 通知参数。 - * @param {string} options.appKey 应用 app_key。 * @param {number} options.warehouseId 仓库 ID。 - * @param {Object} options.context 同步上下文(透传给报文组装)。 + * @param {Object} options.context 同步上下文(appKey 可选,缺失时按订单货主合约反查)。 * @param {Array} options.successResults 同步成功结果列表。 * @param {Map} options.orderMap 订单 ID 到主表记录的映射。 * @param {Map>} options.itemsByOrderId 订单 ID 到明细列表的映射。 @@ -877,7 +954,6 @@ async function processManualOrderInternal(service, orderModel, orderItemsModel, */ async function notifyApiDeliveryOrderConfirmsInternal(service, options = {}) { const { - appKey, warehouseId, context = {}, successResults = [], @@ -896,6 +972,11 @@ async function notifyApiDeliveryOrderConfirmsInternal(service, options = {}) { return; } + // 上下文 appKey 非空时优先使用,保持既有语义,不触发合约反查 + const contextAppKey = String(context.appKey || '').trim(); + // 逐货主缓存合约反查结果:同一批次同货主只查一次库 + const appByStoreCache = new Map(); + // 一次性批量读取运单号(单次查询,避免逐单 N+1), // 与 syncQmOrdersInternal 的加载方式保持一致 const waybillCodeMap = await buildOrderWaybillCodeMapInternal(service, successOrderIds, warehouseId); @@ -927,17 +1008,50 @@ async function notifyApiDeliveryOrderConfirmsInternal(service, options = {}) { continue; } + // 逐单解析发送用 appKey:context.appKey 优先,缺失时按订单货主合约反查; + // 解析不到 appKey 的订单跳过,不发请求(保留门禁语义) + let resolvedAppKey = contextAppKey; + if (!resolvedAppKey) { + const storeId = Number(orderRow.store_id) || 0; + if (storeId <= 0) { + service.ctx.logger.warn(`[OrderAsyncService] deliveryorder.confirm 回调跳过:订单缺少货主 store_id orderId=${orderId}`, { + deliveryOrderCode: String(orderRow.delivery_order_code || '').trim(), + }); + continue; + } + + if (!appByStoreCache.has(storeId)) { + appByStoreCache.set(storeId, await resolveOpenApiAppByStoreInternal(service, storeId, warehouseId)); + } + + const resolvedApp = appByStoreCache.get(storeId); + if (!resolvedApp || !String(resolvedApp.appKey || '').trim()) { + service.ctx.logger.warn(`[OrderAsyncService] deliveryorder.confirm 回调跳过:货主无可用 ApiApp 配置 orderId=${orderId} storeId=${storeId}`, { + deliveryOrderCode: String(orderRow.delivery_order_code || '').trim(), + }); + continue; + } + + resolvedAppKey = String(resolvedApp.appKey).trim(); + } + const callbackResult = await callbackService.sendByAppKey({ - appKey, + appKey: resolvedAppKey, event: 'deliveryorder.confirm', request: requestData.request, }); if (!callbackResult || callbackResult.success !== true) { service.ctx.logger.warn(`[OrderAsyncService] deliveryorder.confirm 回调失败 orderId=${orderId}`, { + appKey: resolvedAppKey, deliveryOrderCode: String(orderRow.delivery_order_code || '').trim(), error: callbackResult && callbackResult.error, }); + } else { + service.ctx.logger.info(`[OrderAsyncService] deliveryorder.confirm 回调成功 orderId=${orderId}`, { + appKey: resolvedAppKey, + deliveryOrderCode: String(orderRow.delivery_order_code || '').trim(), + }); } } catch (error) { service.ctx.logger.warn(`[OrderAsyncService] deliveryorder.confirm 回调异常 orderId=${orderId}`, { @@ -955,7 +1069,7 @@ async function notifyApiDeliveryOrderConfirmsInternal(service, options = {}) { * @param {Object} service 订单异步服务实例。 * @param {string} createChannel 创建渠道(MANUAL / API)。 * @param {Object} [groupedOrder] 分组后的订单(含 order_ids / order_count / orders)。 - * @param {Object} [context] 同步上下文(含 warehouseId / appKey / request_id)。 + * @param {Object} [context] 同步上下文(含 warehouseId / request_id;appKey 可选,缺失时按订单货主合约反查)。 * @param {string} [syncTarget] 同步目标(internal / api)。 * @return {Promise} 同步结果(含 success_count / failed_count / sync_results 等)。 */ @@ -1080,30 +1194,26 @@ async function finalizeLocalChannelOrdersInternal(service, createChannel, groupe const failedCount = syncResults.filter(item => item.status === 'failed').length; const overallSuccess = failedCount === 0 && successCount === syncResults.length; - // 同步成功后触发 OpenAPI 回调通知(fire-and-forget,不阻塞主流程) + // 同步成功后触发 OpenAPI 回调通知(fire-and-forget,不阻塞主流程)。 + // appKey 不在此处统一解析:context.appKey 非空时优先使用,缺失时由 + // notifyApiDeliveryOrderConfirmsInternal 按订单货主合约逐单反查(多货主批次各自解析), + // 解析不到 appKey 的订单仅 warn 后跳过,不发请求(保留门禁语义)。 if (createChannel === CREATE_CHANNEL_API && successCount > 0) { try { const callbackService = service.ctx.service.openapi && service.ctx.service.openapi.callback; if (callbackService && typeof callbackService.sendByAppKey === 'function') { - const appKey = String(context.appKey || '').trim(); + const successResults = syncResults.filter(item => item.status === 'success'); - if (appKey) { - // 逐单发送 deliveryorder.confirm:只对同步成功的订单发送, - // 报文与奇门 taobao.qimen.deliveryorder.confirm 的 request 节点完全一致 - const successResults = syncResults.filter(item => item.status === 'success'); - - notifyApiDeliveryOrderConfirmsInternal(service, { - appKey, - warehouseId, - context, - successResults, - orderMap, - itemsByOrderId, - }).catch(err => { - service.ctx.logger.warn(`[OrderAsyncService] OpenAPI 回调忽略失败: ${err.message}`); - }); - } + notifyApiDeliveryOrderConfirmsInternal(service, { + warehouseId, + context, + successResults, + orderMap, + itemsByOrderId, + }).catch(err => { + service.ctx.logger.warn(`[OrderAsyncService] OpenAPI 回调忽略失败: ${err.message}`); + }); } } catch (err) { service.ctx.logger.warn(`[OrderAsyncService] 触发回调异常,不影响主流程: ${err.message}`); diff --git a/docs/openapi-callback-events.md b/docs/openapi-callback-events.md index df5c794..840fe8a 100644 --- a/docs/openapi-callback-events.md +++ b/docs/openapi-callback-events.md @@ -193,7 +193,7 @@ app_key=APP2024011514301234&method=entryorder.confirm×tamp=1758047400&v=1.0 - label:订单发货完成 - description:订单同步(出库)完成后触发,对应奇门 `taobao.qimen.deliveryorder.confirm` - 触发实现:`app/service/systems/order_async.js#finalizeLocalChannelOrdersInternal`(`syncApiOrders` 处理链,触发条件不变:`createChannel=API` 且 `successCount>0`)→ `notifyApiDeliveryOrderConfirmsInternal`(fire-and-forget,失败仅 warn) -- 发送途径:`sendByAppKey`(按 `app_key` 解析) +- 发送途径:`sendByAppKey`;发送用 appKey 解析优先级:调用上下文 `context.appKey` 非空时优先(**不触发合约反查**),缺失时按订单货主(`store_id` + `warehouse_id`)合约反查 —— `wms_store_warehouse(auth_status=2)` → `wms_api_app(is_enabled=1 且 callback_url 非空)` 的 `self_app_key`(`resolveOpenApiAppByStoreInternal`,口径与入库单回调 `inbound_direct_log.js#_sendOpenApiCallback` 对齐);同一批次按货主 `Map` 缓存(N 个成功单 / M 个货主 → 2M 次查询,无 N+1) - **逐单发送语义(2026-09-13 变化)**: | 维度 | 改动前 | 改动后 | @@ -204,6 +204,7 @@ app_key=APP2024011514301234&method=entryorder.confirm×tamp=1758047400&v=1.0 | 失败处理 | 不阻塞主流程 | 单订单组装/发送失败仅 warn,不影响其他订单与主流程 | - 查询开销:复用原有主表+明细查询,新增 1 次运单号批量查询(`buildOrderWaybillCodeMapInternal`,强制同仓校验,无 N+1) +- **appKey 门禁修复(2026-09-13)**:此前 `order_storage_allocation.js` 构造的 `routeContext` 不含 `appKey`,而 `finalizeLocalChannelOrdersInternal` 内有 `if (appKey)` 门禁,导致 `syncOrderIds(API)` 链路的 `deliveryorder.confirm` **从未真正发出过请求**;订单 `wms_order_delivery.from_key` 也兜不住(`normalizeOrderFromKey` 只接受整数,字符串 app_key 被归一化为 null)。本次改为按货主合约反查 appKey 修复。解析不到 appKey(订单缺 `store_id` / 无授权关系 / 无「启用且 callback_url 非空」的 ApiApp)的订单 warn 后跳过、不发请求;同步失败的订单不发送 - `request` 结构(注册表 `request` 模板口径): ```json diff --git a/methods/changes/openapi_callback.json b/methods/changes/openapi_callback.json index 6bbe05e..fd8ab09 100644 --- a/methods/changes/openapi_callback.json +++ b/methods/changes/openapi_callback.json @@ -1,4 +1,18 @@ [ + { + "version": "2026.09.13-openapi-callback-deliveryorder-confirm-appkey-resolve", + "date": "2026-09-13", + "type": "updated", + "summary": "同步 deliveryorder.confirm 触发条件(appKey 解析规则):发送用 appKey 由仅依赖调用上下文 context.appKey 改为「context.appKey 非空优先,缺失时按订单货主(store_id + warehouse_id)合约反查 wms_store_warehouse(auth_status=2) → wms_api_app(is_enabled=1 且 callback_url 非空) 的 self_app_key,同批次按货主缓存无 N+1」;解析不到 appKey 的订单 warn 后跳过、不发送。修复此前 routeContext 不含 appKey 导致该回调从未真正发出的问题。文档版本 1.2.0 → 1.3.0。", + "methods": [ + "deliveryorder.confirm" + ], + "notes": [ + "背景:order_storage_allocation.js 构造的 routeContext 不含 appKey,finalizeLocalChannelOrdersInternal 内 if(appKey) 门禁使 syncOrderIds(API) 链路的 deliveryorder.confirm 从未真正发出请求;订单 wms_order_delivery.from_key 兜不住(normalizeOrderFromKey 仅接受整数,字符串 app_key 被归一化为 null)", + "实现:order_async.js 新增 resolveOpenApiAppByStoreInternal(口径与 inbound_direct_log.js#_sendOpenApiCallback 对齐);notifyApiDeliveryOrderConfirmsInternal 逐单解析 appKey:context.appKey 优先(不触发反查)→ 按 orderRow.store_id 合约反查 → 逐货主 Map 缓存(N 成功单 / M 货主 → 2M 次查询);解析不到 appKey(订单缺 store_id / 无授权关系 / 无可用 ApiApp 配置)warn 后跳过该订单", + "同步 docs/openapi-callback-events.md 3.3 与 AI_METHOD_ROUTING.md 5.6" + ] + }, { "version": "2026.09.13-openapi-callback-request-protocol", "date": "2026-09-13", diff --git a/methods/openapi_callback.json b/methods/openapi_callback.json index 500855f..7cdf756 100644 --- a/methods/openapi_callback.json +++ b/methods/openapi_callback.json @@ -1,7 +1,7 @@ { "module": "openapi_callback", "description": "开放 API 出站回调定义(出站方向:WMS → 外部)。WMS 在业务完成后按 ApiApp 配置的 callback_url 主动推送事件通知:query 携带 method/v/timestamp/app_key/sign,报文体统一为奇门同层级的 { request: {...} }(event 仅出现在 query 的 method),使用 MD5 签名鉴权。入站接口请参阅 openapi.json。", - "version": "1.2.0", + "version": "1.3.0", "updatedAt": "2026-09-13", "http": { "path": "{ApiApp.callback_url}", @@ -495,7 +495,7 @@ }, { "method": "deliveryorder.confirm", - "description": "订单发货完成出站回调(逐单发送)。API 渠道订单同步(出库)完成(createChannel=API 且 successCount>0)后,WMS 对每个同步成功的订单各发送一次回调(成功 N 单 = N 次回调),仅对 syncResults 中 status==='success' 的订单发送;fire-and-forget,失败仅 warn,不阻塞主流程。触发实现:app/service/systems/order_async.js#finalizeLocalChannelOrdersInternal → notifyApiDeliveryOrderConfirmsInternal(复用 buildQimenDeliveryOrderConfirmDataInternal 组装与奇门 taobao.qimen.deliveryorder.confirm 完全一致的 request 报文;复用原有主表+明细查询,新增 1 次运单号批量查询,无 N+1)。", + "description": "订单发货完成出站回调(逐单发送)。触发前提:createChannel=API 且本批存在同步成功订单(仅对 syncResults 中 status==='success' 的订单发送,成功 N 单 = N 次回调;fire-and-forget,失败仅 warn,不阻塞主流程)。发送用 appKey 优先取调用上下文 context.appKey,缺失时按订单货主(store_id + warehouse_id)合约反查 —— wms_store_warehouse(auth_status=2) → wms_api_app(is_enabled=1 且 callback_url 非空) 的 self_app_key;同一批次按货主缓存,无 N+1。解析不到 appKey(订单缺 store_id / 无授权关系 / 无可用 ApiApp 配置)时跳过该订单并告警,不发送请求;同步失败的订单不发送。触发实现:app/service/systems/order_async.js#finalizeLocalChannelOrdersInternal → notifyApiDeliveryOrderConfirmsInternal(复用 buildQimenDeliveryOrderConfirmDataInternal 组装与奇门 taobao.qimen.deliveryorder.confirm 完全一致的 request 报文;复用原有主表+明细查询,新增 1 次运单号批量查询,无 N+1)。", "isNeedAuth": true, "isNeedLogin": false, "headers": [], @@ -879,7 +879,8 @@ "重试策略:非 2xx 响应或网络错误触发重试,至多重试 3 次(即最多 4 次尝试),间隔 2s→5s→15s,单次请求超时 30s;全部失败后判定回调失败", "报文体统一为奇门同层级的 { request: {...} }(发送端统一包装 body = { request: request || {} }),event 仅出现在 query 的 method", "事件注册表:app/service/openapi/callbackRegistry.js#CALLBACK_EVENTS;调试页:GET /docs/api/openapi/callback-test(app/controller/openapiCallback.js 按注册表自动预填完整报文体 { request: {...} },可编辑后发送)", - "发送途径:sendByAppKey(按 app_key 查 ApiApp,is_enabled=1,取 self_app_secret 与 callback_url)", + "发送途径:sendByAppKey;appKey 解析优先级:context.appKey 非空时优先(不触发合约反查),缺失时按订单货主(store_id + warehouse_id)合约反查 resolveOpenApiAppByStoreInternal —— wms_store_warehouse(auth_status=2) → wms_api_app(contract_id 且 is_enabled=1 且 callback_url 非空) 的 self_app_key;同一批次按货主 Map 缓存(N 个成功单 / M 个货主 → 2M 次查询,无 N+1)", + "appKey 门禁修复(2026-09-13):此前 order_storage_allocation.js 构造的 routeContext 不含 appKey,finalizeLocalChannelOrdersInternal 内 if(appKey) 门禁使 syncOrderIds(API) 链路的 deliveryorder.confirm 从未真正发出请求;订单 wms_order_delivery.from_key 也兜不住(normalizeOrderFromKey 仅接受整数,字符串 app_key 被归一化为 null)。本次改为按货主合约反查修复;解析不到 appKey(订单缺 store_id / 无授权关系 / 无可用 ApiApp 配置)的订单 warn 后跳过,不发请求", "逐单发送语义(破坏性变更):改动前一次回调携带整批 orderIds(含失败/跳过);改后仅对 syncResults 中 status==='success' 的订单逐单发送,成功 N 单 = N 次回调;组装/发送失败仅 warn,不影响其他订单与主流程", "fire-and-forget 触发:回调结果不影响订单同步主流程" ] diff --git a/test/app/service/systems/order_async.openapi.callback.test.js b/test/app/service/systems/order_async.openapi.callback.test.js index 327b16b..37ba97d 100644 --- a/test/app/service/systems/order_async.openapi.callback.test.js +++ b/test/app/service/systems/order_async.openapi.callback.test.js @@ -21,12 +21,62 @@ async function waitFor(predicate, timeoutMs = 500) { } } +/** + * 构造订单主表记录(raw),字段与 harness 默认单一致,便于多货主场景复用。 + * @param {number} id 订单 ID。 + * @param {number} storeId 货主 ID。 + * @param {string} [deliveryOrderCode] 出库单号,缺省自动生成。 + * @return {Object} 订单主表记录。 + */ +function makeOrderRow(id, storeId, deliveryOrderCode) { + return { + id, + warehouse_id: 100000, + store_id: storeId, + delivery_order_code: deliveryOrderCode || `DO-${id}`, + warehouse_code: 'WH-100', + order_type: 'JYCK', + logistics_code: 'YTO', + logistics_name: '圆通速递', + express_code: '', + name: '测试客户', + mobile: '13800000000', + source_order_codes: `SO-${id}`, + sync_status: 'pending', + }; +} + +/** + * 构造订单明细记录(raw)。 + * @param {number} id 明细 ID。 + * @param {number} orderId 所属订单 ID。 + * @param {string} [itemCode] 商品编码,缺省自动生成。 + * @return {Object} 订单明细记录。 + */ +function makeOrderItem(id, orderId, itemCode) { + return { + id, + order_id: orderId, + order_line_no: '1', + source_order_code: `SRC-${orderId}`, + owner_code: `OWNER-${orderId}`, + item_code: itemCode || `SKU-${orderId}`, + item_id: String(id), + item_name: `测试商品${orderId}`, + plan_qty: 1, + actual_qty: 1, + inventory_type: 'ZP', + }; +} + /** * 创建订单异步服务测试桩(覆盖 OpenAPI 回调与 notice 通道断言)。 * @param {Object} [options] 可选配置。 * @param {Array} [options.orderRows] 订单主表记录(raw)。 * @param {Array} [options.orderItems] 订单明细记录(raw)。 * @param {Array} [options.orderExpressRows] 运单号记录(raw)。 + * @param {Array} [options.storeWarehouseRows] 货主-仓库授权关系记录(raw)。 + * @param {Array} [options.apiAppRows] ApiApp 配置记录(raw)。 * @param {Object} [options.stockoutOrder] 出库单主表记录(raw)。 * @param {Function} [options.onSendByAppKey] OpenAPI 回调桩实现。 * @param {Function} [options.onOutbound] 库存扣减桩实现(可模拟失败订单)。 @@ -40,6 +90,10 @@ function createHarness(options = {}) { const transactionCalls = []; const stockoutUpdates = []; const orderUpdates = []; + const storeWarehouseCalls = []; + const apiAppCalls = []; + const warnLogs = []; + const infoLogs = []; const orderRows = Array.isArray(options.orderRows) ? options.orderRows.map(item => ({ ...item })) @@ -86,6 +140,27 @@ function createHarness(options = {}) { waybill_code: 'WB-1001', }, ]; + const storeWarehouseRows = Array.isArray(options.storeWarehouseRows) + ? options.storeWarehouseRows + : [ + { + id: 20001, + store_id: 1000000, + warehouse_id: 100000, + auth_status: 2, + }, + ]; + const apiAppRows = Array.isArray(options.apiAppRows) + ? options.apiAppRows + : [ + { + contract_id: 20001, + is_enabled: 1, + callback_url: 'https://example.com/callback', + self_app_key: 'WMSD08A0001', + self_app_secret: 'SECRET-1', + }, + ]; const ctx = { app: { @@ -165,6 +240,26 @@ function createHarness(options = {}) { return orderExpressRows.filter(item => normalizedIds.includes(Number(item.order_id))); }, }, + StoreWarehouse: { + async findOne(query = {}) { + storeWarehouseCalls.push(query); + const where = query.where || {}; + return storeWarehouseRows.find(row => Number(row.store_id) === Number(where.store_id) + && Number(row.warehouse_id) === Number(where.warehouse_id) + && Number(row.auth_status) === Number(where.auth_status)) || null; + }, + }, + ApiApp: { + async findOne(query = {}) { + apiAppCalls.push(query); + const where = query.where || {}; + return apiAppRows.find(row => Number(row.contract_id) === Number(where.contract_id) + && Number(row.is_enabled) === Number(where.is_enabled) + && row.callback_url !== null + && row.callback_url !== undefined + && String(row.callback_url).trim() !== '') || null; + }, + }, OrderStockout: { async findOne() { return options.stockoutOrder || { @@ -253,8 +348,12 @@ function createHarness(options = {}) { }, }, logger: { - info() {}, - warn() {}, + info(message) { + infoLogs.push(String(message)); + }, + warn(message) { + warnLogs.push(String(message)); + }, error() {}, }, }; @@ -270,6 +369,10 @@ function createHarness(options = {}) { transactionCalls, stockoutUpdates, orderUpdates, + storeWarehouseCalls, + apiAppCalls, + warnLogs, + infoLogs, }; } @@ -497,4 +600,217 @@ describe('test/app/service/systems/order_async.openapi.callback.test.js', () => assert.equal(noticeCalls[0].event, 'order_sync_completed'); assert.equal(noticeCalls[0].businessName, 'order'); }); + + it('context.appKey 为空时按订单货主合约反查 ApiApp 并发送回调(appKey=self_app_key)', async () => { + const { service, callbackCalls, storeWarehouseCalls, apiAppCalls } = createHarness(); + + const result = await service.syncApiOrders({ + create_channel: 'API', + order_ids: [ 1 ], + order_count: 1, + orders: [{ id: 1 }], + }, { + warehouseId: 100000, + }); + + assert.equal(result.status, 'success'); + assert.equal(result.success_count, 1); + + await waitFor(() => callbackCalls.length === 1); + + assert.equal(callbackCalls.length, 1); + assert.equal(callbackCalls[0].event, 'deliveryorder.confirm'); + assert.equal(callbackCalls[0].appKey, 'WMSD08A0001'); + assert.equal(storeWarehouseCalls.length, 1); + assert.equal(apiAppCalls.length, 1); + }); + + it('context.appKey 非空时优先使用,且不触发合约反查', async () => { + const { service, callbackCalls, storeWarehouseCalls, apiAppCalls } = createHarness(); + + const result = await service.syncApiOrders({ + create_channel: 'API', + order_ids: [ 1 ], + order_count: 1, + orders: [{ id: 1 }], + }, { + warehouseId: 100000, + appKey: 'APP-KEY-8', + }); + + assert.equal(result.status, 'success'); + + await waitFor(() => callbackCalls.length === 1); + + assert.equal(callbackCalls.length, 1); + assert.equal(callbackCalls[0].appKey, 'APP-KEY-8'); + // 未触发货主合约反查 + assert.equal(storeWarehouseCalls.length, 0); + assert.equal(apiAppCalls.length, 0); + }); + + it('合约下无授权关系时跳过回调并记录 warn', async () => { + const { service, callbackCalls, storeWarehouseCalls, apiAppCalls, warnLogs } = createHarness({ + storeWarehouseRows: [], + }); + + const result = await service.syncApiOrders({ + create_channel: 'API', + order_ids: [ 1 ], + order_count: 1, + orders: [{ id: 1 }], + }, { + warehouseId: 100000, + }); + + assert.equal(result.status, 'success'); + + await waitFor(() => warnLogs.some(log => log.includes('未找到授权关系'))); + + assert.equal(callbackCalls.length, 0); + assert.equal(storeWarehouseCalls.length, 1); + assert.equal(apiAppCalls.length, 0); + }); + + it('合约下 ApiApp 停用或 callback_url 为空时跳过回调并记录 warn', async () => { + const cases = [ + { + name: 'is_enabled=0', + apiAppRows: [ + { + contract_id: 20001, + is_enabled: 0, + callback_url: 'https://example.com/callback', + self_app_key: 'WMSD08A0001', + self_app_secret: 'SECRET-1', + }, + ], + }, + { + name: 'callback_url 为空', + apiAppRows: [ + { + contract_id: 20001, + is_enabled: 1, + callback_url: '', + self_app_key: 'WMSD08A0001', + self_app_secret: 'SECRET-1', + }, + ], + }, + ]; + + for (const caseItem of cases) { + const { service, callbackCalls, storeWarehouseCalls, apiAppCalls, warnLogs } = createHarness({ + apiAppRows: caseItem.apiAppRows, + }); + + const result = await service.syncApiOrders({ + create_channel: 'API', + order_ids: [ 1 ], + order_count: 1, + orders: [{ id: 1 }], + }, { + warehouseId: 100000, + }); + + assert.equal(result.status, 'success'); + + await waitFor(() => warnLogs.some(log => log.includes('未找到有效ApiApp配置'))); + + assert.equal(callbackCalls.length, 0, `${caseItem.name} 不应发送回调`); + assert.equal(storeWarehouseCalls.length, 1); + assert.equal(apiAppCalls.length, 1); + } + }); + + it('多货主批次各自按货主反查 appKey,同货主只查一次库', async () => { + const { service, callbackCalls, storeWarehouseCalls, apiAppCalls } = createHarness({ + orderRows: [ + makeOrderRow(1, 1000000, 'DO-1001'), + makeOrderRow(2, 1000000, 'DO-1002'), + makeOrderRow(3, 2000000, 'DO-1003'), + ], + orderItems: [ + makeOrderItem(101, 1, 'SKU-1'), + makeOrderItem(102, 2, 'SKU-2'), + makeOrderItem(103, 3, 'SKU-3'), + ], + orderExpressRows: [ + { order_id: 1, business_key: 9001, waybill_code: 'WB-1001' }, + { order_id: 2, business_key: 9002, waybill_code: 'WB-1002' }, + { order_id: 3, business_key: 9003, waybill_code: 'WB-1003' }, + ], + storeWarehouseRows: [ + { id: 20001, store_id: 1000000, warehouse_id: 100000, auth_status: 2 }, + { id: 20002, store_id: 2000000, warehouse_id: 100000, auth_status: 2 }, + ], + apiAppRows: [ + { + contract_id: 20001, + is_enabled: 1, + callback_url: 'https://example.com/cb1', + self_app_key: 'WMSD08A0001', + self_app_secret: 'SECRET-1', + }, + { + contract_id: 20002, + is_enabled: 1, + callback_url: 'https://example.com/cb2', + self_app_key: 'WMSD08A0002', + self_app_secret: 'SECRET-2', + }, + ], + }); + + const result = await service.syncApiOrders({ + create_channel: 'API', + order_ids: [ 1, 2, 3 ], + order_count: 3, + orders: [{ id: 1 }, { id: 2 }, { id: 3 }], + }, { + warehouseId: 100000, + }); + + assert.equal(result.success_count, 3); + + await waitFor(() => callbackCalls.length === 3); + + assert.equal(callbackCalls.length, 3); + const appKeyByCode = new Map(callbackCalls.map(call => [ call.request.deliveryOrder.deliveryOrderCode, call.appKey ])); + assert.equal(appKeyByCode.get('DO-1001'), 'WMSD08A0001'); + assert.equal(appKeyByCode.get('DO-1002'), 'WMSD08A0001'); + assert.equal(appKeyByCode.get('DO-1003'), 'WMSD08A0002'); + // 缓存命中:3 单共 2 个货主,StoreWarehouse / ApiApp 各只查询 2 次 + assert.equal(storeWarehouseCalls.length, 2); + assert.equal(apiAppCalls.length, 2); + }); + + it('订单缺少货主 store_id 时跳过回调并记录 warn', async () => { + const { service, callbackCalls, storeWarehouseCalls, apiAppCalls, warnLogs } = createHarness({ + orderRows: [ + makeOrderRow(1, 0, 'DO-1001'), + ], + orderItems: [ + makeOrderItem(101, 1, 'SKU-1'), + ], + }); + + const result = await service.syncApiOrders({ + create_channel: 'API', + order_ids: [ 1 ], + order_count: 1, + orders: [{ id: 1 }], + }, { + warehouseId: 100000, + }); + + assert.equal(result.status, 'success'); + + await waitFor(() => warnLogs.some(log => log.includes('订单缺少货主'))); + + assert.equal(callbackCalls.length, 0); + assert.equal(storeWarehouseCalls.length, 0); + assert.equal(apiAppCalls.length, 0); + }); });