From 0a6e82e00a796cdd89978599c0d4295b2c4591bd Mon Sep 17 00:00:00 2001 From: liufumingren Date: Tue, 17 Nov 2026 01:30:08 +0800 Subject: [PATCH] =?UTF-8?q?feat(order):=20B2B=20=E8=AE=A2=E5=8D=95?= =?UTF-8?q?=E4=BD=9C=E4=B8=9A=E9=93=BE=E8=B7=AF=EF=BC=88=E5=88=97=E8=A1=A8?= =?UTF-8?q?/=E8=BD=AC=E6=8D=A2/=E5=8F=96=E6=B6=88/=E6=B3=A2=E6=AC=A1?= =?UTF-8?q?=E6=8E=92=E9=99=A4/=E4=BD=9C=E4=B8=9A=E6=98=8E=E7=BB=86?= =?UTF-8?q?=E8=A1=A8=E9=87=8D=E6=9E=84=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 新增 order.pendingOrder2b.list / order.deliveryOrder2b.list:复用待处理与配送列表条件, 强制 is_b2b='Y'(fixedWhere 以 AND 追加,请求 where 无法覆盖),并带出 wms_order_b2b 作业明细字段(total_box_count/pickup_plate_number/prep_remark/prep_duration_seconds/ prep_at/is_picked_up/picked_up_at/created_at),无明细行时输出空值占位 - B2B 列表 where 支持按作业明细字段筛选:先按 warehouse_id + order_id 查副表取 order_id, 再以 id IN (...) 回填;该筛选仅这两个接口开放,不影响普通订单列表 - 其余订单列表(order/reviewOrder/pendingOrder/outboundOrder/expectionOrder/entrustOrder/ deliveryOrder/deliveryExpectionOrder/archiveOrder 及 waveStrategyFallbackOrderList) 统一追加 (is_b2b IS NULL OR is_b2b = 'N'),B2B 订单不再混入普通列表 - order.convertToB2b 收紧准入:status!=cancel、step in [1,2,3]、未拣货、未复核、未锁定、 未拦截、未 B2B(打印状态不限制);已在波次中的订单转换后在同一事务内从波次摘除 (含库内抓取订单),波次存在进行中拣货任务则跳过 - order.cancelB2b 放开打印限制,作业明细由软删除改为物理删除 - 波次抓取全链路排除 B2B:补上自动加团 appendOrderToWave / countCandidateGroupOrders 两处遗漏;抽出 detachOrdersFromWavesInTransaction 供 batchRemoveOrders 与转 B2B 复用 - wms_order_delivery 分表新增 is_b2b 列表索引(current/dispatch,等值列前置 + 排序列), 由订单工厂结构漂移同步自动补建 - 迁移 20261115180000-refactor-wms-order-b2b:新增 prep_at;移除 is_print/updated_at/ deleted_at/delivery_order_code/store_id;唯一键改 uk_warehouse_order(warehouse_id, order_id); 迁移前清理历史软删除行与重复行(开发库与生产库均已执行) - operation_log 兜底用 changeSummary 写入 message,修复转/取消 B2B 日志操作说明为空 - 同步 methods/system.json 与变更记录 0.3.351~0.3.360 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- app/model/order_b2b.js | 65 +- app/model/order_delivery_table_schema.js | 17 + app/service/systemMethods/order/base.js | 242 +++++++- .../systemMethods/order/deliveryOrder2b.js | 47 ++ app/service/systemMethods/order/index.js | 7 +- .../systemMethods/order/pendingOrder2b.js | 47 ++ app/service/systemMethods/order/wave.js | 223 ++++--- app/service/systems/delivery_order.js | 10 +- app/service/systems/operation_log.js | 5 +- app/service/systems/order_b2b.js | 224 +++++-- .../20261115180000-refactor-wms-order-b2b.js | 202 +++++++ methods/changes/system.json | 176 ++++++ methods/system.json | 563 ++++++++++++++++-- 13 files changed, 1591 insertions(+), 237 deletions(-) create mode 100644 app/service/systemMethods/order/deliveryOrder2b.js create mode 100644 app/service/systemMethods/order/pendingOrder2b.js create mode 100644 database/migrations/20261115180000-refactor-wms-order-b2b.js diff --git a/app/model/order_b2b.js b/app/model/order_b2b.js index 8db3df9..a99c526 100644 --- a/app/model/order_b2b.js +++ b/app/model/order_b2b.js @@ -3,12 +3,12 @@ /** * B2B 订单作业明细表 Model。 * - * 对应数据库表 `wms_order_b2b`,与发货单(订单)分表 wms_order_delivery_% 一对一 - * (order_id 关联分表 id),记录 B2B 订单的提货作业信息: - * 总箱数、提货车牌、备货备注、备货用时、是否提货等。 + * 对应数据库表 `wms_order_b2b`,与发货单(订单)分表 wms_order_delivery_% 一对一, + * 记录 B2B 订单的备货/提货作业信息:总箱数、提货车牌、备货备注、备货用时、 + * 备货完成时间、是否提货等。 * - * 不分表(不按仓库分表),通过 warehouse_id/store_id 维度隔离, - * 落表方式类似 wms_order_express(运单号表)。 + * 不分表(不按仓库分表),关联读统一使用 warehouse_id + order_id(分表 id 按仓库 + * 各自发号,跨仓可能重叠,故不单独依赖 order_id)。取消 B2B 时物理删除行,不做软删除。 * @param {import('egg').Application} app - Egg 应用实例 */ module.exports = app => { @@ -32,16 +32,6 @@ module.exports = app => { allowNull: false, comment: '仓库ID', }, - store_id: { - type: BIGINT(20).UNSIGNED, - allowNull: true, - comment: '货主ID', - }, - delivery_order_code: { - type: STRING(50), - allowNull: true, - comment: '发货单号快照', - }, total_box_count: { type: INTEGER(11), allowNull: false, @@ -64,18 +54,17 @@ module.exports = app => { defaultValue: 0, comment: '备货用时(秒)', }, + prep_at: { + type: DATE, + allowNull: true, + comment: '备货完成时间', + }, is_picked_up: { type: ENUM('Y', 'N'), allowNull: false, defaultValue: 'N', comment: '是否提货:Y=已提货 N=未提货', }, - is_print: { - type: ENUM('Y', 'N'), - allowNull: false, - defaultValue: 'N', - comment: '是否打印:Y=已打印 N=未打印', - }, picked_up_at: { type: DATE, allowNull: true, @@ -86,37 +75,15 @@ module.exports = app => { allowNull: false, comment: '创建时间', }, - updated_at: { - type: DATE, - allowNull: false, - comment: '更新时间', - }, - deleted_at: { - type: DATE, - allowNull: true, - comment: '软删除时间', - }, }, { tableName: 'wms_order_b2b', comment: 'B2B订单作业明细表', timestamps: false, indexes: [ { - name: 'uk_order_id', + name: 'uk_warehouse_order', unique: true, - fields: [ 'order_id' ], - }, - { - name: 'idx_warehouse_id', - fields: [ 'warehouse_id' ], - }, - { - name: 'idx_store_id', - fields: [ 'store_id' ], - }, - { - name: 'idx_delivery_order_code', - fields: [ 'delivery_order_code' ], + fields: [ 'warehouse_id', 'order_id' ], }, { name: 'idx_pickup_plate_number', @@ -126,14 +93,6 @@ module.exports = app => { name: 'idx_is_picked_up', fields: [ 'is_picked_up' ], }, - { - name: 'idx_is_print', - fields: [ 'is_print' ], - }, - { - name: 'idx_deleted_at', - fields: [ 'deleted_at' ], - }, ], }); diff --git a/app/model/order_delivery_table_schema.js b/app/model/order_delivery_table_schema.js index 5ff1cd2..71d310b 100644 --- a/app/model/order_delivery_table_schema.js +++ b/app/model/order_delivery_table_schema.js @@ -26,6 +26,7 @@ const AUTO_INCREMENT_SAFE_MARGIN = 50; * 剔除从 current 继承来的同名后缀索引,改用自身版本,避免同一张表维护两份功能重叠的索引。 * * 带 `_list_logistics_code_` 前缀的是「物流公司编码等值过滤 + 排序」变体(见 buildListSortIndexes), + * 带 `_list_is_b2b_` 前缀的是「B2B 标记等值过滤 + 排序」变体(B2B 域列表专用), * 同样需要按分表类型区分版本,故一并登记后缀。 */ const LIST_SORT_INDEX_SUFFIXES = Object.freeze([ @@ -33,6 +34,8 @@ const LIST_SORT_INDEX_SUFFIXES = Object.freeze([ '_list_delivery_time', '_list_logistics_code_updated_at', '_list_logistics_code_delivery_time', + '_list_is_b2b_updated_at', + '_list_is_b2b_delivery_time', ]); const TABLE_PATTERNS = Object.freeze([ @@ -593,6 +596,20 @@ function buildListSortIndexes(warehouseId, type) { }); } + // B2B 列表(order.pendingOrder2b.list / order.deliveryOrder2b.list)恒定带 + // is_b2b='Y' 等值条件,索引形态同上:等值列插在 scopeFields 与排序列之间, + // 让「B2B 过滤 + 排序 + 分页」命中同一索引,避免把整表 B2B 行捞出后 filesort。 + // B2B 列表只查 current / dispatch 分表,history / outsourced 不声明该索引, + // 避免在归档表上补建无查询场景的索引。 + if (modelType === MANAGED_TYPES.CURRENT || dispatchType) { + for (const sortField of sortFields) { + indexes.push({ + name: `${namePrefix}_list_is_b2b_${sortField}`, + fields: [ ...scopeFields, 'is_b2b', sortField, 'id' ], + }); + } + } + return indexes; } diff --git a/app/service/systemMethods/order/base.js b/app/service/systemMethods/order/base.js index 49fde3f..d53e234 100644 --- a/app/service/systemMethods/order/base.js +++ b/app/service/systemMethods/order/base.js @@ -52,6 +52,42 @@ const ORDER_LIST_BASE_ATTRIBUTES = [ 'store_id', ]; +const ORDER_B2B_DETAIL_ATTRIBUTES = Object.freeze([ + 'order_id', + 'total_box_count', + 'pickup_plate_number', + 'prep_remark', + 'prep_duration_seconds', + 'is_picked_up', + 'picked_up_at', + 'created_at', + 'prep_at', +]); + +/** B2B 作业明细空值(副表无对应行时的占位输出) */ +const ORDER_B2B_DETAIL_EMPTY = Object.freeze({ + total_box_count: 0, + pickup_plate_number: null, + prep_remark: null, + prep_duration_seconds: 0, + is_picked_up: 'N', + picked_up_at: null, + created_at: null, + prep_at: null, +}); + +/** B2B 作业明细可筛选字段(仅 B2B 域列表开放,避免污染普通订单列表口径) */ +const ORDER_B2B_DETAIL_FILTER_FIELDS = Object.freeze([ + 'total_box_count', + 'pickup_plate_number', + 'prep_remark', + 'prep_duration_seconds', + 'is_picked_up', + 'picked_up_at', + 'created_at', + 'prep_at', +]); + const ORDER_WEIGHT_TYPE_LABELS = Object.freeze({ 0: '常规', 1: '轻货', @@ -1887,12 +1923,26 @@ class OrderBaseService extends MainService { /** * 查询模块列表。 + * + * 默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),B2B 域列表通过 + * options.fixedWhere 指定 is_b2b 条件时不追加默认排除。 + * * @param {string} moduleName 模块名称。 * @param {Object} data 请求体。 + * @param {Object} [options] 查询选项。 + * @param {Object} [options.fixedWhere] 强制附加的筛选条件,与请求 where 取 AND, + * 不可被请求中的同名字段覆盖(用于 B2B 等固定域列表)。 + * @param {boolean} [options.b2bDetailFilter=false] 是否支持用 wms_order_b2b 作业明细字段 + * (total_box_count / pickup_plate_number / prep_remark / prep_duration_seconds / + * is_picked_up / picked_up_at / created_at / prep_at)作为筛选条件。 * @return {Promise} 列表与分页信息。 */ - async listByModule(moduleName = 'order', data = {}) { + async listByModule(moduleName = 'order', data = {}, options = {}) { const requestData = this.isPlainObject(data) ? data : {}; + const normalizedOptions = this.isPlainObject(options) ? options : {}; + const fixedWhere = this.isPlainObject(normalizedOptions.fixedWhere) + ? normalizedOptions.fixedWhere + : null; const contextWarehouseId = this.getWarehouseId(); const { page, pageSize } = this.normalizePagination(requestData.pagination || requestData); const { where } = this.prepareWhereContext(requestData, { @@ -1909,7 +1959,10 @@ class OrderBaseService extends MainService { const { where: whereAfterWaveScope, waveScope } = this.extractWaveScopeVirtualFilter(whereAfterWaveIndex); const { where: whereAfterSnOrder, isSnOrder } = this.extractSnOrderVirtualFilter(whereAfterWaveScope); const { where: whereAfterSnCode, snCodes } = this.extractSnCodeVirtualFilter(whereAfterSnOrder); - const mergedWhere = this.mergeWhereObjects(this.getDefaultWhere(moduleName), whereAfterSnCode); + const { where: whereAfterB2bDetail, b2bDetailFilters } = normalizedOptions.b2bDetailFilter === true + ? this.extractB2bDetailVirtualFilter(whereAfterSnCode) + : { where: whereAfterSnCode, b2bDetailFilters: null }; + const mergedWhere = this.mergeWhereObjects(this.getDefaultWhere(moduleName), whereAfterB2bDetail); let queryWhere = this.buildWhere(mergedWhere, contextWarehouseId, { specialFieldMap: { quickWhere: { @@ -1918,6 +1971,22 @@ class OrderBaseService extends MainService { }, }); + if (fixedWhere) { + queryWhere = this.appendConditionToWhere(queryWhere, fixedWhere); + } + + // 非 B2B 域列表:默认排除 B2B 订单(B2B 域列表由 fixedWhere 指定 is_b2b='Y') + if (!fixedWhere || !Object.prototype.hasOwnProperty.call(fixedWhere, 'is_b2b')) { + queryWhere = this.appendConditionToWhere(queryWhere, this.buildExcludeB2bCondition()); + } + + if (b2bDetailFilters) { + const b2bOrderIds = await this.findOrderIdsByB2bDetailFilters(b2bDetailFilters, contextWarehouseId); + if (b2bOrderIds !== null) { + queryWhere = this.appendOrderIdsFilterToWhere(queryWhere, b2bOrderIds); + } + } + if (expressNumbers.length > 0) { const orderIds = await this.findOrderIdsByExpressNumbers(expressNumbers, contextWarehouseId); queryWhere = this.appendOrderIdsFilterToWhere(queryWhere, orderIds); @@ -2028,6 +2097,175 @@ class OrderBaseService extends MainService { }; } + /** + * 为订单列表行附加 B2B 作业明细字段(副表 wms_order_b2b)。 + * + * 关联条件固定为 warehouse_id + order_id(分表 id 按仓库发号,不能只按 order_id 关联); + * 无副表行时输出空值占位,保证响应字段结构稳定。附加字段: + * total_box_count / pickup_plate_number / prep_remark / prep_duration_seconds / + * is_picked_up / picked_up_at / created_at(副表创建时间) / prep_at。 + * + * @param {Array} list 订单列表行(需含 id)。 + * @param {number|string|null} [warehouseId=null] 仓库ID,缺省取当前上下文。 + * @return {Promise>} 附加 B2B 作业明细后的列表。 + */ + async attachB2bJobDetail(list = [], warehouseId = null) { + const rows = Array.isArray(list) ? list : []; + if (rows.length === 0) { + return rows; + } + + const normalizedWarehouseId = Number(warehouseId ?? this.getWarehouseId() ?? 0); + const b2bModel = this.ctx.model && this.ctx.model.OrderB2b; + const detailMap = new Map(); + + if (Number.isInteger(normalizedWarehouseId) && normalizedWarehouseId > 0 + && b2bModel && typeof b2bModel.findAll === 'function') { + const orderIds = [ ...new Set(rows + .map(row => Number(row && row.id || 0)) + .filter(id => Number.isInteger(id) && id > 0)) ]; + + if (orderIds.length > 0) { + const detailRows = await b2bModel.findAll({ + where: { + warehouse_id: normalizedWarehouseId, + order_id: { [this.app.Sequelize.Op.in]: orderIds }, + }, + attributes: [ ...ORDER_B2B_DETAIL_ATTRIBUTES ], + raw: true, + }); + + for (const detail of (Array.isArray(detailRows) ? detailRows : [])) { + const orderId = Number(detail && detail.order_id || 0); + if (Number.isInteger(orderId) && orderId > 0) { + detailMap.set(orderId, detail); + } + } + } + } + + return rows.map(row => { + const detail = detailMap.get(Number(row && row.id || 0)); + if (!detail) { + return { ...row, ...ORDER_B2B_DETAIL_EMPTY }; + } + + return { + ...row, + total_box_count: Number(detail.total_box_count || 0), + pickup_plate_number: detail.pickup_plate_number ?? null, + prep_remark: detail.prep_remark ?? null, + prep_duration_seconds: Number(detail.prep_duration_seconds || 0), + is_picked_up: String(detail.is_picked_up || 'N').trim() === 'Y' ? 'Y' : 'N', + picked_up_at: detail.picked_up_at ?? null, + created_at: detail.created_at ?? null, + prep_at: detail.prep_at ?? null, + }; + }); + } + + /** + * 构造"排除 B2B 订单"条件(is_b2b 为 NULL 的存量行视为非 B2B)。 + * @return {Object} Sequelize 条件。 + */ + buildExcludeB2bCondition() { + const { Op } = this.app.Sequelize; + return { + is_b2b: { + [Op.or]: [ + { [Op.is]: null }, + 'N', + ], + }, + }; + } + + /** + * 从 where 中提取 B2B 作业明细筛选条件(仅 B2B 域列表使用)。 + * + * @param {Object} [where={}] 已解析的 where 条件。 + * @return {{ where: Object, b2bDetailFilters: (Object|null) }} 剩余 where 与作业明细筛选条件。 + */ + extractB2bDetailVirtualFilter(where = {}) { + const source = this.isPlainObject(where) ? where : {}; + const rest = {}; + const filters = {}; + + for (const [ fieldName, condition ] of Object.entries(source)) { + if (!ORDER_B2B_DETAIL_FILTER_FIELDS.includes(fieldName)) { + rest[fieldName] = condition; + continue; + } + + const conditionValue = this.isPlainObject(condition) && Object.prototype.hasOwnProperty.call(condition, 'value') + ? condition.value + : condition; + if (conditionValue === undefined || conditionValue === null || conditionValue === '') { + continue; + } + + filters[fieldName] = condition; + } + + return { + where: rest, + b2bDetailFilters: Object.keys(filters).length > 0 ? filters : null, + }; + } + + /** + * 按 B2B 作业明细筛选条件查询命中的订单ID。 + * + * 关联条件固定为 warehouse_id + order_id;无有效条件时返回 null(表示不过滤), + * 有条件下未命中时返回空数组(下游展开为空列表)。 + * + * @param {Object} filters 作业明细筛选条件。 + * @param {number|string|null} [warehouseId=null] 仓库ID,缺省取当前上下文。 + * @return {Promise} 命中订单ID列表,或 null(无有效条件)。 + */ + async findOrderIdsByB2bDetailFilters(filters = {}, warehouseId = null) { + const { Sequelize } = this.app; + const { Op } = Sequelize; + const b2bModel = this.ctx.model && this.ctx.model.OrderB2b; + const normalizedWarehouseId = Number(warehouseId ?? this.getWarehouseId() ?? 0); + + if (!this.isPlainObject(filters) || Object.keys(filters).length === 0) { + return null; + } + + if (!b2bModel || typeof b2bModel.findAll !== 'function' + || !Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) { + return []; + } + + const parsed = parseWhereConditions({ + where: this.normalizeWhereInput({ where: filters }), + app: this.app, + }); + + if (!parsed.ok) { + throw new Error(`B2B 作业明细筛选条件解析失败: ${parsed.reason}`); + } + + const conditions = Array.isArray(parsed.result.dynamicConditions) ? parsed.result.dynamicConditions : []; + if (conditions.length === 0) { + return null; + } + + const rows = await b2bModel.findAll({ + where: { + warehouse_id: normalizedWarehouseId, + [Op.and]: conditions, + }, + attributes: [ 'order_id' ], + raw: true, + }); + + return [ ...new Set((Array.isArray(rows) ? rows : []) + .map(row => Number(row && row.order_id || 0)) + .filter(orderId => Number.isInteger(orderId) && orderId > 0)) ]; + } + /** * 查询订单详情。 * diff --git a/app/service/systemMethods/order/deliveryOrder2b.js b/app/service/systemMethods/order/deliveryOrder2b.js new file mode 100644 index 0000000..a904d64 --- /dev/null +++ b/app/service/systemMethods/order/deliveryOrder2b.js @@ -0,0 +1,47 @@ +'use strict'; + +const OrderBaseService = require('./base'); + +/** B2B 列表强制条件 */ +const B2B_FIXED_WHERE = Object.freeze({ is_b2b: 'Y' }); + +/** + * B2B 配送订单系统方法。 + * + * 查询条件与 order.deliveryOrder.list 完全一致(dispatch 分表 + dispatch_lane=m4), + * 仅额外强制 is_b2b='Y',用于 B2B 订单的配送域列表。 + */ +class DeliveryOrder2bService extends OrderBaseService { + constructor(ctx) { + super(ctx); + const _noNeedLogin = ''; + const _noNeedRight = 'list'; + const _noNeedLog = 'list'; + const _noNeedAuth = 'list'; + this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth); + } + + /** + * B2B 配送订单列表。 + * + * 在 order.deliveryOrder.list 的基础上强制 is_b2b='Y',并附加 wms_order_b2b 作业明细字段 + * (total_box_count / pickup_plate_number / prep_remark / prep_duration_seconds / + * is_picked_up / picked_up_at / created_at / prep_at)。 + * + * @param {Object} data 请求体(与 order.deliveryOrder.list 一致)。 + * @return {Promise} 列表与分页信息。 + */ + async list(data = {}) { + const warehouseId = this.getWarehouseId(); + const result = await this.listByModule('deliveryOrder', data, { + fixedWhere: B2B_FIXED_WHERE, + b2bDetailFilter: true, + }); + return { + ...result, + list: await this.attachB2bJobDetail(result.list, warehouseId), + }; + } +} + +module.exports = DeliveryOrder2bService; diff --git a/app/service/systemMethods/order/index.js b/app/service/systemMethods/order/index.js index 1f90d5f..5a2ad88 100644 --- a/app/service/systemMethods/order/index.js +++ b/app/service/systemMethods/order/index.js @@ -22,7 +22,8 @@ class OrderIndexService extends OrderBaseService { /** * 订单转 B2B 订单。 * - * 仅限待处理表中未打印、未锁定、未拦截的订单;不符合条件跳过。 + * 仅限待处理表中处于待处理阶段(step in [1,2,3])、未取消、未拣货、未复核、 + * 未锁定、未拦截的订单(打印状态不限制);不符合条件跳过。 * 事务内:订单表 is_b2b 置 Y + 写入 wms_order_b2b 作业明细,提交后写操作日志。 * * @param {Object} data 请求体。 @@ -69,8 +70,8 @@ class OrderIndexService extends OrderBaseService { /** * 取消 B2B 出库:订单流转回正常订单。 * - * 仅限待处理表中 is_b2b=Y 且未打印、未锁定、未拦截、B2B 面单未打印的订单; - * 不符合条件跳过。事务内:订单表 is_b2b 置回 N + B2B 作业明细软删除, + * 仅限待处理表中 is_b2b=Y 且未锁定、未拦截的订单(打印状态不限制); + * 不符合条件跳过。事务内:订单表 is_b2b 置回 N + B2B 作业明细物理删除, * 提交后写操作日志。 * * @param {Object} data 请求体。 diff --git a/app/service/systemMethods/order/pendingOrder2b.js b/app/service/systemMethods/order/pendingOrder2b.js new file mode 100644 index 0000000..865ba02 --- /dev/null +++ b/app/service/systemMethods/order/pendingOrder2b.js @@ -0,0 +1,47 @@ +'use strict'; + +const OrderBaseService = require('./base'); + +/** B2B 列表强制条件 */ +const B2B_FIXED_WHERE = Object.freeze({ is_b2b: 'Y' }); + +/** + * B2B 待处理订单系统方法。 + * + * 查询条件与 order.pendingOrder.list 完全一致(current 分表 + 模块默认 where), + * 仅额外强制 is_b2b='Y',用于 B2B 备货/提货作业的独立列表。 + */ +class PendingOrder2bService extends OrderBaseService { + constructor(ctx) { + super(ctx); + const _noNeedLogin = ''; + const _noNeedRight = 'list'; + const _noNeedLog = 'list'; + const _noNeedAuth = 'list'; + this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth); + } + + /** + * B2B 待处理订单列表。 + * + * 在 order.pendingOrder.list 的基础上强制 is_b2b='Y',并附加 wms_order_b2b 作业明细字段 + * (total_box_count / pickup_plate_number / prep_remark / prep_duration_seconds / + * is_picked_up / picked_up_at / created_at / prep_at)。 + * + * @param {Object} data 请求体(与 order.pendingOrder.list 一致)。 + * @return {Promise} 列表与分页信息。 + */ + async list(data = {}) { + const warehouseId = this.getWarehouseId(); + const result = await this.listByModule('pendingOrder', data, { + fixedWhere: B2B_FIXED_WHERE, + b2bDetailFilter: true, + }); + return { + ...result, + list: await this.attachB2bJobDetail(result.list, warehouseId), + }; + } +} + +module.exports = PendingOrder2bService; diff --git a/app/service/systemMethods/order/wave.js b/app/service/systemMethods/order/wave.js index cfdf9bc..4819e67 100644 --- a/app/service/systemMethods/order/wave.js +++ b/app/service/systemMethods/order/wave.js @@ -5241,6 +5241,9 @@ class WaveService extends OrderBaseService { specialFieldMap: { quickWhere: { bucket: 'quick' } }, }); + // 兜底列表同样排除 B2B 订单(B2B 订单不参与波次抓取,也不应出现在"未命中策略"列表中) + queryWhere = this.appendConditionToWhere(queryWhere, this.buildExcludeB2bCondition()); + // 处理快递号虚拟筛选 if (expressNumbers.length > 0) { const orderIds = await this.findOrderIdsByExpressNumbers(expressNumbers, contextWarehouseId); @@ -8685,6 +8688,150 @@ class WaveService extends OrderBaseService { * @param {Array|number|string} data.id 订单ID集合别名。 * @return {Promise} 批量移出结果。 */ + /** + * 在调用方事务内把订单从波次中摘除。 + * + * 处理内容:清空订单波次字段(wave_id/wave_no/wave_scope/wave_strategy_version/wave_scan_result)、 + * 重建受影响波次的订单索引(wave_index 重排)、回写 wms_wave_batch 统计(空波次置 wave_status=-1)。 + * 供 batchRemoveOrders、订单转 B2B 等「订单离开波次」场景复用;活动拣货任务校验由调用方负责。 + * + * @param {Object} params 摘除参数。 + * @param {number|string} params.warehouseId 仓库ID。 + * @param {Array} params.orderIds 待摘除订单ID集合。 + * @param {Object} params.orderModel 订单 current 分表模型。 + * @param {Object} params.transaction 事务对象(必填)。 + * @return {Promise} { removed_order_ids, affected_wave_ids, updated_wave_ids, + * emptied_wave_ids, wave_no_map } 摘除结果。 + */ + async detachOrdersFromWavesInTransaction({ warehouseId, orderIds, orderModel, transaction } = {}) { + const normalizedWarehouseId = Number(warehouseId || 0); + const normalizedOrderIds = this.normalizeIdsInput(orderIds); + const emptyResult = { + removed_order_ids: [], + affected_wave_ids: [], + updated_wave_ids: [], + emptied_wave_ids: [], + wave_no_map: new Map(), + }; + + if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0 + || normalizedOrderIds.length === 0) { + return emptyResult; + } + + if (!transaction) { + throw new Error('detachOrdersFromWavesInTransaction 必须在事务内调用'); + } + + const currentOrderModel = orderModel || await this.getOrderModel('pendingOrder', normalizedWarehouseId); + if (!currentOrderModel || typeof currentOrderModel.findAll !== 'function') { + return emptyResult; + } + + const waveRows = await currentOrderModel.findAll({ + attributes: [ 'id', 'wave_id', 'wave_no' ], + where: { + id: { [Op.in]: normalizedOrderIds }, + wave_id: { [Op.gt]: 0 }, + }, + raw: true, + transaction, + }); + + const removableRows = Array.isArray(waveRows) ? waveRows : []; + const removableOrderIds = [ ...new Set(removableRows + .map(row => Number(row && row.id || 0)) + .filter(id => Number.isInteger(id) && id > 0)) ]; + const affectedWaveIds = [ ...new Set(removableRows + .map(row => Number(row && row.wave_id || 0)) + .filter(waveId => Number.isInteger(waveId) && waveId > 0)) ]; + const waveNoMap = new Map(removableRows + .map(row => [ Number(row && row.id || 0), String(row && row.wave_no || '').trim() ]) + .filter(item => item[0] > 0)); + + if (removableOrderIds.length === 0 || affectedWaveIds.length === 0) { + return emptyResult; + } + + await currentOrderModel.update({ + wave_id: 0, + wave_no: '', + wave_scope: 0, + wave_strategy_version: 0, + wave_scan_result: 0, + }, { + where: { + id: { [Op.in]: removableOrderIds }, + }, + transaction, + }); + + // 重建受影响波次的订单索引(wave_index 重新排序),并获取各波次剩余订单数量 + const remainingCountMap = await this.replaceOrderWaveIndexByWaveIds({ + warehouseId: normalizedWarehouseId, + waveIds: affectedWaveIds, + orderModel: currentOrderModel, + transaction, + }); + + const updatedWaveIds = []; + const emptiedWaveIds = []; + + for (const waveId of affectedWaveIds) { + const remainingCount = Number(remainingCountMap.get(waveId) || 0); + if (remainingCount > 0) { + updatedWaveIds.push(waveId); + } else { + emptiedWaveIds.push(waveId); + } + } + + for (const waveId of updatedWaveIds) { + const remainingCount = Number(remainingCountMap.get(waveId) || 0); + await this.ctx.model.query(` + UPDATE wms_wave_batch + SET total_orders = :remainingCount, + processed_orders = LEAST(processed_orders, :remainingCount), + update_time = NOW() + WHERE warehouse_id = :warehouseId + AND wave_id = :waveId + `, { + replacements: { + warehouseId: normalizedWarehouseId, + waveId, + remainingCount, + }, + transaction, + }); + } + + if (emptiedWaveIds.length > 0) { + await this.ctx.model.query(` + UPDATE wms_wave_batch + SET total_orders = 0, + processed_orders = 0, + wave_status = -1, + update_time = NOW() + WHERE warehouse_id = :warehouseId + AND wave_id IN (:waveIds) + `, { + replacements: { + warehouseId: normalizedWarehouseId, + waveIds: emptiedWaveIds, + }, + transaction, + }); + } + + return { + removed_order_ids: removableOrderIds, + affected_wave_ids: affectedWaveIds, + updated_wave_ids: updatedWaveIds, + emptied_wave_ids: emptiedWaveIds, + wave_no_map: waveNoMap, + }; + } + async batchRemoveOrders(data = {}) { const contextWarehouseId = Number(this.getWarehouseId() || 0); if (!Number.isInteger(contextWarehouseId) || contextWarehouseId <= 0) { @@ -8787,81 +8934,15 @@ class WaveService extends OrderBaseService { }); } - const orderUpdateResult = await orderModel.update({ - wave_id: 0, - wave_no: '', - wave_scope: 0, - wave_strategy_version: 0, - wave_scan_result: 0, - }, { - where: { - id: { [Op.in]: removablePendingIds }, - }, - transaction, - }); - - const updatedOrderCount = Number(Array.isArray(orderUpdateResult) ? orderUpdateResult[0] : orderUpdateResult || 0); - - // 重建受影响波次的订单索引(wave_index 重新排序),并获取各波次剩余订单数量 - const remainingCountMap = await this.replaceOrderWaveIndexByWaveIds({ + const detachResult = await this.detachOrdersFromWavesInTransaction({ warehouseId, - waveIds: affectedWaveIds, + orderIds: removablePendingIds, orderModel, transaction, }); - - const updatedWaveIds = []; - const emptiedWaveIds = []; - - for (const waveId of affectedWaveIds) { - const remainingCount = Number(remainingCountMap.get(waveId) || 0); - if (remainingCount > 0) { - updatedWaveIds.push(waveId); - } else { - emptiedWaveIds.push(waveId); - } - } - - for (const waveId of updatedWaveIds) { - const remainingCount = Number(remainingCountMap.get(waveId) || 0); - const updateWaveSql = ` - UPDATE wms_wave_batch - SET total_orders = :remainingCount, - processed_orders = LEAST(processed_orders, :remainingCount), - update_time = NOW() - WHERE warehouse_id = :warehouseId - AND wave_id = :waveId - `; - - await this.ctx.model.query(updateWaveSql, { - replacements: { - warehouseId, - waveId, - remainingCount, - }, - transaction, - }); - } - - if (emptiedWaveIds.length > 0) { - const emptyWaveSql = ` - UPDATE wms_wave_batch - SET total_orders = 0, - processed_orders = 0, - wave_status = -1, - update_time = NOW() - WHERE warehouse_id = :warehouseId - AND wave_id IN (:waveIds) - `; - - await this.ctx.model.query(emptyWaveSql, { - replacements: { - warehouseId, - waveIds: emptiedWaveIds, - }, - transaction, - }); - } + const updatedOrderCount = detachResult.removed_order_ids.length; + const updatedWaveIds = detachResult.updated_wave_ids; + const emptiedWaveIds = detachResult.emptied_wave_ids; await transaction.commit(); await this.batchCreateOrderOperationLogs(removeOrderLogItems, { diff --git a/app/service/systems/delivery_order.js b/app/service/systems/delivery_order.js index 1ef6d71..951eab4 100644 --- a/app/service/systems/delivery_order.js +++ b/app/service/systems/delivery_order.js @@ -2353,7 +2353,7 @@ class DeliveryOrderService extends Service { id: orderId, warehouse_id: warehouseId, }, - attributes: [ 'id', 'wave_id', 'step', 'status', 'outbound_status', 'lock_status', 'has_sn_item' ], + attributes: [ 'id', 'wave_id', 'step', 'status', 'outbound_status', 'lock_status', 'has_sn_item', 'is_b2b' ], transaction, lock: transaction.LOCK.UPDATE, }); @@ -2368,6 +2368,12 @@ class DeliveryOrderService extends Service { return false; } + // B2B 订单不参与波次抓取,自动加团时静默跳过(NULL 视为非 B2B,兼容存量行) + if (String(orderRow.is_b2b || '').trim() === 'Y') { + await transaction.commit(); + return false; + } + // SN(序列号管理)订单不参与团购,自动加团时静默跳过 if (String(orderRow.has_sn_item || '').trim().toUpperCase() === 'Y') { await transaction.commit(); @@ -2507,6 +2513,8 @@ class DeliveryOrderService extends Service { outbound_status: { [Op.ne]: 'padding' }, lock_status: 'none', sys_logistics_code: structure.logisticsName, + // 自动加团同样不抓取 B2B 订单(NULL 视为非 B2B,兼容存量行) + is_b2b: { [Op.or]: [{ [Op.is]: null }, 'N' ] }, // 团购排除 SN(序列号管理)订单 [Op.or]: [ { has_sn_item: { [Op.is]: null } }, diff --git a/app/service/systems/operation_log.js b/app/service/systems/operation_log.js index 00faaaf..089ffe6 100644 --- a/app/service/systems/operation_log.js +++ b/app/service/systems/operation_log.js @@ -22,6 +22,7 @@ class operationLogService extends Service { * @param {string|number} params.businessId 业务ID。 * @param {string} params.operationCode 操作编码。 * @param {Object} [params.operator={}] 操作人信息。 + * @param {string} [params.changeSummary=''] 变更描述(extras.message 缺省时作为日志说明落库)。 * @param {Object} [params.extras={}] 扩展字段。 * @param {Object|null} [params.beforeChanges=null] 操作前快照。 * @return {Object} 可直接落库的日志数据。 @@ -34,6 +35,7 @@ class operationLogService extends Service { operationCode, operator = {}, beforeChanges = null, + changeSummary = '', extras = {}, } = params; @@ -49,7 +51,8 @@ class operationLogService extends Service { warehouse_id: extras.warehouseId ?? null, before_changes: beforeChanges, platform_code: ctx.user?.platform_code || 'SYSTEM', - message: extras.message || null, + // 日志说明:优先 extras.message;调用方只传 changeSummary 时回退使用,避免前端"操作说明"为空 + message: extras.message || changeSummary || null, }; } diff --git a/app/service/systems/order_b2b.js b/app/service/systems/order_b2b.js index 0c30060..935f7ec 100644 --- a/app/service/systems/order_b2b.js +++ b/app/service/systems/order_b2b.js @@ -9,6 +9,22 @@ const ORDER_B2B_CANCEL_OPERATION_CODE = 'ORDER_B2B_CANCEL'; /** 单次转换订单数上限 */ const ORDER_B2B_CONVERT_BATCH_LIMIT = 200; +/** + * 允许转 B2B 的订单步骤白名单。 + * + * 仅待处理阶段(1 已审核 / 2 处理中 / 3 驳回异常)可转;4 配送中(含已提交出库)、 + * 5 已完成、9 已关闭等已离开待处理阶段的订单一律拒绝,避免误转已配送/已关闭订单。 + */ +const ORDER_B2B_CONVERT_ALLOWED_STEPS = new Set([ 1, 2, 3 ]); + +/** 非白名单步骤的拒绝文案 */ +const ORDER_B2B_CONVERT_STEP_SKIP_REASONS = Object.freeze({ + 0: '订单待审核,不允许转B2B', + 4: '订单已提交出库,不允许转B2B', + 5: '订单已完成,不允许转B2B', + 9: '订单已关闭,不允许转B2B', +}); + /** * B2B 订单业务服务。 * @@ -18,16 +34,19 @@ class OrderB2bService extends Service { /** * 将待处理订单批量转为 B2B 订单。 * - * 仅限待处理表(current 分表)中未打印、未锁定、未拦截的订单; - * 不符合条件的订单跳过(计入 skipped),不报错。事务内完成 - * is_b2b 置 Y 与 wms_order_b2b 明细写入;操作日志在事务提交后写入。 + * 仅限待处理表(current 分表)中处于待处理阶段(step in [1,2,3])、未取消、 + * 未拣货、未复核、未锁定、未拦截的订单(打印状态不限制);不符合条件的订单跳过(计入 skipped),不报错。 + * 已在波次中的订单(含库内抓取进波次的订单)转换成功后会在同一事务内从波次摘除 + * (清空波次字段、重排 wave_index、回写波次统计);若波次存在进行中的拣货任务则跳过转换。 + * 事务内完成 is_b2b 置 Y 与 wms_order_b2b 明细写入;操作日志在事务提交后写入。 * * @param {Object} params 转换参数。 * @param {number|string} params.warehouseId 仓库ID。 * @param {Array} params.orderIds 订单ID数组。 * @param {Object|null} [params.operator=null] 操作人 { id, name }。 * @return {Promise} { converted_order_ids, converted_count, skipped_order_ids, - * skipped_count, skipped_reasons, not_found_order_ids } + * skipped_count, skipped_reasons, not_found_order_ids, removed_from_wave_order_ids, + * affected_wave_ids, emptied_wave_ids, active_pick_task_wave_ids } */ async convertOrdersToB2b(params = {}) { const { ctx, app } = this; @@ -58,13 +77,18 @@ class OrderB2bService extends Service { const transaction = await ctx.model.transaction(); const convertedRows = []; const skippedReasons = []; + const waveRemovalLogItems = []; + let waveDetachResult = null; let notFoundOrderIds = []; + let notConvertedWaveIds = []; try { const lockRows = await orderModel.findAll({ attributes: [ - 'id', 'delivery_order_code', 'store_id', 'step', + 'id', 'delivery_order_code', 'step', 'status', + 'pick_status', 'recheck_status', 'print_status', 'lock_status', 'intercept_status', 'is_b2b', + 'wave_id', 'wave_no', ], where: { id: { [Op.in]: normalizedOrderIds }, @@ -97,6 +121,46 @@ class OrderB2bService extends Service { convertedRows.push(row); } + // 已在波次中的订单:波次存在进行中的拣货任务时无法安全摘除,跳过转换 + const waveBoundRows = convertedRows.filter(row => Number(row && row.wave_id || 0) > 0); + if (waveBoundRows.length > 0) { + const waveIds = [ ...new Set(waveBoundRows.map(row => Number(row.wave_id))) ]; + const activeWaveRows = await ctx.model.query(` + SELECT DISTINCT ptw.wave_id + FROM wms_wave_pick_task_wave ptw + INNER JOIN wms_wave_pick_task pt ON pt.id = ptw.task_id + WHERE ptw.wave_id IN (:waveIds) + AND pt.status IN (0, 1) + `, { + replacements: { waveIds }, + type: ctx.model.QueryTypes.SELECT, + transaction, + }); + const activeWaveIdSet = new Set((Array.isArray(activeWaveRows) ? activeWaveRows : []) + .map(row => Number(row && row.wave_id || 0)) + .filter(waveId => Number.isInteger(waveId) && waveId > 0)); + + if (activeWaveIdSet.size > 0) { + notConvertedWaveIds = [ ...activeWaveIdSet ].sort((a, b) => a - b); + const retainedRows = []; + for (const row of convertedRows) { + const waveId = Number(row && row.wave_id || 0); + if (waveId > 0 && activeWaveIdSet.has(waveId)) { + skippedReasons.push({ + order_id: Number(row.id), + delivery_order_code: String(row.delivery_order_code || '').trim(), + reason: '订单所在波次存在进行中的拣货任务,不允许转B2B', + }); + continue; + } + retainedRows.push(row); + } + + convertedRows.length = 0; + convertedRows.push(...retainedRows); + } + } + if (convertedRows.length > 0) { const convertedOrderIds = convertedRows.map(row => Number(row.id)); const now = new Date(); @@ -112,43 +176,58 @@ class OrderB2bService extends Service { } ); - // 写入 B2B 作业明细(uk_order_id 唯一): - // 首次转换创建新行;二次转换(存在历史软删除行)恢复同一行并重置作业字段 + // 写入 B2B 作业明细(uk_warehouse_order 唯一): + // 正常流程为创建新行;并发/重复转换命中同一行时重置作业字段(取消 B2B 为物理删除,无历史行恢复) const b2bModel = ctx.model.OrderB2b; for (const row of convertedRows) { const orderId = Number(row.id); const baseFields = { warehouse_id: normalizedWarehouseId, - store_id: Number(row.store_id || 0) > 0 ? Number(row.store_id) : null, - delivery_order_code: String(row.delivery_order_code || '').trim(), - updated_at: now, + order_id: orderId, }; const existing = await b2bModel.findOne({ - where: { order_id: orderId }, - paranoid: false, + where: { + warehouse_id: normalizedWarehouseId, + order_id: orderId, + }, transaction, }); if (existing) { - // 恢复历史行并重置作业字段(取消 B2B 后的旧作业数据不再有效) await existing.update({ - deleted_at: null, total_box_count: 0, pickup_plate_number: null, prep_remark: null, prep_duration_seconds: 0, + prep_at: null, is_picked_up: 'N', picked_up_at: null, - is_print: 'N', ...baseFields, - }, { transaction, paranoid: false }); + }, { transaction }); } else { await b2bModel.create({ - order_id: orderId, ...baseFields, created_at: now, }, { transaction }); } } + + // 已在波次中的订单(含库内抓取进波次的订单):转 B2B 后必须从波次摘除, + // 清空波次字段、重排 wave_index、回写波次统计(空波次置 wave_status=-1) + const waveBoundConvertedRows = convertedRows.filter(row => Number(row && row.wave_id || 0) > 0); + if (waveBoundConvertedRows.length > 0) { + waveDetachResult = await ctx.service.systemMethods.order.wave.detachOrdersFromWavesInTransaction({ + warehouseId: normalizedWarehouseId, + orderIds: waveBoundConvertedRows.map(row => Number(row.id)), + orderModel, + transaction, + }); + for (const orderId of waveDetachResult.removed_order_ids) { + waveRemovalLogItems.push({ + orderId, + waveNo: String(waveDetachResult.wave_no_map.get(orderId) || '').trim(), + }); + } + } } await transaction.commit(); @@ -171,6 +250,7 @@ class OrderB2bService extends Service { warehouseId: normalizedWarehouseId, orderId: Number(row.id), orderNo: String(row.delivery_order_code || '').trim(), + message: '订单转为B2B订单', }, beforeChanges: null, }); @@ -179,6 +259,30 @@ class OrderB2bService extends Service { } } + // 波次摘除日志在事务提交后写入,失败不影响主流程 + for (const item of waveRemovalLogItems) { + try { + await ctx.service.systems.operationLog.createOperationLog({ + businessType: 'order', + businessId: Number(item.orderId), + operationCode: 'ORDER_WAVE_REMOVE', + operationAction: 'UPDATE', + changeSummary: `订单从波次 ${item.waveNo || '未知波次'} 中移除(转B2B)`, + operator, + extras: { + warehouseId: normalizedWarehouseId, + orderId: Number(item.orderId), + waveNo: item.waveNo, + reason: 'convertToB2b', + message: `订单从波次 ${item.waveNo || '未知波次'} 中移除(转B2B)`, + }, + beforeChanges: null, + }); + } catch (error) { + ctx.logger.warn(`[orderB2b.convertOrdersToB2b] 写入波次移除日志失败,不影响业务, orderId=${item.orderId}, error=${error.message}`); + } + } + const skippedOrderIds = [ ...new Set(skippedReasons.map(item => item.order_id)) ]; return { converted_order_ids: [ ...new Set(convertedRows.map(row => Number(row.id))) ], @@ -187,25 +291,43 @@ class OrderB2bService extends Service { skipped_count: skippedOrderIds.length, skipped_reasons: skippedReasons, not_found_order_ids: notFoundOrderIds, + removed_from_wave_order_ids: waveDetachResult ? waveDetachResult.removed_order_ids : [], + affected_wave_ids: waveDetachResult ? waveDetachResult.affected_wave_ids : [], + emptied_wave_ids: waveDetachResult ? waveDetachResult.emptied_wave_ids : [], + active_pick_task_wave_ids: notConvertedWaveIds, }; } /** * 判断订单是否满足转 B2B 条件,返回跳过原因;可转换时返回空串。 * - * 条件:待处理(step != 0)、未打印(print_status != fin)、 + * 条件:非已取消(status != cancel)、处于待处理阶段(step in [1,2,3])、 + * 未拣货(pick_status != fin)、未复核(recheck_status != fin)、 * 未锁定(lock_status = none)、未拦截(intercept_status = none)、未转 B2B(is_b2b != Y)。 + * 打印状态不参与校验:已打印(print_status = fin)的订单同样允许转 B2B。 * * @param {Object} row 订单行。 * @return {string} 跳过原因,可转换返回空字符串。 */ resolveConvertSkipReason(row = {}) { - if (Number(row && row.step || 0) === 0) { - return '订单待审核,不允许转B2B'; + // 已取消订单即使仍停留在待处理步骤也不允许转 B2B + if (String(row && row.status || '').trim() === 'cancel') { + return '订单已取消,不允许转B2B'; } - if (String(row && row.print_status || '').trim() === 'fin') { - return '订单已打印,不允许转B2B'; + // 仅待处理阶段可转:4 配送中/已提交出库、5 已完成、9 已关闭一律拒绝 + const step = Number(row && row.step || 0); + if (!ORDER_B2B_CONVERT_ALLOWED_STEPS.has(step)) { + return ORDER_B2B_CONVERT_STEP_SKIP_REASONS[step] || `订单当前步骤(${step})不允许转B2B`; + } + + // 已进入作业流程的订单不允许转 B2B:拣货/复核完成后订单实物已分拣、单据已核对 + if (String(row && row.pick_status || '').trim() === 'fin') { + return '订单已拣货,不允许转B2B'; + } + + if (String(row && row.recheck_status || '').trim() === 'fin') { + return '订单已复核,不允许转B2B'; } if (String(row && row.lock_status || 'none').trim() !== 'none') { @@ -226,9 +348,8 @@ class OrderB2bService extends Service { /** * 取消 B2B 出库:将 B2B 订单流转回正常订单。 * - * 仅限待处理表(current 分表)中 is_b2b=Y 且未打印、未锁定、未拦截、 - * B2B 面单未打印(wms_order_b2b.is_print=N)的订单;不符合条件的订单跳过, - * 不报错。事务内完成 is_b2b 置回 N 与 B2B 作业明细软删除; + * 仅限待处理表(current 分表)中 is_b2b=Y 且未锁定、未拦截的订单(打印状态不限制); + * 不符合条件的订单跳过,不报错。事务内完成 is_b2b 置回 N 与 B2B 作业明细物理删除; * 操作日志在事务提交后写入。 * * @param {Object} params 取消参数。 @@ -272,7 +393,7 @@ class OrderB2bService extends Service { try { const lockRows = await orderModel.findAll({ attributes: [ - 'id', 'delivery_order_code', 'store_id', 'step', + 'id', 'delivery_order_code', 'step', 'print_status', 'lock_status', 'intercept_status', 'is_b2b', ], where: { @@ -287,26 +408,13 @@ class OrderB2bService extends Service { const rowMap = new Map((Array.isArray(lockRows) ? lockRows : []).map(row => [ Number(row && row.id || 0), row ])); notFoundOrderIds = normalizedOrderIds.filter(orderId => !rowMap.has(orderId)); - // B2B 作业明细打印状态(is_print):已打印 B2B 面单的订单不允许取消 - const b2bRows = await ctx.model.OrderB2b.findAll({ - where: { - order_id: { [Op.in]: normalizedOrderIds }, - deleted_at: null, - }, - attributes: [ 'order_id', 'is_print' ], - raw: true, - transaction, - }); - const b2bPrintMap = new Map((Array.isArray(b2bRows) ? b2bRows : []) - .map(row => [ Number(row && row.order_id || 0), String(row && row.is_print || 'N').trim() ])); - for (const orderId of normalizedOrderIds) { const row = rowMap.get(orderId); if (!row) { continue; } - const skipReason = this.resolveCancelSkipReason(row, b2bPrintMap.get(orderId)); + const skipReason = this.resolveCancelSkipReason(row); if (skipReason) { skippedReasons.push({ order_id: orderId, @@ -334,17 +442,14 @@ class OrderB2bService extends Service { } ); - // B2B 作业明细软删除(保留历史) - await ctx.model.OrderB2b.update( - { deleted_at: now, updated_at: now }, - { - where: { - order_id: { [Op.in]: canceledOrderIds }, - deleted_at: null, - }, - transaction, - } - ); + // B2B 作业明细物理删除(不保留历史),关联条件固定为 warehouse_id + order_id + await ctx.model.OrderB2b.destroy({ + where: { + warehouse_id: normalizedWarehouseId, + order_id: { [Op.in]: canceledOrderIds }, + }, + transaction, + }); } await transaction.commit(); @@ -367,6 +472,7 @@ class OrderB2bService extends Service { warehouseId: normalizedWarehouseId, orderId: Number(row.id), orderNo: String(row.delivery_order_code || '').trim(), + message: '取消B2B出库,订单流转回正常订单', }, beforeChanges: null, }); @@ -389,15 +495,13 @@ class OrderB2bService extends Service { /** * 判断 B2B 订单是否满足取消条件,返回跳过原因;可取消时返回空串。 * - * 条件:待处理(step != 0)、是 B2B(is_b2b = Y)、未打印(print_status != fin)、 - * 未锁定(lock_status = none)、未拦截(intercept_status = none)、 - * B2B 面单未打印(is_print != Y)。 + * 条件:待处理(step != 0)、是 B2B(is_b2b = Y)、未锁定(lock_status = none)、 + * 未拦截(intercept_status = none)。打印状态不参与校验。 * * @param {Object} row 订单行。 - * @param {string} b2bIsPrint B2B 作业明细打印状态(无明细行时为空串,视为未打印)。 * @return {string} 跳过原因,可取消返回空字符串。 */ - resolveCancelSkipReason(row = {}, b2bIsPrint = '') { + resolveCancelSkipReason(row = {}) { if (Number(row && row.step || 0) === 0) { return '订单待审核,不允许取消B2B'; } @@ -406,10 +510,6 @@ class OrderB2bService extends Service { return '订单不是B2B订单'; } - if (String(row && row.print_status || '').trim() === 'fin') { - return '订单已打印,不允许取消B2B'; - } - if (String(row && row.lock_status || 'none').trim() !== 'none') { return '订单已锁定,不允许取消B2B'; } @@ -418,10 +518,6 @@ class OrderB2bService extends Service { return '订单已拦截,不允许取消B2B'; } - if (String(b2bIsPrint || '').trim() === 'Y') { - return 'B2B面单已打印,不允许取消B2B'; - } - return ''; } } diff --git a/database/migrations/20261115180000-refactor-wms-order-b2b.js b/database/migrations/20261115180000-refactor-wms-order-b2b.js new file mode 100644 index 0000000..646a3ef --- /dev/null +++ b/database/migrations/20261115180000-refactor-wms-order-b2b.js @@ -0,0 +1,202 @@ +'use strict'; + +/** + * wms_order_b2b 精简重构。 + * + * 变更内容: + * 1. 新增 prep_at(备货完成时间)。 + * 2. 移除 is_print / updated_at / deleted_at / delivery_order_code / store_id: + * - is_print 随 B2B 面单打印能力下线而废弃;打印限制改由订单主表 print_status 决定(且已放开)。 + * - updated_at / deleted_at 移除后作业明细不再软删除。 + * - delivery_order_code / store_id 为快照冗余字段,关联读统一走 warehouse_id + order_id。 + * 3. 唯一键 uk_order_id 改为 uk_warehouse_order(warehouse_id, order_id): + * 分表 id 按仓库各自发号,跨仓可能重叠,只按 order_id 唯一会误伤。 + * 4. 取消 B2B 由软删除改为物理删除:迁移时先清掉历史软删除行,避免移除 deleted_at 后"复活"。 + * + * 幂等:所有列/索引变更前都做存在性判断,重复执行安全。 + * ⚠ 数据不可逆:删除的列与历史软删除行不会保留。 + */ + +const TABLE_NAME = 'wms_order_b2b'; + +/** 需要移除的列 */ +const DROP_COLUMNS = [ 'is_print', 'updated_at', 'deleted_at', 'delivery_order_code', 'store_id' ]; + +/** 需要移除的索引 */ +const DROP_INDEXES = [ 'uk_order_id', 'idx_warehouse_id', 'idx_store_id', 'idx_delivery_order_code', 'idx_is_print', 'idx_deleted_at' ]; + +/** + * 判断索引是否存在。 + * @param {import('sequelize').QueryInterface} queryInterface 查询接口。 + * @param {string} indexName 索引名。 + * @return {Promise} 是否存在。 + */ +async function indexExists(queryInterface, indexName) { + const indexes = await queryInterface.showIndex(TABLE_NAME); + return (Array.isArray(indexes) ? indexes : []).some(index => { + const name = String(index && (index.name || index.Key_name || index.key_name) || ''); + return name.toLowerCase() === String(indexName).toLowerCase(); + }); +} + +/** + * 安全删除索引(不存在则跳过)。 + * @param {import('sequelize').QueryInterface} queryInterface 查询接口。 + * @param {string} indexName 索引名。 + * @param {Array} log 执行日志。 + * @return {Promise} 无返回值。 + */ +async function dropIndexIfExists(queryInterface, indexName, log) { + if (!(await indexExists(queryInterface, indexName))) { + log.push({ action: 'skip-drop-index', indexName, reason: 'not-exists' }); + return; + } + await queryInterface.removeIndex(TABLE_NAME, indexName); + log.push({ action: 'drop-index', indexName }); +} + +/** + * 安全删除列(不存在则跳过)。 + * @param {import('sequelize').QueryInterface} queryInterface 查询接口。 + * @param {string} columnName 列名。 + * @param {Object} columns describeTable 结果。 + * @param {Array} log 执行日志。 + * @return {Promise} 无返回值。 + */ +async function dropColumnIfExists(queryInterface, columnName, columns, log) { + if (!Object.prototype.hasOwnProperty.call(columns, columnName)) { + log.push({ action: 'skip-drop-column', columnName, reason: 'not-exists' }); + return; + } + await queryInterface.removeColumn(TABLE_NAME, columnName); + log.push({ action: 'drop-column', columnName }); +} + +module.exports = { + /** + * 执行迁移。 + * @param {import('sequelize').QueryInterface} queryInterface 查询接口。 + * @param {Object} Sequelize Sequelize 类型集合。 + * @return {Promise} 无返回值。 + */ + async up(queryInterface, Sequelize) { + const { DATE } = Sequelize; + const log = []; + const query = queryInterface.sequelize; + + let columns = await queryInterface.describeTable(TABLE_NAME); + if (!columns || Object.keys(columns).length === 0) { + throw new Error(`表 ${TABLE_NAME} 不存在,无法执行重构迁移`); + } + + // 1. 历史软删除行清理(deleted_at 即将被移除,不清掉会变成"有效行") + if (Object.prototype.hasOwnProperty.call(columns, 'deleted_at')) { + const [ deletedRows ] = await query.query(`DELETE FROM ${TABLE_NAME} WHERE deleted_at IS NOT NULL`); + log.push({ action: 'delete-soft-deleted-rows', affected: Number(deletedRows && deletedRows.affectedRows || 0) }); + } + + // 2. 同仓同单重复行清理(保留 id 最大的一行),为新唯一键让路 + if (Object.prototype.hasOwnProperty.call(columns, 'warehouse_id') + && Object.prototype.hasOwnProperty.call(columns, 'order_id')) { + const [ dedupeRows ] = await query.query(` + DELETE t FROM ${TABLE_NAME} t + INNER JOIN ${TABLE_NAME} keep + ON keep.warehouse_id = t.warehouse_id + AND keep.order_id = t.order_id + AND keep.id > t.id + `); + log.push({ action: 'delete-duplicate-rows', affected: Number(dedupeRows && dedupeRows.affectedRows || 0) }); + } + + // 3. 新增 prep_at + if (!Object.prototype.hasOwnProperty.call(columns, 'prep_at')) { + await queryInterface.addColumn(TABLE_NAME, 'prep_at', { + type: DATE, + allowNull: true, + comment: '备货完成时间', + }); + log.push({ action: 'add-column', columnName: 'prep_at' }); + } else { + log.push({ action: 'skip-add-column', columnName: 'prep_at', reason: 'exists' }); + } + + // 4. 删除废弃索引(含旧唯一键与冗余 warehouse_id 索引) + for (const indexName of DROP_INDEXES) { + await dropIndexIfExists(queryInterface, indexName, log); + } + + // 5. 建立新的复合唯一键 + if (!(await indexExists(queryInterface, 'uk_warehouse_order'))) { + await queryInterface.addIndex(TABLE_NAME, [ 'warehouse_id', 'order_id' ], { + name: 'uk_warehouse_order', + unique: true, + }); + log.push({ action: 'add-index', indexName: 'uk_warehouse_order' }); + } else { + log.push({ action: 'skip-add-index', indexName: 'uk_warehouse_order', reason: 'exists' }); + } + + // 6. 删除废弃列 + columns = await queryInterface.describeTable(TABLE_NAME); + for (const columnName of DROP_COLUMNS) { + await dropColumnIfExists(queryInterface, columnName, columns, log); + } + + console.log('[20261115180000-refactor-wms-order-b2b] up results:', JSON.stringify(log)); + }, + + /** + * 回滚迁移:恢复被移除的列与索引(历史数据不可恢复)。 + * @param {import('sequelize').QueryInterface} queryInterface 查询接口。 + * @param {Object} Sequelize Sequelize 类型集合。 + * @return {Promise} 无返回值。 + */ + async down(queryInterface, Sequelize) { + const { DATE, ENUM, STRING, BIGINT } = Sequelize; + const log = []; + + let columns = await queryInterface.describeTable(TABLE_NAME); + + await dropIndexIfExists(queryInterface, 'uk_warehouse_order', log); + + const restoreColumns = [ + [ 'store_id', { type: BIGINT(20).UNSIGNED, allowNull: true, comment: '货主ID' }], + [ 'delivery_order_code', { type: STRING(50), allowNull: true, comment: '发货单号快照' }], + [ 'is_print', { type: ENUM('Y', 'N'), allowNull: false, defaultValue: 'N', comment: '是否打印:Y=已打印 N=未打印' }], + [ 'updated_at', { type: DATE, allowNull: true, comment: '更新时间' }], + [ 'deleted_at', { type: DATE, allowNull: true, comment: '软删除时间' }], + ]; + + for (const [ columnName, definition ] of restoreColumns) { + if (Object.prototype.hasOwnProperty.call(columns, columnName)) { + log.push({ action: 'skip-add-column', columnName, reason: 'exists' }); + continue; + } + await queryInterface.addColumn(TABLE_NAME, columnName, definition); + log.push({ action: 'add-column', columnName }); + } + + const restoreIndexes = [ + [ 'uk_order_id', [ 'order_id' ], true ], + [ 'idx_warehouse_id', [ 'warehouse_id' ], false ], + [ 'idx_store_id', [ 'store_id' ], false ], + [ 'idx_delivery_order_code', [ 'delivery_order_code' ], false ], + [ 'idx_is_print', [ 'is_print' ], false ], + [ 'idx_deleted_at', [ 'deleted_at' ], false ], + ]; + + for (const [ indexName, fields, unique ] of restoreIndexes) { + if (await indexExists(queryInterface, indexName)) { + log.push({ action: 'skip-add-index', indexName, reason: 'exists' }); + continue; + } + await queryInterface.addIndex(TABLE_NAME, fields, { name: indexName, unique }); + log.push({ action: 'add-index', indexName }); + } + + columns = await queryInterface.describeTable(TABLE_NAME); + await dropColumnIfExists(queryInterface, 'prep_at', columns, log); + + console.log('[20261115180000-refactor-wms-order-b2b] down results:', JSON.stringify(log)); + }, +}; diff --git a/methods/changes/system.json b/methods/changes/system.json index 3e82cd5..557e3a9 100644 --- a/methods/changes/system.json +++ b/methods/changes/system.json @@ -1,4 +1,180 @@ [ + { + "version": "0.3.360", + "date": "2026-11-15", + "type": "updated", + "summary": "B2B 列表支持作业明细筛选;其余订单列表统一排除 B2B 订单", + "methods": [ + "order.list", + "order.reviewOrder.list", + "order.pendingOrder.list", + "order.pendingOrder2b.list", + "order.outboundOrder.list", + "order.expectionOrder.list", + "order.entrustOrder.list", + "order.deliveryOrder.list", + "order.deliveryOrder2b.list", + "order.deliveryExpectionOrder.list", + "order.archiveOrder.list", + "order.wave.waveStrategyFallbackOrderList" + ], + "notes": [ + "B2B 列表筛选:order.pendingOrder2b.list / order.deliveryOrder2b.list 的 where 新增 8 个作业明细字段(total_box_count / pickup_plate_number / prep_remark / prep_duration_seconds / is_picked_up / picked_up_at / created_at / prep_at),内部按 warehouse_id + order_id 查 wms_order_b2b 取命中 order_id 后以 id IN (...) 回填,未命中返回空列表;该筛选仅这两个接口开放,不影响普通订单列表。", + "B2B 排除:order.list / order.reviewOrder.list / order.pendingOrder.list / order.outboundOrder.list / order.expectionOrder.list / order.entrustOrder.list / order.deliveryOrder.list / order.deliveryExpectionOrder.list / order.archiveOrder.list / order.wave.waveStrategyFallbackOrderList 在模块默认条件之上统一追加 (is_b2b IS NULL OR is_b2b = 'N'),B2B 订单不再出现在这些列表中;NULL 存量行按非 B2B 处理。", + "实现位置:app/service/systemMethods/order/base.js#listByModule(fixedWhere 含 is_b2b 时视为 B2B 域列表,不再追加排除条件)、#extractB2bDetailVirtualFilter / #findOrderIdsByB2bDetailFilters、#buildExcludeB2bCondition;app/service/systemMethods/order/wave.js#waveStrategyFallbackOrderList 单独追加排除条件。", + "不在本次口径内:order.export 走独立表位查询(getOrderModelByTableType),不经过 listByModule,导出仍按原口径取数。" + ] + }, + { + "version": "0.3.359", + "date": "2026-11-15", + "type": "updated", + "summary": "B2B 作业明细表重构:列表带出作业字段、取消改物理删除、移除冗余字段并新增 prep_at", + "methods": [ + "order.pendingOrder2b.list", + "order.deliveryOrder2b.list", + "order.convertToB2b", + "order.cancelB2b" + ], + "notes": [ + "数据库迁移 20261115180000-refactor-wms-order-b2b.js(已在开发库与生产库执行):wms_order_b2b 新增 prep_at(备货完成时间);移除 is_print / updated_at / deleted_at / delivery_order_code / store_id;唯一键 uk_order_id 改为 uk_warehouse_order(warehouse_id, order_id);迁移前先清空历史软删除行与同仓同单重复行。", + "关联口径:wms_order_b2b 与订单分表的关联读统一使用 warehouse_id + order_id(分表 id 按仓库发号,跨仓可能重叠,不能只按 order_id)。", + "列表变更:order.pendingOrder2b.list / order.deliveryOrder2b.list 的列表行新增 total_box_count、pickup_plate_number、prep_remark、prep_duration_seconds、prep_at、is_picked_up、picked_up_at、created_at 8 个作业明细字段,无明细行时输出空值占位(0 / N / null)。", + "转换变更:order.convertToB2b 写作业明细改为 (warehouse_id, order_id) 唯一键,不再写 store_id / delivery_order_code / updated_at,已存在同仓同单行时重置作业字段(含 prep_at)。", + "取消变更:order.cancelB2b 由软删除改为物理删除;随 is_print 字段移除,取消不再校验「B2B面单已打印」,skipped_reasons 枚举同步删除该原因。" + ] + }, + { + "version": "0.3.358", + "date": "2026-11-15", + "type": "updated", + "summary": "order.cancelB2b 取消「已打印不允许取消」限制,并补齐接口文档", + "methods": [ + "order.cancelB2b" + ], + "notes": [ + "变更:删除 print_status=fin 的拦截,已打印(含打印中)的订单同样允许取消 B2B,不再返回「订单已打印,不允许取消B2B」。", + "保留不变的拦截:step=0(待审核)、非 B2B(is_b2b != Y)、已锁定、已拦截、B2B 面单已打印(wms_order_b2b.is_print = Y,当前无逻辑置 Y,实际不触发)。", + "实现位置:app/service/systems/order_b2b.js#resolveCancelSkipReason;查询列 print_status 保留(不参与校验)。", + "补文档:该接口此前已实现但未登记接口文档,本次一并补齐(入参别名、响应字段、跳过原因枚举、错误码、权限口径与波次/落库行为)。", + "文档中如实标注现状差异:cancelB2b 的 step 仅排除 0(step 4/5/9 可取消)、未校验 pick_status / recheck_status,与 convertToB2b 的白名单口径不一致。" + ] + }, + { + "version": "0.3.357", + "date": "2026-11-15", + "type": "updated", + "summary": "order.convertToB2b 取消「已打印不允许转 B2B」限制", + "methods": [ + "order.convertToB2b" + ], + "notes": [ + "变更:删除 print_status=fin 的拦截,已打印(含打印中)的订单同样允许转 B2B,不再返回「订单已打印,不允许转B2B」。", + "保留不变的拦截:已取消(status=cancel)、step 白名单(仅 1/2/3)、已拣货(pick_status=fin)、已复核(recheck_status=fin)、已锁定、已拦截、已是 B2B、所在波次存在进行中的拣货任务。", + "实现位置:app/service/systems/order_b2b.js#resolveConvertSkipReason;查询列 print_status 保留(不参与校验,仅便于排查)。", + "关联提醒:order.cancelB2b 目前仍拦截「订单已打印,不允许取消B2B」,因此已打印订单转 B2B 后无法通过取消接口回退,如需对称放行需另行调整。" + ] + }, + { + "version": "0.3.356", + "date": "2026-11-15", + "type": "updated", + "summary": "order.convertToB2b 转换时自动把订单从波次摘除(含库内抓取订单),拣货任务进行中则跳过", + "methods": [ + "order.convertToB2b", + "order.wave.batchRemoveOrders" + ], + "notes": [ + "新行为:已在波次中的订单转 B2B 成功后,在同一事务内从波次摘除——订单 wave_id/wave_no/wave_scope/wave_strategy_version/wave_scan_result 清零,重排 wms_order_wave_index,回写 wms_wave_batch.total_orders / processed_orders,剩余 0 单的波次置 wave_status=-1。团购/散单抓取与库内抓取进入波次的订单一视同仁。", + "保护逻辑:波次存在进行中的拣货任务(wms_wave_pick_task.status in (0,1))时该订单不转换,skipped_reasons 返回「订单所在波次存在进行中的拣货任务,不允许转B2B」,波次 ID 通过 active_pick_task_wave_ids 返回;与 order.wave.batchRemoveOrders 的既有保护口径一致。", + "响应新增字段:removed_from_wave_order_ids / affected_wave_ids / emptied_wave_ids / active_pick_task_wave_ids;入参结构不变。", + "实现:app/service/systemMethods/order/wave.js 新增 detachOrdersFromWavesInTransaction(事务内复用),order.wave.batchRemoveOrders 同步改为复用该方法,行为与改造前等价;app/service/systems/order_b2b.js#convertOrdersToB2b 增加 wave_id/wave_no 查询列、活动拣货任务预检、摘除调用与 ORDER_WAVE_REMOVE 操作日志(提交后写入,失败不影响主流程)。", + "本次未触发波次策略快速重扫(enqueueWaveStrategyQuickScanPostOrderChange):被摘除的订单已是 B2B,策略扫描侧本身已排除 B2B,无需为其重扫。" + ] + }, + { + "version": "0.3.355", + "date": "2026-11-15", + "type": "updated", + "summary": "order.convertToB2b 增加已拣货/已复核订单拦截", + "methods": [ + "order.convertToB2b" + ], + "notes": [ + "新增准入校验:pick_status=fin(拣货已完成)返回「订单已拣货,不允许转B2B」,recheck_status=fin(复核已完成)返回「订单已复核,不允许转B2B」,避免把已进入作业流程的订单改成 B2B。", + "实现位置:app/service/systems/order_b2b.js#resolveConvertSkipReason;查询列新增 pick_status、recheck_status。校验顺序:已取消 → 步骤白名单 → 已拣货 → 已复核 → 已打印 → 已锁定 → 已拦截 → 已是 B2B。", + "拣货中(pick_status=padding)与拣货异常(pick_status=error)按本次需求不拦截,仍允许转换;如需一并拦截需另行调整。" + ] + }, + { + "version": "0.3.354", + "date": "2026-11-15", + "type": "updated", + "summary": "波次抓取类接口统一声明排除 B2B 订单,并修复自动加团链路未排除 B2B 的问题", + "methods": [ + "order.wave.fetch", + "order.wave.groupFetch", + "order.wave.singleFetch", + "order.wave.groupOrderFetchList", + "order.wave.singleOrderFetchList", + "order.wave.fetchableOrderCount", + "order.wave.waveStrategyFetchPda", + "order.wave.waveStrategyFetchAdmin", + "order.wave.waveStrategyQuickScan" + ], + "notes": [ + "代码侧核查结论:波次抓取的候选取数已全部带 (is_b2b IS NULL OR is_b2b = 'N') 条件,覆盖 buildFetchWhere(团购/散单抓取、异步 fetch 任务、自动加团新建波次)、groupOrderFetchList / singleOrderFetchList / fetchableOrderCount、策略候选 SQL(getWaveStrategyFetchCandidateOrders、selectWaveStrategyFetchOrdersBySkuLimit、第一池同结构合并)、快速扫描 where(buildWaveStrategyQuickScanOrderWhere)与 singleFetchByIds。", + "本次修复的缺口:app/service/systems/delivery_order.js 自动加团链路——appendOrderToWave 查询订单未带 is_b2b 且无 B2B 校验,导致 B2B 订单可能被自动加入已存在的\"自动加团中\"波次;countCandidateGroupOrders 候选计数未排除 B2B,导致开新团的候选数量被 B2B 订单污染。", + "修复方式:appendOrderToWave 查询属性增加 is_b2b 并在锁校验后静默跳过 is_b2b=Y 的订单;countCandidateGroupOrders 的 where 增加 is_b2b 排除条件。NULL 存量行按非 B2B 处理,不影响历史数据。", + "本轮仅补充上述 9 个抓取类接口的 B2B 排除口径说明,接口入参/响应结构未变更。" + ] + }, + { + "version": "0.3.353", + "date": "2026-11-15", + "type": "updated", + "summary": "order.convertToB2b 收紧准入:禁止转换已取消与已配送/已出库订单", + "methods": [ + "order.convertToB2b" + ], + "notes": [ + "问题:原准入只判断 step != 0,导致 step=4(配送中/已提交出库)、step=5(已完成)、step=9(已关闭,含取消单)只要未打印/未锁定/未拦截就会被转成 B2B,可能把已取消或已配送的订单误转。", + "现改为步骤白名单:仅 step in [1,2,3] 可转;0 返回「订单待审核」、4 返回「订单已提交出库」、5 返回「订单已完成」、9 返回「订单已关闭」、其它步骤返回「订单当前步骤(N)不允许转B2B」。", + "新增 status='cancel' 校验并置于校验链首位(已取消订单即使 step 仍在 [1,2,3] 也拒绝),返回「订单已取消,不允许转B2B」。", + "实现位置:app/service/systems/order_b2b.js#resolveConvertSkipReason;查询列新增 status 字段。行为上仍然只跳过不报错,跳过原因通过 skipped_reasons 返回。" + ] + }, + { + "version": "0.3.352", + "date": "2026-11-15", + "type": "added", + "summary": "补充 order.convertToB2b 接口文档(订单转 B2B)", + "methods": [ + "order.convertToB2b" + ], + "notes": [ + "该接口此前已实现(app/service/systemMethods/order/index.js#convertToB2b → app/service/systems/order_b2b.js#convertOrdersToB2b),但未登记接口文档,本次补齐。", + "入参支持 ids / order_ids / orderIds / id / order_id / orderId 六种键名,单值或数组均可,单次最多 200 个;仓库取自登录上下文,仅能转换本仓 current 分表内的订单。", + "准入条件:step != 0、print_status != 'fin'、lock_status = 'none'、intercept_status = 'none'、is_b2b != 'Y';不满足只跳过并在 skipped_reasons 返回原因,不在 current 分表中的订单进 not_found_order_ids。", + "文档中已明确 step 口径现状:只排除 step=0,step=4/5/9(含已取消单)同样可转换,且未校验 outbound_status='padding' 与 wave_id。", + "参数错误(订单ID为空 / 超过 200 个)返回 HTTP 200 但响应体 flag=failure、code=400;缺少仓库上下文抛错,HTTP 500。" + ] + }, + { + "version": "0.3.351", + "date": "2026-11-15", + "type": "added", + "summary": "新增 B2B 订单列表接口 order.pendingOrder2b.list 与 order.deliveryOrder2b.list", + "methods": [ + "order.pendingOrder2b.list", + "order.deliveryOrder2b.list" + ], + "notes": [ + "两个接口复用 order.pendingOrder.list / order.deliveryOrder.list 的全部查询条件与响应结构,仅额外强制 is_b2b='Y'。", + "固定条件通过 listByModule 的 fixedWhere 选项以 AND 方式附加,请求 where 传入同名 is_b2b 条件无法覆盖(传入 N 只会得到空列表)。", + "wms_order_delivery 各分表新增 is_b2b 列表索引:idx_{wh}_{type}_list_is_b2b_updated_at (warehouse_id, [dispatch_lane,] is_b2b, updated_at, id) 与 ..._list_is_b2b_delivery_time (warehouse_id, [dispatch_lane,] is_b2b, delivery_time, id),dispatch 分表版本携带 dispatch_lane;history / outsourced 分表不声明该索引。索引由订单工厂表结构漂移同步在部署后首次访问分表时自动补建(ALTER TABLE ADD INDEX),无需手工迁移。" + ] + }, { "version": "0.3.349", "date": "2026-11-13", diff --git a/methods/system.json b/methods/system.json index e535a5c..5352bec 100644 --- a/methods/system.json +++ b/methods/system.json @@ -1,8 +1,8 @@ { "module": "system", "description": "系统接口标准入口,method 对应系统内置方法,全部使用 POST 请求,参数统一放在 body 内", - "version": "0.3.350", - "updatedAt": "2026-11-14", + "version": "0.3.360", + "updatedAt": "2026-11-15", "headers": [ { "name": "platform", @@ -2663,7 +2663,7 @@ "list": [ { "method": "order.list", - "description": "订单工作台总列表入口,查询当前登录用户仓库上下文下的订单总列表,支持 pagination / where / sort。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号", + "description": "订单工作台总列表入口,查询当前登录用户仓库上下文下的订单总列表,支持 pagination / where / sort。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号;默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -2687,7 +2687,7 @@ "type": "object", "required": false, "source": "body", - "description": "统一 where 条件对象;推荐使用 { operator, value, type } 标准结构,历史简写会自动标准化;禁止传入 warehouse_id / warehouseId。支持虚拟字段:buyer_message_has(覆盖 buyer_message/seller_message/remark 三个字段,任一有值即为有留言,value=true/false),express_numbers / waybill_codes(运单号筛选),wave_index(波次内序号筛选,联查 wms_order_wave_index,支持 eq/in/gt/lt/ge/le/between/notbetween,between 要求 value 为长度 2 的数组,如 {\"wave_index\":{\"operator\":\"between\",\"value\":[1,50]}}),wave_scope(波次范围筛选,直接按订单表 wave_scope 字段过滤,支持单个值、数组多选或 { operator, value } 结构;取值:0=未分配波次,1=大团购,2=散单,3=小团购,4=单品单件;示例 {\"wave_scope\":{\"operator\":\"in\",\"value\":[1,3]}} 筛选大团购+小团购,{\"wave_scope\":0} 筛选未分配波次订单)。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配)。" + "description": "统一 where 条件对象;推荐使用 { operator, value, type } 标准结构,历史简写会自动标准化;禁止传入 warehouse_id / warehouseId。支持虚拟字段:buyer_message_has(覆盖 buyer_message/seller_message/remark 三个字段,任一有值即为有留言,value=true/false),express_numbers / waybill_codes(运单号筛选),wave_index(波次内序号筛选,联查 wms_order_wave_index,支持 eq/in/gt/lt/ge/le/between/notbetween,between 要求 value 为长度 2 的数组,如 {\"wave_index\":{\"operator\":\"between\",\"value\":[1,50]}}),wave_scope(波次范围筛选,直接按订单表 wave_scope 字段过滤,支持单个值、数组多选或 { operator, value } 结构;取值:0=未分配波次,1=大团购,2=散单,3=小团购,4=单品单件;示例 {\"wave_scope\":{\"operator\":\"in\",\"value\":[1,3]}} 筛选大团购+小团购,{\"wave_scope\":0} 筛选未分配波次订单)。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配);默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" }, { "name": "sort", @@ -2726,6 +2726,9 @@ "code": "500", "message": "查询失败" } + ], + "notes": [ + "B2B 排除口径:本接口在模块默认条件之上强制追加 (is_b2b IS NULL OR is_b2b = 'N'),B2B 订单不会出现在本列表中;B2B 域请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" ] }, { @@ -3551,6 +3554,200 @@ "message": "查询失败或内部错误" } ] + }, + { + "method": "order.convertToB2b", + "description": "将待处理订单批量转为 B2B 订单。仅查当前仓库 current 分表(wms_order_delivery_{warehouseId}),对命中订单逐条做准入校验:仅待处理阶段(step in [1,2,3])且未取消、未拣货、未复核、未锁定、未拦截、尚未是 B2B 的订单可转(打印状态不限制,已打印订单同样可转);已取消(status=cancel)、已提交出库/配送中(step=4)、已完成(step=5)、已关闭(step=9)、已拣货(pick_status=fin)、已复核(recheck_status=fin)的订单一律拒绝。已在波次中的订单(含库内抓取进波次的订单)转换成功后会在同一事务内从波次摘除:清空波次字段、重排 wave_index、回写波次统计(波次被清空时置 wave_status=-1);若订单所在波次存在进行中的拣货任务(wms_wave_pick_task.status in (0,1))则跳过该订单。符合条件的在同一事务内把 is_b2b 置 'Y' 并写入 wms_order_b2b 作业明细,事务提交后写操作日志(ORDER_B2B_CONVERT;波次摘除另写 ORDER_WAVE_REMOVE,失败不影响主流程)。不符合条件的订单只跳过、不报错,原因通过 skipped_reasons 返回。单次最多 200 个订单,仓库取自当前登录上下文(ctx.user.store_id),仅能转换本仓订单;撤销使用 order.cancelB2b。", + "isNeedAuth": false, + "isNeedLogin": true, + "headers": [ + { + "name": "Authorization", + "type": "string", + "required": true, + "description": "Bearer token" + } + ], + "params": [ + { + "name": "ids / order_ids / orderIds / id / order_id / orderId", + "type": "number[]", + "required": true, + "source": "body", + "description": "订单ID集合,单值或数组均可(内部统一转数组)。取值优先级:ids > order_ids > orderIds > id > order_id > orderId;仅保留正整数并去重,单次最多 200 个。" + } + ], + "response": [ + { + "name": "converted_order_ids", + "type": "number[]", + "required": true, + "description": "转换成功的订单 ID 列表(已去重)" + }, + { + "name": "converted_count", + "type": "number", + "required": true, + "description": "转换成功的订单数量" + }, + { + "name": "skipped_order_ids", + "type": "number[]", + "required": true, + "description": "命中订单但不满足准入条件被跳过的订单 ID 列表" + }, + { + "name": "skipped_count", + "type": "number", + "required": true, + "description": "被跳过的订单数量" + }, + { + "name": "skipped_reasons", + "type": "array", + "required": true, + "description": "跳过原因明细,每项 { order_id, delivery_order_code, reason };reason 取值:订单已取消,不允许转B2B / 订单待审核,不允许转B2B / 订单已提交出库,不允许转B2B / 订单已完成,不允许转B2B / 订单已关闭,不允许转B2B / 订单当前步骤(N)不允许转B2B / 订单已拣货,不允许转B2B / 订单已复核,不允许转B2B / 订单已锁定,不允许转B2B / 订单已拦截,不允许转B2B / 订单所在波次存在进行中的拣货任务,不允许转B2B / 订单已是B2B订单" + }, + { + "name": "not_found_order_ids", + "type": "number[]", + "required": true, + "description": "当前仓库 current 分表中查不到的订单 ID(已进配送/历史/外仓表,或不属于本仓,或 ID 不存在)" + }, + { + "name": "removed_from_wave_order_ids", + "type": "number[]", + "required": true, + "description": "转换成功后从波次中摘除的订单 ID 列表(订单原本不在波次中时为空数组)" + }, + { + "name": "affected_wave_ids", + "type": "number[]", + "required": true, + "description": "因本次摘除而受影响的波次 ID 列表" + }, + { + "name": "emptied_wave_ids", + "type": "number[]", + "required": true, + "description": "摘除后已无剩余订单、被置为 wave_status=-1(作废)的波次 ID 列表" + }, + { + "name": "active_pick_task_wave_ids", + "type": "number[]", + "required": true, + "description": "因存在进行中的拣货任务而跳过转换的波次 ID 列表(对应订单见 skipped_reasons)" + } + ], + "errors": [ + { + "code": "400", + "message": "订单ID不能为空(HTTP 仍为 200,响应体 flag=failure、code=400)" + }, + { + "code": "400", + "message": "单次最多转换 200 个订单(HTTP 仍为 200,响应体 flag=failure、code=400)" + }, + { + "code": "500", + "message": "未识别到当前仓库上下文,HTTP 500,message 为「接口错误: 未识别到当前仓库上下文」" + } + ], + "notes": [ + "准入条件(需同时满足):① 订单存在于当前仓库 current 分表;② status != 'cancel'(未取消);③ step in [1,2,3](待处理阶段);④ pick_status != 'fin'(未拣货);⑤ recheck_status != 'fin'(未复核);⑥ lock_status = 'none'(未锁定,空值视为 none);⑦ intercept_status = 'none'(未拦截,空值视为 none);⑧ is_b2b != 'Y'(尚未是 B2B 订单)。订单是否已在波次中(wave_id > 0)不构成拒绝条件,会在转换成功后自动摘除。", + "打印状态不限制:print_status 为 none / padding / fin 均不影响转换,已打印(fin)的订单同样允许转 B2B;打印与否由前端按业务决定,接口不做拦截。", + "步骤口径:step 采用白名单校验,仅 1 已审核 / 2 处理中 / 3 驳回异常可转;0 待审核、4 配送中(含已提交出库,提交出库时 outbound_status=padding 与 step=4 同时写入)、5 已完成、9 已关闭一律拒绝,其它未知步骤返回「订单当前步骤(N)不允许转B2B」。取消原因优先于步骤及其它校验(已取消订单即使 step 仍在 [1,2,3] 也拒绝)。", + "作业进度口径:pick_status=fin(拣货已完成)与 recheck_status=fin(复核已完成)均拒绝转换,避免把已分拣/已核对的订单改成 B2B;拣货中(pick_status=padding)与拣货异常(pick_status=error)目前不拦截,仅拦截已完成拣货。", + "波次联动口径:已在波次中的订单(无论由团购/散单抓取还是库内抓取进入波次)转换成功后,在同一事务内执行摘除——订单 wave_id / wave_no / wave_scope / wave_strategy_version / wave_scan_result 清零,按波次重排 wms_order_wave_index(wave_index 重新连续编号),wms_wave_batch.total_orders 回写为剩余单数且 processed_orders 取不超过剩余值,剩余 0 单的波次置 wave_status=-1(作废)。", + "拣货任务保护:若订单所在波次存在进行中的拣货任务(wms_wave_pick_task.status in (0,1)),该订单不转换、不摘除,返回原因「订单所在波次存在进行中的拣货任务,不允许转B2B」,涉及波次在 active_pick_task_wave_ids 返回;请走任务取消接口处理后再转。", + "落库行为:订单行 is_b2b 置 'Y'(同时刷新 updated_at);wms_order_b2b 以 (warehouse_id, order_id) 唯一键写入作业明细行,若已存在同仓同单行则重置作业字段(total_box_count=0、pickup_plate_number=null、prep_remark=null、prep_duration_seconds=0、prep_at=null、is_picked_up='N'、picked_up_at=null),created_at 保留首次创建时间。作业明细不再软删除(updated_at / deleted_at / is_print / store_id / delivery_order_code 字段已移除),取消 B2B 时物理删除该行。", + "权限口径:该接口当前在 app/service/systemMethods/order/index.js 的 _noNeedRight / _noNeedLog / _noNeedAuth 名单内,即免接口权限校验、免接口访问日志、免仓库有效期校验,仅需登录。", + "配套接口:order.cancelB2b(取消 B2B 出库,订单流转回正常订单);查询侧使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" + ] + }, + { + "method": "order.cancelB2b", + "description": "取消 B2B 出库,把 B2B 订单流转回正常订单。仅查当前仓库 current 分表(wms_order_delivery_{warehouseId}),对命中订单逐条做准入校验:is_b2b=Y、step != 0(非待审核)、未锁定、未拦截的订单可取消;打印状态不限制,已打印订单同样允许取消。事务内把 is_b2b 置回 'N' 并按 warehouse_id + order_id 物理删除 wms_order_b2b 作业明细(不保留历史),提交后写操作日志(ORDER_B2B_CANCEL,失败不影响主流程)。不符合条件的订单只跳过、不报错,原因通过 skipped_reasons 返回。单次最多 200 个订单,仓库取自当前登录上下文(ctx.user.store_id),仅能取消本仓订单;反向操作为 order.convertToB2b。", + "isNeedAuth": false, + "isNeedLogin": true, + "headers": [ + { + "name": "Authorization", + "type": "string", + "required": true, + "description": "Bearer token" + } + ], + "params": [ + { + "name": "ids / order_ids / orderIds / id / order_id / orderId", + "type": "number[]", + "required": true, + "source": "body", + "description": "订单ID集合,单值或数组均可(内部统一转数组)。取值优先级:ids > order_ids > orderIds > id > order_id > orderId;仅保留正整数并去重,单次最多 200 个。" + } + ], + "response": [ + { + "name": "canceled_order_ids", + "type": "number[]", + "required": true, + "description": "取消成功的订单 ID 列表(已去重)" + }, + { + "name": "canceled_count", + "type": "number", + "required": true, + "description": "取消成功的订单数量" + }, + { + "name": "skipped_order_ids", + "type": "number[]", + "required": true, + "description": "命中订单但不满足取消条件被跳过的订单 ID 列表" + }, + { + "name": "skipped_count", + "type": "number", + "required": true, + "description": "被跳过的订单数量" + }, + { + "name": "skipped_reasons", + "type": "array", + "required": true, + "description": "跳过原因明细,每项 { order_id, delivery_order_code, reason };reason 取值:订单待审核,不允许取消B2B / 订单不是B2B订单 / 订单已锁定,不允许取消B2B / 订单已拦截,不允许取消B2B" + }, + { + "name": "not_found_order_ids", + "type": "number[]", + "required": true, + "description": "当前仓库 current 分表中查不到的订单 ID(已进配送/历史/外仓表,或不属于本仓,或 ID 不存在)" + } + ], + "errors": [ + { + "code": "400", + "message": "订单ID不能为空(HTTP 仍为 200,响应体 flag=failure、code=400)" + }, + { + "code": "400", + "message": "单次最多取消 200 个订单(HTTP 仍为 200,响应体 flag=failure、code=400)" + }, + { + "code": "500", + "message": "未识别到当前仓库上下文,HTTP 500,message 为「接口错误: 未识别到当前仓库上下文」" + } + ], + "notes": [ + "准入条件(需同时满足):① 订单存在于当前仓库 current 分表;② is_b2b = 'Y'(是 B2B 订单);③ step != 0(非待审核);④ lock_status = 'none'(未锁定,空值视为 none);⑤ intercept_status = 'none'(未拦截,空值视为 none)。", + "打印状态不限制:print_status 为 none / padding / fin 均不影响取消,已打印(fin)的订单同样允许取消。", + "作业明细处理:取消成功后按 warehouse_id + order_id 物理删除 wms_order_b2b 对应行(DELETE,不保留历史、不做软删除);该表已移除 updated_at / deleted_at / is_print / store_id / delivery_order_code 字段。", + "步骤口径现状:当前仅排除 step=0,step=4(配送中/已提交出库)、5(已完成)、9(已关闭,含取消单)仍可取消;也未校验 pick_status / recheck_status。与 order.convertToB2b 的 step 白名单(仅 1/2/3)口径不一致,如需对齐需另行调整。", + "落库行为:订单行 is_b2b 置回 'N'(同时刷新 updated_at)。转 B2B 时订单已从波次摘除,取消后订单直接回到待处理池,不会回到原波次。", + "权限口径:该接口当前在 app/service/systemMethods/order/index.js 的 _noNeedRight / _noNeedLog / _noNeedAuth 名单内,即免接口权限校验、免接口访问日志、免仓库有效期校验,仅需登录。", + "配套接口:order.convertToB2b(订单转 B2B);查询侧使用 order.pendingOrder2b.list / order.deliveryOrder2b.list(列表行带出作业明细字段)。" + ] } ] }, @@ -3560,7 +3757,7 @@ "list": [ { "method": "order.reviewOrder.list", - "description": "待审核订单列表,默认仅查询 step=0 的订单。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号", + "description": "待审核订单列表,默认仅查询 step=0 的订单。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号;默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -3584,7 +3781,7 @@ "type": "object", "required": false, "source": "body", - "description": "统一 where 条件对象;禁止传入 warehouse_id / warehouseId。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配)。" + "description": "统一 where 条件对象;禁止传入 warehouse_id / warehouseId。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配);默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" }, { "name": "sort", @@ -3623,6 +3820,9 @@ "code": "500", "message": "查询失败" } + ], + "notes": [ + "B2B 排除口径:本接口在模块默认条件之上强制追加 (is_b2b IS NULL OR is_b2b = 'N'),B2B 订单不会出现在本列表中;B2B 域请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" ] }, { @@ -3851,7 +4051,7 @@ "list": [ { "method": "order.pendingOrder.list", - "description": "待处理订单列表,默认筛选 outbound_status != padding 且 step in [1,2,3]。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号", + "description": "待处理订单列表,默认筛选 outbound_status != padding 且 step in [1,2,3]。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号;默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -3875,7 +4075,7 @@ "type": "object", "required": false, "source": "body", - "description": "统一 where 条件对象;禁止传入 warehouse_id / warehouseId。where 无字段白名单,可直接传订单表列名。lock_status 锁定状态筛选(筛选值用数据库原始枚举 none/warehouse/store,不是响应中的 Y/N;ne 表示不等于;条件值为空自动忽略):未锁定 {\"lock_status\":\"none\"};已锁定(所有非 none){\"lock_status\":{\"operator\":\"ne\",\"value\":\"none\"}}。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。confirm_print_status(确认打印状态筛选,按订单表列过滤;枚举:none=未确认打印、fin=已确认打印)。支持简写与标准结构(同 create_channel 示例),如 {\"confirm_print_status\":\"fin\"} 只查已确认打印订单。claim_status(领料状态筛选,按订单表列过滤;枚举:none=未领料、padding=领料中、fin=已领料、error=异常)。支持简写与标准结构(同 create_channel 示例),如 {\"claim_status\":{\"operator\":\"ne\",\"value\":\"fin\"}} 查未完成领料的订单。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配)。" + "description": "统一 where 条件对象;禁止传入 warehouse_id / warehouseId。where 无字段白名单,可直接传订单表列名。lock_status 锁定状态筛选(筛选值用数据库原始枚举 none/warehouse/store,不是响应中的 Y/N;ne 表示不等于;条件值为空自动忽略):未锁定 {\"lock_status\":\"none\"};已锁定(所有非 none){\"lock_status\":{\"operator\":\"ne\",\"value\":\"none\"}}。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。confirm_print_status(确认打印状态筛选,按订单表列过滤;枚举:none=未确认打印、fin=已确认打印)。支持简写与标准结构(同 create_channel 示例),如 {\"confirm_print_status\":\"fin\"} 只查已确认打印订单。claim_status(领料状态筛选,按订单表列过滤;枚举:none=未领料、padding=领料中、fin=已领料、error=异常)。支持简写与标准结构(同 create_channel 示例),如 {\"claim_status\":{\"operator\":\"ne\",\"value\":\"fin\"}} 查未完成领料的订单。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配);默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" }, { "name": "sort", @@ -3914,6 +4114,9 @@ "code": "500", "message": "查询失败" } + ], + "notes": [ + "B2B 排除口径:本接口在模块默认条件之上强制追加 (is_b2b IS NULL OR is_b2b = 'N'),B2B 订单不会出现在本列表中;B2B 域请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" ] }, { @@ -6498,6 +6701,119 @@ "message": "task_id 参数不能为空" } ] + }, + { + "method": "order.pendingOrder2b.list", + "description": "B2B 待处理订单列表。查询条件与 order.pendingOrder.list 完全一致(current 分表 + 模块默认 where:outbound_status != padding 且 step in [1,2,3]),额外强制 is_b2b='Y'。固定条件与请求 where 取 AND,请求传入同名 is_b2b 条件无法覆盖。;列表行额外带出 wms_order_b2b 作业明细字段:total_box_count(总箱数)、pickup_plate_number(提货车牌)、prep_remark(备货备注)、prep_duration_seconds(备货用时/秒)、prep_at(备货完成时间)、is_picked_up(是否提货 Y/N)、picked_up_at(提货时间)、created_at(作业明细创建时间,与订单自身的 create_at 不同)。关联条件固定为 warehouse_id + order_id;无作业明细行时上述字段输出空值占位(数值 0、is_picked_up=N、时间为 null);另支持按 wms_order_b2b 作业明细字段筛选(仅本接口开放,普通订单列表不识别这些字段):total_box_count(总箱数)、pickup_plate_number(提货车牌)、prep_remark(备货备注)、prep_duration_seconds(备货用时/秒)、is_picked_up(Y/N)、picked_up_at(提货时间)、created_at(作业明细创建时间)、prep_at(备货完成时间)。支持简写与标准结构,如 {\"is_picked_up\":\"Y\"}、{\"pickup_plate_number\":{\"operator\":\"like\",\"value\":\"粤A\"}}、{\"prep_at\":{\"operator\":\"between\",\"value\":[\"2026-11-01 00:00:00\",\"2026-11-30 23:59:59\"]}};内部先按 warehouse_id + order_id 查 wms_order_b2b 取命中 order_id,再回填订单列表条件,未命中返回空列表。", + "isNeedAuth": false, + "isNeedLogin": true, + "headers": [ + { + "name": "Authorization", + "type": "string", + "required": true, + "description": "Bearer token" + } + ], + "params": [ + { + "name": "pagination", + "type": "object", + "required": false, + "source": "body", + "description": "分页参数,支持 page / pageSize" + }, + { + "name": "where", + "type": "object", + "required": false, + "source": "body", + "description": "统一 where 条件对象,语义与 order.pendingOrder.list 完全一致(禁止传入 warehouse_id / warehouseId)。另强制附加 is_b2b='Y':即使传入 {\"is_b2b\":\"N\"} 也只会得到空列表(固定条件与请求条件取 AND);另支持按 wms_order_b2b 作业明细字段筛选(仅本接口开放,普通订单列表不识别这些字段):total_box_count(总箱数)、pickup_plate_number(提货车牌)、prep_remark(备货备注)、prep_duration_seconds(备货用时/秒)、is_picked_up(Y/N)、picked_up_at(提货时间)、created_at(作业明细创建时间)、prep_at(备货完成时间)。支持简写与标准结构,如 {\"is_picked_up\":\"Y\"}、{\"pickup_plate_number\":{\"operator\":\"like\",\"value\":\"粤A\"}}、{\"prep_at\":{\"operator\":\"between\",\"value\":[\"2026-11-01 00:00:00\",\"2026-11-30 23:59:59\"]}};内部先按 warehouse_id + order_id 查 wms_order_b2b 取命中 order_id,再回填订单列表条件,未命中返回空列表。" + }, + { + "name": "sort", + "type": "object", + "required": false, + "source": "body", + "description": "排序参数,支持 sortField / sortOrder;默认 updated_at DESC, id DESC" + } + ], + "response": [ + { + "name": "list", + "type": "array", + "required": true, + "description": "B2B 订单列表(raw 行数据,字段与 order.pendingOrder.list 一致)" + }, + { + "name": "pagination", + "type": "object", + "required": true, + "description": "分页信息" + }, + { + "name": "total_box_count", + "type": "number", + "required": true, + "description": "总箱数(wms_order_b2b.total_box_count,无作业明细行时为 0)" + }, + { + "name": "pickup_plate_number", + "type": "string", + "required": false, + "description": "提货车牌(wms_order_b2b.pickup_plate_number)" + }, + { + "name": "prep_remark", + "type": "string", + "required": false, + "description": "备货备注(wms_order_b2b.prep_remark)" + }, + { + "name": "prep_duration_seconds", + "type": "number", + "required": true, + "description": "备货用时,单位秒(wms_order_b2b.prep_duration_seconds,无作业明细行时为 0)" + }, + { + "name": "prep_at", + "type": "string", + "required": false, + "description": "备货完成时间(wms_order_b2b.prep_at)" + }, + { + "name": "is_picked_up", + "type": "string", + "required": true, + "description": "是否提货:Y=已提货 N=未提货(无作业明细行时为 N)" + }, + { + "name": "picked_up_at", + "type": "string", + "required": false, + "description": "提货时间(wms_order_b2b.picked_up_at)" + }, + { + "name": "created_at", + "type": "string", + "required": false, + "description": "B2B 作业明细创建时间(wms_order_b2b.created_at),与订单自身的 create_at 不同;无作业明细行时为 null" + } + ], + "errors": [ + { + "code": "400", + "message": "参数格式错误或缺少仓库上下文" + }, + { + "code": "500", + "message": "查询失败" + } + ], + "notes": [ + "B2B 作业明细输出口径:列表行按 warehouse_id + order_id 关联 wms_order_b2b 取数(分表 id 按仓库发号,不能只按 order_id 关联);副表已移除 store_id / delivery_order_code / is_print / updated_at / deleted_at 字段,取消 B2B 时物理删除明细行,故列表中的 created_at 为作业明细创建时间,无明细行时为空值占位。", + "B2B 作业明细筛选口径:仅在 order.pendingOrder2b.list / order.deliveryOrder2b.list 开放 total_box_count / pickup_plate_number / prep_remark / prep_duration_seconds / is_picked_up / picked_up_at / created_at / prep_at 作为 where 条件;内部转成 wms_order_b2b(warehouse_id + order_id)子查询取 order_id,再以 id IN (...) 回填,未命中返回空列表,不影响其他订单列表口径。" + ] } ] }, @@ -9152,7 +9468,7 @@ }, { "method": "order.wave.waveStrategyQuickScan", - "description": "提交波次策略快速扫描异步任务。无外部参数,使用当前仓库上下文;同一仓库同一时刻仅允许一个任务运行,若已有运行任务直接返回已有 task_id。", + "description": "提交波次策略快速扫描异步任务。无外部参数,使用当前仓库上下文;同一仓库同一时刻仅允许一个任务运行,若已有运行任务直接返回已有 task_id;B2B 订单(is_b2b=Y)全程不参与波次抓取:候选查询、可抓取数量统计与建波均排除,请求传入 B2B 订单 ID 也不会被抓入波次(NULL 存量行视为非 B2B)。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -9205,17 +9521,22 @@ "errors": [ { "code": "400", - "description": "未识别到当前仓库上下文" + "description": "未识别到当前仓库上下文", + "message": "未识别到当前仓库上下文" }, { "code": "500", - "description": "任务提交失败或内部错误" + "description": "任务提交失败或内部错误", + "message": "任务提交失败或内部错误" } + ], + "notes": [ + "B2B 抓取排除口径:所有波次抓取链路(团购/散单抓取、按策略抓取、快速扫描匹配、自动加团)的候选取数均带 (is_b2b IS NULL OR is_b2b = 'N') 条件,B2B 订单不会被选入波次;已进波次的 B2B 订单也不会因转 B2B 而被移出,需要时用 order.wave.batchRemoveOrders 移出。" ] }, { "method": "order.wave.waveStrategyFetchPda", - "description": "按策略提交并创建抓取主流程任务(PDA)。当前为最小主流程:进行入参校验并创建任务记录,返回创建结果与计划预览;后续扫描/执行阶段将扩展为完整执行流。 注意:当存在未完成任务时,接口返回 fetch_state=3 且同时返回 existing task_id/task_no,前端可直接进入拣货流程。 小团购跨池同结构合并规则:候选订单按创建时间分割为第一池(今日 0 点前)与第二池(今日订单),只有第一池抓取完毕才抓取第二池;小团购(pickMode=1)第一池抓取时,按第一池候选分组出现过的结构 key(require_same_express=1 时为「结构+快递」组合)将同结构全池订单(不限策略匹配、不含池边界)并入候选,随后复用既有分组建波流程,修复同结构订单被两池分割后单独成波(1 单 1 波次)的问题。合并触发条件:小团购 pickMode=1、第一池非空(candidate_pool_stage=first)、策略 max_same_structure 为正整数且≠999;max_same_structure 为 null/999 的团购策略跳过合并维持现状,大团购 pickMode=5 与后台抓取入口(order.wave.waveStrategyFetchAdmin)不覆盖;同结构全池查询无新增订单时亦不合并。 SN 策略(strategy_type=3)忽略同结构最小/最大数量限制(min_same_structure/max_same_structure):SN 订单只能由 SN 策略抓取,若按散单同结构区间过滤会永远抓不到单件/少量 SN 订单;其余仍按订单池(wave_id=0、step!=0、快递/储位已分配、未打印、未拦截、未锁定)与 batch_max_skus/batch_max_orders 切片。", + "description": "按策略提交并创建抓取主流程任务(PDA)。当前为最小主流程:进行入参校验并创建任务记录,返回创建结果与计划预览;后续扫描/执行阶段将扩展为完整执行流。 注意:当存在未完成任务时,接口返回 fetch_state=3 且同时返回 existing task_id/task_no,前端可直接进入拣货流程。 小团购跨池同结构合并规则:候选订单按创建时间分割为第一池(今日 0 点前)与第二池(今日订单),只有第一池抓取完毕才抓取第二池;小团购(pickMode=1)第一池抓取时,按第一池候选分组出现过的结构 key(require_same_express=1 时为「结构+快递」组合)将同结构全池订单(不限策略匹配、不含池边界)并入候选,随后复用既有分组建波流程,修复同结构订单被两池分割后单独成波(1 单 1 波次)的问题。合并触发条件:小团购 pickMode=1、第一池非空(candidate_pool_stage=first)、策略 max_same_structure 为正整数且≠999;max_same_structure 为 null/999 的团购策略跳过合并维持现状,大团购 pickMode=5 与后台抓取入口(order.wave.waveStrategyFetchAdmin)不覆盖;同结构全池查询无新增订单时亦不合并。 SN 策略(strategy_type=3)忽略同结构最小/最大数量限制(min_same_structure/max_same_structure):SN 订单只能由 SN 策略抓取,若按散单同结构区间过滤会永远抓不到单件/少量 SN 订单;其余仍按订单池(wave_id=0、step!=0、快递/储位已分配、未打印、未拦截、未锁定)与 batch_max_skus/batch_max_orders 切片;B2B 订单(is_b2b=Y)全程不参与波次抓取:候选查询、可抓取数量统计与建波均排除,请求传入 B2B 订单 ID 也不会被抓入波次(NULL 存量行视为非 B2B)。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -9371,11 +9692,14 @@ "code": "500", "message": "创建任务失败或内部错误,message 字段含简短说明" } + ], + "notes": [ + "B2B 抓取排除口径:所有波次抓取链路(团购/散单抓取、按策略抓取、快速扫描匹配、自动加团)的候选取数均带 (is_b2b IS NULL OR is_b2b = 'N') 条件,B2B 订单不会被选入波次;已进波次的 B2B 订单也不会因转 B2B 而被移出,需要时用 order.wave.batchRemoveOrders 移出。" ] }, { "method": "order.wave.waveStrategyFetchAdmin", - "description": "按策略提交并创建抓取主流程任务(后台管理)。当前为最小主流程:执行入参校验并创建任务记录,返回创建结果与计划预览;后续将扩展完整扫描/执行链路。 注意:当存在未完成任务时,接口返回 fetch_state=3 且同时返回 existing task_id/task_no,前端可直接进入拣货流程。 SN 策略(strategy_type=3)忽略同结构最小/最大数量限制(min_same_structure/max_same_structure):SN 订单只能由 SN 策略抓取,若按散单同结构区间过滤会永远抓不到单件/少量 SN 订单;其余仍按订单池(wave_id=0、step!=0、快递/储位已分配、未打印、未拦截、未锁定)与 batch_max_skus/batch_max_orders 切片。", + "description": "按策略提交并创建抓取主流程任务(后台管理)。当前为最小主流程:执行入参校验并创建任务记录,返回创建结果与计划预览;后续将扩展完整扫描/执行链路。 注意:当存在未完成任务时,接口返回 fetch_state=3 且同时返回 existing task_id/task_no,前端可直接进入拣货流程。 SN 策略(strategy_type=3)忽略同结构最小/最大数量限制(min_same_structure/max_same_structure):SN 订单只能由 SN 策略抓取,若按散单同结构区间过滤会永远抓不到单件/少量 SN 订单;其余仍按订单池(wave_id=0、step!=0、快递/储位已分配、未打印、未拦截、未锁定)与 batch_max_skus/batch_max_orders 切片;B2B 订单(is_b2b=Y)全程不参与波次抓取:候选查询、可抓取数量统计与建波均排除,请求传入 B2B 订单 ID 也不会被抓入波次(NULL 存量行视为非 B2B)。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -9528,6 +9852,9 @@ "description": "创建任务失败或内部错误,message 字段含简短说明", "message": "请求失败" } + ], + "notes": [ + "B2B 抓取排除口径:所有波次抓取链路(团购/散单抓取、按策略抓取、快速扫描匹配、自动加团)的候选取数均带 (is_b2b IS NULL OR is_b2b = 'N') 条件,B2B 订单不会被选入波次;已进波次的 B2B 订单也不会因转 B2B 而被移出,需要时用 order.wave.batchRemoveOrders 移出。" ] }, { @@ -9651,7 +9978,7 @@ }, { "method": "order.wave.groupOrderFetchList", - "description": "按机器结构分组的可抓取列表。仅处理待处理订单(排除待审核),且排除已在波次中的订单。;已排除 SN(序列号管理)订单(has_sn_item='Y'),SN 订单不参与团购抓取。", + "description": "按机器结构分组的可抓取列表。仅处理待处理订单(排除待审核),且排除已在波次中的订单。;已排除 SN(序列号管理)订单(has_sn_item='Y'),SN 订单不参与团购抓取;B2B 订单(is_b2b=Y)全程不参与波次抓取:候选查询、可抓取数量统计与建波均排除,请求传入 B2B 订单 ID 也不会被抓入波次(NULL 存量行视为非 B2B)。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -9736,6 +10063,9 @@ "code": "500", "message": "查询失败" } + ], + "notes": [ + "B2B 抓取排除口径:所有波次抓取链路(团购/散单抓取、按策略抓取、快速扫描匹配、自动加团)的候选取数均带 (is_b2b IS NULL OR is_b2b = 'N') 条件,B2B 订单不会被选入波次;已进波次的 B2B 订单也不会因转 B2B 而被移出,需要时用 order.wave.batchRemoveOrders 移出。" ] }, { @@ -9835,7 +10165,7 @@ }, { "method": "order.wave.waveStrategyFallbackOrderList", - "description": "基于波次策略的回退候选订单列表。该接口内置固定筛选条件:step != 0、wave_id = 0,且满足以下任一条件:wave_scan_result = 2(未匹配任何波次策略)、print_status = 'fin'(已完全打印)、lock_status != 'none'(订单已锁定)、intercept_status != 'none'(订单已拦截)。用于展示策略未命中或需回退处理的订单候选。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号", + "description": "基于波次策略的回退候选订单列表。该接口内置固定筛选条件:step != 0、wave_id = 0,且满足以下任一条件:wave_scan_result = 2(未匹配任何波次策略)、print_status = 'fin'(已完全打印)、lock_status != 'none'(订单已锁定)、intercept_status != 'none'(订单已拦截)。用于展示策略未命中或需回退处理的订单候选。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号;默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -9859,7 +10189,7 @@ "type": "object", "required": false, "source": "body", - "description": "筛选白名单字段(object)。仅支持下列字段,且禁止传入 warehouse_id / warehouseId:\n- id(等值)\n- delivery_no / deliveryNo(模糊)\n- tracking_no / trackingNo(模糊)\n- items_count_min / items_count_max(范围)\n- items_total_min / items_total_max(范围)\n- sys_logistics_name(模糊)\n- store_name(模糊)\n- owner_name(等值)\n- province(模糊)\n- sys_platform_name(模糊)\n- buyer_message_has(虚拟字段,覆盖 buyer_message/seller_message/remark 三个字段,任一有值即为有留言,value=true/false)\n说明:若传入未列出的字段或禁止字段(如 warehouse_id)接口会返回 400。" + "description": "筛选白名单字段(object)。仅支持下列字段,且禁止传入 warehouse_id / warehouseId:\n- id(等值)\n- delivery_no / deliveryNo(模糊)\n- tracking_no / trackingNo(模糊)\n- items_count_min / items_count_max(范围)\n- items_total_min / items_total_max(范围)\n- sys_logistics_name(模糊)\n- store_name(模糊)\n- owner_name(等值)\n- province(模糊)\n- sys_platform_name(模糊)\n- buyer_message_has(虚拟字段,覆盖 buyer_message/seller_message/remark 三个字段,任一有值即为有留言,value=true/false)\n说明:若传入未列出的字段或禁止字段(如 warehouse_id)接口会返回 400;默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" } ], "response": [ @@ -9957,11 +10287,14 @@ "code": "500", "message": "查询失败或内部错误" } + ], + "notes": [ + "B2B 排除口径:本接口在模块默认条件之上强制追加 (is_b2b IS NULL OR is_b2b = 'N'),B2B 订单不会出现在本列表中;B2B 域请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" ] }, { "method": "order.wave.singleOrderFetchList", - "description": "按机器结构分组的散单候选列表。仅处理待处理订单(排除待审核),且排除已在波次中的订单。与 order.wave.groupOrderFetchList 不同:groupOrderFetchList 返回满足同组订单数量 >= same_order_quantity(或仓库配置 min_group_order_fetch_quantity)的团购命中分组;singleOrderFetchList 则排除这些团购命中分组,仅返回同组订单数量小于该阈值的散单候选分组(即 < same_order_quantity)。;已排除 SN(序列号管理)订单(has_sn_item='Y'),SN 订单不参与散单抓取。", + "description": "按机器结构分组的散单候选列表。仅处理待处理订单(排除待审核),且排除已在波次中的订单。与 order.wave.groupOrderFetchList 不同:groupOrderFetchList 返回满足同组订单数量 >= same_order_quantity(或仓库配置 min_group_order_fetch_quantity)的团购命中分组;singleOrderFetchList 则排除这些团购命中分组,仅返回同组订单数量小于该阈值的散单候选分组(即 < same_order_quantity)。;已排除 SN(序列号管理)订单(has_sn_item='Y'),SN 订单不参与散单抓取;B2B 订单(is_b2b=Y)全程不参与波次抓取:候选查询、可抓取数量统计与建波均排除,请求传入 B2B 订单 ID 也不会被抓入波次(NULL 存量行视为非 B2B)。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -10046,6 +10379,9 @@ "code": "500", "message": "查询失败" } + ], + "notes": [ + "B2B 抓取排除口径:所有波次抓取链路(团购/散单抓取、按策略抓取、快速扫描匹配、自动加团)的候选取数均带 (is_b2b IS NULL OR is_b2b = 'N') 条件,B2B 订单不会被选入波次;已进波次的 B2B 订单也不会因转 B2B 而被移出,需要时用 order.wave.batchRemoveOrders 移出。" ] }, { @@ -11304,7 +11640,7 @@ }, { "method": "order.wave.groupFetch", - "description": "抓取团购接口(异步任务提交);团购抓取会排除 SN(序列号管理)订单。", + "description": "抓取团购接口(异步任务提交);团购抓取会排除 SN(序列号管理)订单;B2B 订单(is_b2b=Y)全程不参与波次抓取:候选查询、可抓取数量统计与建波均排除,请求传入 B2B 订单 ID 也不会被抓入波次(NULL 存量行视为非 B2B)。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -11371,11 +11707,14 @@ "code": 500, "message": "任务提交失败或内部错误" } + ], + "notes": [ + "B2B 抓取排除口径:所有波次抓取链路(团购/散单抓取、按策略抓取、快速扫描匹配、自动加团)的候选取数均带 (is_b2b IS NULL OR is_b2b = 'N') 条件,B2B 订单不会被选入波次;已进波次的 B2B 订单也不会因转 B2B 而被移出,需要时用 order.wave.batchRemoveOrders 移出。" ] }, { "method": "order.wave.singleFetch", - "description": "抓取散单接口(异步任务提交);散单抓取同样排除 SN(序列号管理)订单。", + "description": "抓取散单接口(异步任务提交);散单抓取同样排除 SN(序列号管理)订单;B2B 订单(is_b2b=Y)全程不参与波次抓取:候选查询、可抓取数量统计与建波均排除,请求传入 B2B 订单 ID 也不会被抓入波次(NULL 存量行视为非 B2B)。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -11448,11 +11787,14 @@ "code": 500, "message": "任务提交失败或内部错误" } + ], + "notes": [ + "B2B 抓取排除口径:所有波次抓取链路(团购/散单抓取、按策略抓取、快速扫描匹配、自动加团)的候选取数均带 (is_b2b IS NULL OR is_b2b = 'N') 条件,B2B 订单不会被选入波次;已进波次的 B2B 订单也不会因转 B2B 而被移出,需要时用 order.wave.batchRemoveOrders 移出。" ] }, { "method": "order.wave.fetch", - "description": "兼容别名(等同 groupFetch)", + "description": "兼容别名(等同 groupFetch);B2B 订单(is_b2b=Y)全程不参与波次抓取:候选查询、可抓取数量统计与建波均排除,请求传入 B2B 订单 ID 也不会被抓入波次(NULL 存量行视为非 B2B)。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -11519,6 +11861,9 @@ "code": 500, "message": "任务提交失败或内部错误" } + ], + "notes": [ + "B2B 抓取排除口径:所有波次抓取链路(团购/散单抓取、按策略抓取、快速扫描匹配、自动加团)的候选取数均带 (is_b2b IS NULL OR is_b2b = 'N') 条件,B2B 订单不会被选入波次;已进波次的 B2B 订单也不会因转 B2B 而被移出,需要时用 order.wave.batchRemoveOrders 移出。" ] }, { @@ -11859,7 +12204,7 @@ }, { "method": "order.wave.fetchableOrderCount", - "description": "统计当前仓库团购可抓取订单数。口径与 order.wave.groupOrderFetchList 完全一致(同一候选条件 + items_hash 粗分组 + 团购阈值过滤),但不分页、不查订单明细,仅返回达到团购阈值分组的数量与组内订单数合计。注意与 groupOrderFetchList 的口径差异:其 pagination.total 是分组数,本方法 order_count 是命中分组的订单数合计。;统计口径同样排除 SN(序列号管理)订单。", + "description": "统计当前仓库团购可抓取订单数。口径与 order.wave.groupOrderFetchList 完全一致(同一候选条件 + items_hash 粗分组 + 团购阈值过滤),但不分页、不查订单明细,仅返回达到团购阈值分组的数量与组内订单数合计。注意与 groupOrderFetchList 的口径差异:其 pagination.total 是分组数,本方法 order_count 是命中分组的订单数合计。;统计口径同样排除 SN(序列号管理)订单;B2B 订单(is_b2b=Y)全程不参与波次抓取:候选查询、可抓取数量统计与建波均排除,请求传入 B2B 订单 ID 也不会被抓入波次(NULL 存量行视为非 B2B)。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -11958,6 +12303,9 @@ "code": "500", "message": "查询失败" } + ], + "notes": [ + "B2B 抓取排除口径:所有波次抓取链路(团购/散单抓取、按策略抓取、快速扫描匹配、自动加团)的候选取数均带 (is_b2b IS NULL OR is_b2b = 'N') 条件,B2B 订单不会被选入波次;已进波次的 B2B 订单也不会因转 B2B 而被移出,需要时用 order.wave.batchRemoveOrders 移出。" ] } ] @@ -11968,7 +12316,7 @@ "list": [ { "method": "order.outboundOrder.list", - "description": "待出库订单列表,默认筛选 outbound_status in [fin,padding] 且 step in [4,9]。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号", + "description": "待出库订单列表,默认筛选 outbound_status in [fin,padding] 且 step in [4,9]。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号;默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -11992,7 +12340,7 @@ "type": "object", "required": false, "source": "body", - "description": "统一 where 条件对象;禁止传入 warehouse_id / warehouseId。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配)。" + "description": "统一 where 条件对象;禁止传入 warehouse_id / warehouseId。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配);默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" }, { "name": "sort", @@ -12031,6 +12379,9 @@ "code": "500", "message": "查询失败" } + ], + "notes": [ + "B2B 排除口径:本接口在模块默认条件之上强制追加 (is_b2b IS NULL OR is_b2b = 'N'),B2B 订单不会出现在本列表中;B2B 域请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" ] }, { @@ -12216,7 +12567,7 @@ "list": [ { "method": "order.expectionOrder.list", - "description": "待处理异常订单列表,默认仅查询 step=3 的订单。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号", + "description": "待处理异常订单列表,默认仅查询 step=3 的订单。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号;默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -12240,7 +12591,7 @@ "type": "object", "required": false, "source": "body", - "description": "统一 where 条件对象;禁止传入 warehouse_id / warehouseId。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配)。" + "description": "统一 where 条件对象;禁止传入 warehouse_id / warehouseId。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配);默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" }, { "name": "sort", @@ -12273,6 +12624,9 @@ "code": "500", "message": "查询失败" } + ], + "notes": [ + "B2B 排除口径:本接口在模块默认条件之上强制追加 (is_b2b IS NULL OR is_b2b = 'N'),B2B 订单不会出现在本列表中;B2B 域请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" ] }, { @@ -12401,7 +12755,7 @@ "list": [ { "method": "order.entrustOrder.list", - "description": "委托外仓订单列表,使用 outsourced 模型。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号", + "description": "委托外仓订单列表,使用 outsourced 模型。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号;默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -12425,7 +12779,7 @@ "type": "object", "required": false, "source": "body", - "description": "统一 where 条件对象;禁止传入 warehouse_id / warehouseId。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配)。" + "description": "统一 where 条件对象;禁止传入 warehouse_id / warehouseId。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配);默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" }, { "name": "sort", @@ -12458,6 +12812,9 @@ "code": "500", "message": "查询失败" } + ], + "notes": [ + "B2B 排除口径:本接口在模块默认条件之上强制追加 (is_b2b IS NULL OR is_b2b = 'N'),B2B 订单不会出现在本列表中;B2B 域请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" ] }, { @@ -12539,7 +12896,7 @@ "list": [ { "method": "order.deliveryOrder.list", - "description": "配送订单列表,使用 dispatch 模型,默认筛选 dispatch_lane=m4。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号", + "description": "配送订单列表,使用 dispatch 模型,默认筛选 dispatch_lane=m4。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号;默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -12563,7 +12920,7 @@ "type": "object", "required": false, "source": "body", - "description": "统一 where 条件对象;禁止传入 warehouse_id / warehouseId。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配)。" + "description": "统一 where 条件对象;禁止传入 warehouse_id / warehouseId。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配);默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" }, { "name": "sort", @@ -12602,6 +12959,9 @@ "code": "500", "message": "查询失败" } + ], + "notes": [ + "B2B 排除口径:本接口在模块默认条件之上强制追加 (is_b2b IS NULL OR is_b2b = 'N'),B2B 订单不会出现在本列表中;B2B 域请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" ] }, { @@ -13113,16 +13473,10 @@ "message": "配送订单汇总查询失败(数据库异常,详情见服务端日志)" } ] - } - ] - }, - { - "groupName": "订单配送异常模块", - "module": "order.deliveryExpectionOrder", - "list": [ + }, { - "method": "order.deliveryExpectionOrder.list", - "description": "配送异常订单列表,使用 dispatch 模型,默认筛选 dispatch_lane=m5。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号", + "method": "order.deliveryOrder2b.list", + "description": "B2B 配送订单列表。查询条件与 order.deliveryOrder.list 完全一致(dispatch 分表 + 默认 dispatch_lane=m4),额外强制 is_b2b='Y'。固定条件与请求 where 取 AND,请求传入同名 is_b2b 条件无法覆盖。;列表行额外带出 wms_order_b2b 作业明细字段:total_box_count(总箱数)、pickup_plate_number(提货车牌)、prep_remark(备货备注)、prep_duration_seconds(备货用时/秒)、prep_at(备货完成时间)、is_picked_up(是否提货 Y/N)、picked_up_at(提货时间)、created_at(作业明细创建时间,与订单自身的 create_at 不同)。关联条件固定为 warehouse_id + order_id;无作业明细行时上述字段输出空值占位(数值 0、is_picked_up=N、时间为 null);另支持按 wms_order_b2b 作业明细字段筛选(仅本接口开放,普通订单列表不识别这些字段):total_box_count(总箱数)、pickup_plate_number(提货车牌)、prep_remark(备货备注)、prep_duration_seconds(备货用时/秒)、is_picked_up(Y/N)、picked_up_at(提货时间)、created_at(作业明细创建时间)、prep_at(备货完成时间)。支持简写与标准结构,如 {\"is_picked_up\":\"Y\"}、{\"pickup_plate_number\":{\"operator\":\"like\",\"value\":\"粤A\"}}、{\"prep_at\":{\"operator\":\"between\",\"value\":[\"2026-11-01 00:00:00\",\"2026-11-30 23:59:59\"]}};内部先按 warehouse_id + order_id 查 wms_order_b2b 取命中 order_id,再回填订单列表条件,未命中返回空列表。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -13146,7 +13500,126 @@ "type": "object", "required": false, "source": "body", - "description": "统一 where 条件对象;禁止传入 warehouse_id / warehouseId。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配)。" + "description": "统一 where 条件对象,语义与 order.deliveryOrder.list 完全一致(禁止传入 warehouse_id / warehouseId)。另强制附加 is_b2b='Y':即使传入 {\"is_b2b\":\"N\"} 也只会得到空列表(固定条件与请求条件取 AND);另支持按 wms_order_b2b 作业明细字段筛选(仅本接口开放,普通订单列表不识别这些字段):total_box_count(总箱数)、pickup_plate_number(提货车牌)、prep_remark(备货备注)、prep_duration_seconds(备货用时/秒)、is_picked_up(Y/N)、picked_up_at(提货时间)、created_at(作业明细创建时间)、prep_at(备货完成时间)。支持简写与标准结构,如 {\"is_picked_up\":\"Y\"}、{\"pickup_plate_number\":{\"operator\":\"like\",\"value\":\"粤A\"}}、{\"prep_at\":{\"operator\":\"between\",\"value\":[\"2026-11-01 00:00:00\",\"2026-11-30 23:59:59\"]}};内部先按 warehouse_id + order_id 查 wms_order_b2b 取命中 order_id,再回填订单列表条件,未命中返回空列表。" + }, + { + "name": "sort", + "type": "object", + "required": false, + "source": "body", + "description": "排序参数,支持 sortField / sortOrder;默认 delivery_time DESC, id DESC" + } + ], + "response": [ + { + "name": "list", + "type": "array", + "required": true, + "description": "B2B 配送订单列表(raw 行数据,字段与 order.deliveryOrder.list 一致)" + }, + { + "name": "pagination", + "type": "object", + "required": true, + "description": "分页信息" + }, + { + "name": "total_box_count", + "type": "number", + "required": true, + "description": "总箱数(wms_order_b2b.total_box_count,无作业明细行时为 0)" + }, + { + "name": "pickup_plate_number", + "type": "string", + "required": false, + "description": "提货车牌(wms_order_b2b.pickup_plate_number)" + }, + { + "name": "prep_remark", + "type": "string", + "required": false, + "description": "备货备注(wms_order_b2b.prep_remark)" + }, + { + "name": "prep_duration_seconds", + "type": "number", + "required": true, + "description": "备货用时,单位秒(wms_order_b2b.prep_duration_seconds,无作业明细行时为 0)" + }, + { + "name": "prep_at", + "type": "string", + "required": false, + "description": "备货完成时间(wms_order_b2b.prep_at)" + }, + { + "name": "is_picked_up", + "type": "string", + "required": true, + "description": "是否提货:Y=已提货 N=未提货(无作业明细行时为 N)" + }, + { + "name": "picked_up_at", + "type": "string", + "required": false, + "description": "提货时间(wms_order_b2b.picked_up_at)" + }, + { + "name": "created_at", + "type": "string", + "required": false, + "description": "B2B 作业明细创建时间(wms_order_b2b.created_at),与订单自身的 create_at 不同;无作业明细行时为 null" + } + ], + "errors": [ + { + "code": "400", + "message": "参数格式错误或缺少仓库上下文" + }, + { + "code": "500", + "message": "查询失败" + } + ], + "notes": [ + "B2B 作业明细输出口径:列表行按 warehouse_id + order_id 关联 wms_order_b2b 取数(分表 id 按仓库发号,不能只按 order_id 关联);副表已移除 store_id / delivery_order_code / is_print / updated_at / deleted_at 字段,取消 B2B 时物理删除明细行,故列表中的 created_at 为作业明细创建时间,无明细行时为空值占位。", + "B2B 作业明细筛选口径:仅在 order.pendingOrder2b.list / order.deliveryOrder2b.list 开放 total_box_count / pickup_plate_number / prep_remark / prep_duration_seconds / is_picked_up / picked_up_at / created_at / prep_at 作为 where 条件;内部转成 wms_order_b2b(warehouse_id + order_id)子查询取 order_id,再以 id IN (...) 回填,未命中返回空列表,不影响其他订单列表口径。" + ] + } + ] + }, + { + "groupName": "订单配送异常模块", + "module": "order.deliveryExpectionOrder", + "list": [ + { + "method": "order.deliveryExpectionOrder.list", + "description": "配送异常订单列表,使用 dispatch 模型,默认筛选 dispatch_lane=m5。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号;默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。", + "isNeedAuth": false, + "isNeedLogin": true, + "headers": [ + { + "name": "Authorization", + "type": "string", + "required": true, + "description": "Bearer token" + } + ], + "params": [ + { + "name": "pagination", + "type": "object", + "required": false, + "source": "body", + "description": "分页参数,支持 page / pageSize" + }, + { + "name": "where", + "type": "object", + "required": false, + "source": "body", + "description": "统一 where 条件对象;禁止传入 warehouse_id / warehouseId。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配);默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" }, { "name": "sort", @@ -13185,6 +13658,9 @@ "code": "500", "message": "查询失败" } + ], + "notes": [ + "B2B 排除口径:本接口在模块默认条件之上强制追加 (is_b2b IS NULL OR is_b2b = 'N'),B2B 订单不会出现在本列表中;B2B 域请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" ] }, { @@ -13266,7 +13742,7 @@ "list": [ { "method": "order.archiveOrder.list", - "description": "归档订单列表,使用 history 模型。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号", + "description": "归档订单列表,使用 history 模型。;列表运单号回填强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号;默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -13290,7 +13766,7 @@ "type": "object", "required": false, "source": "body", - "description": "统一 where 条件对象;禁止传入 warehouse_id / warehouseId。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配)。" + "description": "统一 where 条件对象;禁止传入 warehouse_id / warehouseId。create_channel(订单来源渠道筛选,按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单)。支持简写与标准结构:{\"create_channel\":\"MANUAL\"} 单值精确、{\"create_channel\":[\"QM\",\"API\"]} 裸数组按 in 多选、{\"create_channel\":{\"operator\":\"in\",\"value\":[\"QM\",\"API\"]}} 标准结构多选、{\"create_channel\":{\"operator\":\"ne\",\"value\":\"MANUAL\"}} 排除指定渠道。注意:列表响应中的 create_channel 已格式化为中文标签(手工单/接口/奇门/出库转单),查询条件请传英文枚举值。 is_sn_order(是否序列号订单筛选,按订单表 has_sn_item 列过滤):Y=仅序列号订单、N=仅非序列号订单;兼容 true/false、1/0、是/否,支持 {\"is_sn_order\":\"Y\"} 简写与 {\"is_sn_order\":{\"value\":\"Y\"}} 标准结构;存量订单已按明细 stock_warehouse.is_sn_mgmt 回填;sn_code / snCode / sn_codes / snCodes(按 SN 码反查订单:先查 wms_order_item_sn 拿 order_id 再回填到订单列表条件,订单表结构不变;值支持单个字符串、逗号/空格/分号分隔的多个码、字符串数组或 { value } 结构,按完整 SN 码精确匹配);默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B),需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" }, { "name": "sort", @@ -13329,6 +13805,9 @@ "code": "500", "message": "查询失败" } + ], + "notes": [ + "B2B 排除口径:本接口在模块默认条件之上强制追加 (is_b2b IS NULL OR is_b2b = 'N'),B2B 订单不会出现在本列表中;B2B 域请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。" ] }, { @@ -15638,7 +16117,7 @@ "list": [ { "method": "setting.warehouse.getSettings", - "description": "获取当前登录仓库的 subject_config;subject_config 新增大团购打包系数 big_group_pack_coefficient(数字,默认 3,单位秒/单,必须大于 0,用于 workbench 大团购波次打包时长闸门与倒计时);新增散单称重是否需要打包 single_weigh_require_pack(flag 布尔,默认 false 关闭;开启后散单称重(订单波次范围 wave_scope 非 1 大团购/3 小团购)前必须已打包完成 pack_status=fin,未打包时拒绝称重并返回错误);本次调整自动出库配置:新增 subject_config.auto_outbound_enabled(flag,默认 false 关闭);subject_config.auto_outbound_rules 由对象改为数组(每项仅校验 require_pack/require_weigh/require_sync,任一规则命中即出库;固定前置条件为已复核 recheck_status=fin 与已分配储位 storage_status=fin),移除 rules.enabled 与 require_recheck/require_print/require_pick 字段;本次文档补充「不出库当天订单」的时间口径:时间字段范围 00:00~23:59(不支持 24:00),常用组合为 允许当天出库最后时间=00:00 + 当天放开时间=23:59 表示「当天复核的订单全天不出库、过了零点后全部出库」;本次补充「不出库当天订单」的跨天口径:按订单复核时间所在日计算,放行时间支持 00:00~47:59(27:00 = 次日 03:00 放行)", + "description": "获取当前登录仓库的 subject_config;subject_config 新增大团购打包系数 big_group_pack_coefficient(数字,默认 3,单位秒/单,必须大于 0,用于 workbench 大团购波次打包时长闸门与倒计时);新增散单称重是否需要打包 single_weigh_require_pack(flag 布尔,默认 false 关闭;开启后散单称重(订单波次范围 wave_scope 非 1 大团购/3 小团购)须处于打包中或已打包(pack_status=padding/fin),未打包或打包异常时拒绝称重并返回错误);本次调整自动出库配置:新增 subject_config.auto_outbound_enabled(flag,默认 false 关闭);subject_config.auto_outbound_rules 由对象改为数组(每项仅校验 require_pack/require_weigh/require_sync,任一规则命中即出库;固定前置条件为已复核 recheck_status=fin 与已分配储位 storage_status=fin),移除 rules.enabled 与 require_recheck/require_print/require_pick 字段;本次文档补充「不出库当天订单」的时间口径:时间字段范围 00:00~23:59(不支持 24:00),常用组合为 允许当天出库最后时间=00:00 + 当天放开时间=23:59 表示「当天复核的订单全天不出库、过了零点后全部出库」;本次补充「不出库当天订单」的跨天口径:按订单复核时间所在日计算,放行时间支持 00:00~47:59(27:00 = 次日 03:00 放行)", "isNeedAuth": false, "isNeedLogin": true, "headers": [