From 59bc65b443fbe829cc5fc3376855b7e9aaa7be0a Mon Sep 17 00:00:00 2001 From: liufumingren Date: Thu, 19 Nov 2026 18:17:19 +0800 Subject: [PATCH] =?UTF-8?q?feat(order):=20B2B=20=E5=8A=A0=E6=80=A5?= =?UTF-8?q?=E4=BC=98=E5=85=88=E3=80=81=E5=88=86=E7=AE=B1=E6=98=8E=E7=BB=86?= =?UTF-8?q?=E4=B8=8E=E5=8F=96=E8=B4=A7=E5=82=A8=E4=BD=8D=EF=BC=8C=E4=BD=9C?= =?UTF-8?q?=E4=B8=9A=E9=93=BE=E8=B7=AF=E6=94=B6=E5=8F=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 列表:B2B 待处理/配送列表固定加急优先排序(wms_order_b2b.is_urgent='Y' 置顶), 作业明细筛选口径不变 - 备货/提货:新增 setB2bUrgent/cancelB2bUrgent、startB2bPrep/cancelB2bPrep/finishB2bPrep、 setB2bPickupPlate、pickupB2b、updateB2bOrderImages;提货即出库完成 (写 outbound_status=fin / step=4 / delivery_time 并迁移到配送表),车牌与提货照片 随单落库 - 分箱:新增 wms_order_b2b_items 与 order.updateB2bPackingItems、order.getB2bPackingSnapshot; 快照按商品行返回 wms_picking 取货储位(items[].pick_locations / pick_location_count), 列表不再携带储位明细 - 齐套校验:仓库 subject_config 新增 b2b_packing_quantity_check,备货完成时逐商品校验 分箱数量合计等于 plan_qty 且总箱数与箱号数一致 - 拦截:B2B 订单不参与波次抓取、快捷复核批量发货、反审回待审核与克隆,命中即整批驳回 - 明细:order.pendingOrder.detail / order.deliveryOrder.detail 为 B2B 订单附加副表作业明细 b2b、备货照片 images 与提货照片 pickup_images - 迁移:wms_order_b2b 新增 is_urgent 与备货作业字段,新建 wms_order_b2b_items - 文档:methods/system.json 与 methods/changes/system.json 同步至 0.3.375 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- app/dict/businessDict.js | 9 + app/lib/file_business_types.js | 33 + app/model/order_b2b.js | 37 +- app/model/order_b2b_item.js | 73 + app/model/store.js | 8 + app/service/systemMethods/order/base.js | 294 +- .../systemMethods/order/deliveryOrder2b.js | 1 + app/service/systemMethods/order/index.js | 396 ++- .../systemMethods/order/pendingOrder.js | 14 +- .../systemMethods/order/pendingOrder2b.js | 1 + .../systemMethods/order/recheckOrder.js | 10 +- app/service/systemMethods/order/wave.js | 15 +- app/service/systems/order_b2b.js | 2406 ++++++++++++++++- app/service/systems/setting/warehouse.js | 8 + ...17180000-add-is-urgent-to-wms-order-b2b.js | 90 + ...200000-add-prep-fields-to-wms-order-b2b.js | 140 + ...261119090000-create-wms-order-b2b-items.js | 65 + methods/changes/system.json | 125 + methods/system.json | 425 ++- ...er.pendingOrder.reverseReviewOrder.test.js | 64 + .../order/wave.singleFetchByIds.test.js | 39 +- .../service/systems/order_b2b_packing.test.js | 218 ++ 22 files changed, 4419 insertions(+), 52 deletions(-) create mode 100644 app/lib/file_business_types.js create mode 100644 app/model/order_b2b_item.js create mode 100644 database/migrations/20261117180000-add-is-urgent-to-wms-order-b2b.js create mode 100644 database/migrations/20261117200000-add-prep-fields-to-wms-order-b2b.js create mode 100644 database/migrations/20261119090000-create-wms-order-b2b-items.js create mode 100644 test/app/service/systems/order_b2b_packing.test.js diff --git a/app/dict/businessDict.js b/app/dict/businessDict.js index 7a26592..5fa1d22 100644 --- a/app/dict/businessDict.js +++ b/app/dict/businessDict.js @@ -77,6 +77,15 @@ module.exports = { ORDER_WAVE_AUTO_GROUP: '自动加团', ORDER_WAVE_STRATEGY_FETCH: '策略抓取波次', ORDER_WAVE_CLAIM: '领取波次', + ORDER_B2B_CONVERT: '转B2B订单', + ORDER_B2B_CANCEL: '取消B2B', + ORDER_B2B_SET_URGENT: '设置B2B加急', + ORDER_B2B_PREP_START: '备货开始', + ORDER_B2B_PREP_CANCEL: '取消备货', + ORDER_B2B_PREP_FINISH: '备货完成', + ORDER_B2B_PICKUP: 'B2B提货', + ORDER_B2B_PICKUP_PLATE: '录入B2B提货车牌', + ORDER_B2B_IMAGES: '更新B2B订单图片', ORDER_CONFIRM_PRINT: '确认打印', ORDER_AUTO_EXPRESS_SKIP: '跳过自动分配快递', ORDER_PICK_COMPLETE: '拣货完成', diff --git a/app/lib/file_business_types.js b/app/lib/file_business_types.js new file mode 100644 index 0000000..6baf3b3 --- /dev/null +++ b/app/lib/file_business_types.js @@ -0,0 +1,33 @@ +'use strict'; + +/** + * wms_file_reference.business_type 取值集中定义。 + * + * 文件与业务的关联统一落在 wms_file_reference:business_type 标识业务域, + * business_id 为业务主键字符串(如商品ID、盘点记录ID、订单ID), + * warehouse_id 做仓库隔离,display_order 控制展示顺序。 + * + * 新增业务域时必须在此登记,避免各服务散落硬编码字符串导致口径漂移。 + */ +const FILE_BUSINESS_TYPE = Object.freeze({ + /** 商品图片(business_id = wms_stock_warehouse.id) */ + STOCK: 'stock', + /** 盘点作业记录图片(business_id = wms_stock_check_record.id) */ + STOCK_CHECK_RECORD: 'stock_check_record', + /** 收货明细图片(business_id = 收货明细 id) */ + RECEIVING_ITEM: 'receivingItem', + /** + * B2B 订单备货留证照片(business_id = wms_order_delivery*.id)。 + * 仅用于 B2B 订单(is_b2b='Y')的备货留证照片,与普通订单附件隔离。 + */ + B2B_ORDER: 'b2b_order', + /** + * B2B 订单提货留证照片(business_id = wms_order_delivery*.id)。 + * 与备货照片(b2b_order)分开存放,便于提货交接留证与客户推送按环节区分。 + */ + B2B_PICKUP: 'b2b_pickup', +}); + +module.exports = { + FILE_BUSINESS_TYPE, +}; diff --git a/app/model/order_b2b.js b/app/model/order_b2b.js index a99c526..7a0a406 100644 --- a/app/model/order_b2b.js +++ b/app/model/order_b2b.js @@ -5,7 +5,7 @@ * * 对应数据库表 `wms_order_b2b`,与发货单(订单)分表 wms_order_delivery_% 一对一, * 记录 B2B 订单的备货/提货作业信息:总箱数、提货车牌、备货备注、备货用时、 - * 备货完成时间、是否提货等。 + * 备货完成时间、备货状态与备货人、是否加急、是否提货等。 * * 不分表(不按仓库分表),关联读统一使用 warehouse_id + order_id(分表 id 按仓库 * 各自发号,跨仓可能重叠,故不单独依赖 order_id)。取消 B2B 时物理删除行,不做软删除。 @@ -59,12 +59,39 @@ module.exports = app => { allowNull: true, comment: '备货完成时间', }, + prep_status: { + type: ENUM('none', 'padding', 'fin'), + allowNull: false, + defaultValue: 'none', + comment: '备货状态:none=未开始 padding=备货中 fin=已完成', + }, + prep_operator_id: { + type: BIGINT(20).UNSIGNED, + allowNull: true, + comment: '备货人工号ID(工号,用于同工号校验)', + }, + prep_operator_name: { + type: STRING(50), + allowNull: true, + comment: '备货人姓名', + }, + prep_start_at: { + type: DATE, + allowNull: true, + comment: '备货开始时间', + }, is_picked_up: { type: ENUM('Y', 'N'), allowNull: false, defaultValue: 'N', comment: '是否提货:Y=已提货 N=未提货', }, + is_urgent: { + type: ENUM('Y', 'N'), + allowNull: false, + defaultValue: 'N', + comment: '是否加急:Y=加急 N=普通', + }, picked_up_at: { type: DATE, allowNull: true, @@ -93,6 +120,14 @@ module.exports = app => { name: 'idx_is_picked_up', fields: [ 'is_picked_up' ], }, + { + name: 'idx_is_urgent', + fields: [ 'is_urgent' ], + }, + { + name: 'idx_prep_status_operator', + fields: [ 'prep_status', 'prep_operator_id' ], + }, ], }); diff --git a/app/model/order_b2b_item.js b/app/model/order_b2b_item.js new file mode 100644 index 0000000..e5bdf66 --- /dev/null +++ b/app/model/order_b2b_item.js @@ -0,0 +1,73 @@ +'use strict'; + +/** + * B2B 订单分箱商品明细。 + * @param {import('egg').Application} app Egg 应用实例。 + */ +module.exports = app => { + const { BIGINT, INTEGER, STRING, DATE } = app.Sequelize; + + return app.model.define('wms_order_b2b_items', { + id: { + type: BIGINT(20).UNSIGNED, + primaryKey: true, + autoIncrement: true, + allowNull: false, + comment: '主键ID', + }, + warehouse_id: { + type: BIGINT(20).UNSIGNED, + allowNull: false, + comment: '仓库ID', + }, + order_id: { + type: BIGINT(20).UNSIGNED, + allowNull: false, + comment: '订单ID', + }, + order_item_id: { + type: BIGINT(20).UNSIGNED, + allowNull: false, + comment: '订单商品明细ID', + }, + box_no: { + type: STRING(50), + allowNull: false, + comment: '箱号', + }, + quantity: { + type: INTEGER(11).UNSIGNED, + allowNull: false, + comment: '该商品在该箱中的数量', + }, + created_at: { + type: DATE, + allowNull: false, + comment: '创建时间', + }, + updated_at: { + type: DATE, + allowNull: false, + comment: '更新时间', + }, + }, { + tableName: 'wms_order_b2b_items', + comment: 'B2B订单分箱商品明细表', + timestamps: false, + indexes: [ + { + name: 'uk_warehouse_order_item_box', + unique: true, + fields: [ 'warehouse_id', 'order_id', 'order_item_id', 'box_no' ], + }, + { + name: 'idx_warehouse_order', + fields: [ 'warehouse_id', 'order_id' ], + }, + { + name: 'idx_order_item', + fields: [ 'order_item_id' ], + }, + ], + }); +}; diff --git a/app/model/store.js b/app/model/store.js index 1c5e8d0..c9977f6 100644 --- a/app/model/store.js +++ b/app/model/store.js @@ -101,6 +101,7 @@ module.exports = app => { group_order_pack_max_minutes: 40, big_group_pack_coefficient: 3, single_weigh_require_pack: false, + b2b_packing_quantity_check: false, stock_warning_enabled: false, stock_warning_quantity: 0, stock_static_hours: 168, @@ -575,6 +576,13 @@ module.exports = app => { ); } + if (Object.prototype.hasOwnProperty.call(parsed, 'b2b_packing_quantity_check')) { + normalized.b2b_packing_quantity_check = normalizeBooleanFlag( + parsed.b2b_packing_quantity_check, + 'subject_config.b2b_packing_quantity_check' + ); + } + // 是否开启库存预警:默认关闭 if (Object.prototype.hasOwnProperty.call(parsed, 'stock_warning_enabled')) { normalized.stock_warning_enabled = normalizeBooleanFlag( diff --git a/app/service/systemMethods/order/base.js b/app/service/systemMethods/order/base.js index d53e234..7832fba 100644 --- a/app/service/systemMethods/order/base.js +++ b/app/service/systemMethods/order/base.js @@ -4,6 +4,7 @@ const MainService = require('../../main'); const { parseWhereConditions } = require('../../../lib/query_condition_parser'); const { isInterceptedOrderStatus } = require('../../../lib/intercept_guard'); const { isLockedOrderStatus } = require('../../../lib/lock_guard'); +const { FILE_BUSINESS_TYPE } = require('../../../lib/file_business_types'); const DEFAULT_PAGE_SIZE = 20; const MAX_PAGE_SIZE = 500; @@ -58,6 +59,11 @@ const ORDER_B2B_DETAIL_ATTRIBUTES = Object.freeze([ 'pickup_plate_number', 'prep_remark', 'prep_duration_seconds', + 'prep_status', + 'prep_operator_id', + 'prep_operator_name', + 'prep_start_at', + 'is_urgent', 'is_picked_up', 'picked_up_at', 'created_at', @@ -70,6 +76,11 @@ const ORDER_B2B_DETAIL_EMPTY = Object.freeze({ pickup_plate_number: null, prep_remark: null, prep_duration_seconds: 0, + prep_status: 'none', + prep_operator_id: null, + prep_operator_name: null, + prep_start_at: null, + is_urgent: 'N', is_picked_up: 'N', picked_up_at: null, created_at: null, @@ -82,6 +93,10 @@ const ORDER_B2B_DETAIL_FILTER_FIELDS = Object.freeze([ 'pickup_plate_number', 'prep_remark', 'prep_duration_seconds', + 'prep_status', + 'prep_operator_id', + 'prep_start_at', + 'is_urgent', 'is_picked_up', 'picked_up_at', 'created_at', @@ -1934,7 +1949,8 @@ class OrderBaseService extends MainService { * 不可被请求中的同名字段覆盖(用于 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)作为筛选条件。 + * is_urgent / is_picked_up / picked_up_at / created_at / prep_at)作为筛选条件。 + * @param {boolean} [options.urgentFirst=false] 是否让加急订单(wms_order_b2b.is_urgent='Y')优先排序。 * @return {Promise} 列表与分页信息。 */ async listByModule(moduleName = 'order', data = {}, options = {}) { @@ -2023,7 +2039,11 @@ class OrderBaseService extends MainService { } const model = await this.getOrderModel(moduleName, contextWarehouseId); - const order = this.buildListOrder(requestData.sort, moduleName); + const baseOrder = this.buildListOrder(requestData.sort, moduleName); + const urgentOrder = normalizedOptions.urgentFirst === true + ? this.buildB2bUrgentFirstOrder(model, contextWarehouseId) + : null; + const order = urgentOrder ? [ urgentOrder, ...baseOrder ] : baseOrder; const offset = (page - 1) * pageSize; const moduleConfig = this.getModuleConfig(moduleName); const listAttributes = moduleConfig.modelType === 'history' @@ -2098,16 +2118,103 @@ class OrderBaseService extends MainService { } /** - * 为订单列表行附加 B2B 作业明细字段(副表 wms_order_b2b)。 + * 规范化 B2B 作业明细行的输出字段(列表与详情共用)。 + * + * @param {Object|null} detail wms_order_b2b 行。 + * @return {Object} 统一字段结构;detail 为空时输出空值占位。 + */ + formatB2bDetailFields(detail) { + if (!detail) { + return { ...ORDER_B2B_DETAIL_EMPTY }; + } + + return { + 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), + prep_status: String(detail.prep_status || 'none').trim() || 'none', + prep_operator_id: detail.prep_operator_id === null || detail.prep_operator_id === undefined + ? null + : Number(detail.prep_operator_id), + prep_operator_name: detail.prep_operator_name ?? null, + prep_start_at: detail.prep_start_at ?? null, + is_urgent: String(detail.is_urgent || 'N').trim() === 'Y' ? 'Y' : 'N', + 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='Y' 的订单返回副表数据:非 B2B 订单返回 + * { b2b: null, images: [], pickup_images: [] },保持结构稳定。 + * B2B 订单无副表行时 b2b 输出空值占位(字段结构不变): + * images 来自 wms_file_reference(business_type=b2b_order,备货照片), + * pickup_images 来自 wms_file_reference(business_type=b2b_pickup,提货照片), + * 两者均按 display_order 升序。 + * + * @param {Object} order 订单行(需含 id、is_b2b)。 + * @param {number|string|null} [warehouseId=null] 仓库ID,缺省取当前上下文。 + * @return {Promise<{ b2b: (Object|null), images: Array, pickup_images: Array }>} + * 副表字段、备货照片与提货照片列表。 + */ + async buildB2bDetailExtras(order = {}, warehouseId = null) { + const emptyResult = { b2b: null, images: [], pickup_images: [] }; + const orderId = Number(order && order.id || 0); + const normalizedWarehouseId = Number(warehouseId ?? this.getWarehouseId() ?? 0); + + if (String(order && order.is_b2b || '').trim() !== 'Y' + || !Number.isInteger(orderId) || orderId <= 0 + || !Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) { + return emptyResult; + } + + const b2bModel = this.ctx.model && this.ctx.model.OrderB2b; + let b2bDetail = null; + + if (b2bModel && typeof b2bModel.findOne === 'function') { + b2bDetail = await b2bModel.findOne({ + where: { + warehouse_id: normalizedWarehouseId, + order_id: orderId, + }, + attributes: [ ...ORDER_B2B_DETAIL_ATTRIBUTES ], + raw: true, + }) || null; + } + + const imageMap = new Map(); + const pickupImageMap = new Map(); + await this.attachB2bImages({ prepImageMap: imageMap, pickupImageMap }, [ orderId ], normalizedWarehouseId); + + return { + b2b: this.formatB2bDetailFields(b2bDetail), + images: imageMap.get(orderId) || [], + pickup_images: pickupImageMap.get(orderId) || [], + }; + } + + /** + * 为订单列表行附加 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。 + * prep_status / prep_operator_id / prep_operator_name / prep_start_at / + * is_urgent / is_picked_up / picked_up_at / created_at(副表创建时间) / prep_at。 + * + * 同时批量挂载 B2B 订单图片(元素结构统一为 { file_id, url, display_order }): + * - images(business_type=b2b_order,备货照片) + * - pickup_images(business_type=b2b_pickup,提货照片) + * 均按 display_order 升序,无图片输出空数组。 * * @param {Array} list 订单列表行(需含 id)。 * @param {number|string|null} [warehouseId=null] 仓库ID,缺省取当前上下文。 - * @return {Promise>} 附加 B2B 作业明细后的列表。 + * @return {Promise>} 附加 B2B 作业明细与图片后的列表。 */ async attachB2bJobDetail(list = [], warehouseId = null) { const rows = Array.isArray(list) ? list : []; @@ -2118,6 +2225,8 @@ class OrderBaseService extends MainService { const normalizedWarehouseId = Number(warehouseId ?? this.getWarehouseId() ?? 0); const b2bModel = this.ctx.model && this.ctx.model.OrderB2b; const detailMap = new Map(); + const imageMap = new Map(); + const pickupImageMap = new Map(); if (Number.isInteger(normalizedWarehouseId) && normalizedWarehouseId > 0 && b2bModel && typeof b2bModel.findAll === 'function') { @@ -2141,29 +2250,138 @@ class OrderBaseService extends MainService { detailMap.set(orderId, detail); } } + + await this.attachB2bImages({ + prepImageMap: imageMap, + pickupImageMap, + }, orderIds, normalizedWarehouseId); } } return rows.map(row => { - const detail = detailMap.get(Number(row && row.id || 0)); - if (!detail) { - return { ...row, ...ORDER_B2B_DETAIL_EMPTY }; - } + const orderId = Number(row && row.id || 0); + const detail = detailMap.get(orderId); + const images = imageMap.get(orderId) || []; + const pickupImages = pickupImageMap.get(orderId) || []; 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, + ...this.formatB2bDetailFields(detail), + images, + pickup_images: pickupImages, }; }); } + /** + * 批量读取 B2B 订单图片并按业务类型分发(一次查询,不做 N+1)。 + * + * 数据源为 wms_file_reference(warehouse_id 隔离)关联 wms_file.file_url, + * 同时取 business_type=b2b_order(备货照片)与 b2b_pickup(提货照片), + * 按 display_order、id 升序后分别写入 prepImageMap / pickupImageMap + * (订单ID → [{ id, url, display_order }]);无引用模型或查询失败时保持空映射 + * (列表输出空数组),不影响列表主流程。 + * + * @param {Object} targetMaps 输出映射容器。 + * @param {Map>} [targetMaps.prepImageMap] 备货照片输出映射。 + * @param {Map>} [targetMaps.pickupImageMap] 提货照片输出映射。 + * @param {Array} orderIds 订单ID列表。 + * @param {number} warehouseId 仓库ID。 + * @return {Promise} 无返回值。 + */ + async attachB2bImages(targetMaps = {}, orderIds = [], warehouseId = 0) { + const fileReferenceModel = this.ctx.model && this.ctx.model.FileReference; + const prepImageMap = targetMaps && targetMaps.prepImageMap; + const pickupImageMap = targetMaps && targetMaps.pickupImageMap; + if ((!prepImageMap && !pickupImageMap) || !fileReferenceModel + || typeof fileReferenceModel.findAll !== 'function') { + return; + } + + try { + const imageRefs = await fileReferenceModel.findAll({ + where: { + business_type: { + [this.app.Sequelize.Op.in]: [ FILE_BUSINESS_TYPE.B2B_ORDER, FILE_BUSINESS_TYPE.B2B_PICKUP ], + }, + business_id: { [this.app.Sequelize.Op.in]: orderIds.map(String) }, + warehouse_id: warehouseId, + }, + include: [{ + model: this.ctx.model.File, + as: 'file', + attributes: [ 'file_url' ], + required: false, + }], + order: [[ 'display_order', 'ASC' ], [ 'id', 'ASC' ]], + raw: true, + }); + + for (const ref of (Array.isArray(imageRefs) ? imageRefs : [])) { + const businessType = String(ref && ref.business_type || '').trim(); + const targetMap = businessType === FILE_BUSINESS_TYPE.B2B_PICKUP + ? pickupImageMap + : businessType === FILE_BUSINESS_TYPE.B2B_ORDER + ? prepImageMap + : null; + if (!targetMap) { + continue; + } + + const orderId = Number(ref && ref.business_id || 0); + const fileId = Number(ref && ref.file_id || 0); + if (!Number.isInteger(orderId) || orderId <= 0 || !Number.isInteger(fileId) || fileId <= 0) { + continue; + } + + if (!targetMap.has(orderId)) { + targetMap.set(orderId, []); + } + const url = String(ref['file.file_url'] || '').trim(); + targetMap.get(orderId).push({ + file_id: fileId, + url: url || null, + display_order: Number(ref.display_order || 0), + }); + } + } catch (error) { + if (this.ctx.logger && typeof this.ctx.logger.warn === 'function') { + this.ctx.logger.warn('[attachB2bImages] 查询订单图片失败,列表输出空图片列表', error); + } + } + } + + /** + * 构造"加急优先"排序项(B2B 域列表专用)。 + * + * 观察表为 wms_order_b2b(按 warehouse_id + order_id 唯一索引关联), + * 该行 is_urgent='Y' 时排在最前;无作业明细行时子查询为 NULL,排序落到最后。 + * + * @param {Object} model 订单分表模型(用于取物理表名作为限定前缀)。 + * @param {number|string} warehouseId 仓库ID。 + * @return {Array} Sequelize order 单项 [literal, 'DESC']。 + */ + buildB2bUrgentFirstOrder(model, warehouseId) { + const { Sequelize } = this.app; + const tableName = String( + (model && (model.tableName || (typeof model.getTableName === 'function' ? model.getTableName() : ''))) || '' + ).trim(); + const normalizedWarehouseId = Number(warehouseId || 0); + + if (!tableName || !Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) { + return null; + } + + const orderIdColumn = `\`${tableName}\`.\`id\``; + + return [ + Sequelize.literal( + `(SELECT b2b.is_urgent FROM wms_order_b2b b2b WHERE b2b.warehouse_id = ${normalizedWarehouseId} AND b2b.order_id = ${orderIdColumn} LIMIT 1) = 'Y'` + ), + 'DESC', + ]; + } + /** * 构造"排除 B2B 订单"条件(is_b2b 为 NULL 的存量行视为非 B2B)。 * @return {Object} Sequelize 条件。 @@ -2180,6 +2398,42 @@ class OrderBaseService extends MainService { }; } + /** + * 判断订单行是否为 B2B 订单(is_b2b='Y';NULL 存量行视为非 B2B)。 + * + * @param {Object} row 订单行。 + * @return {boolean} 是否 B2B 订单。 + */ + isB2bOrderRow(row = {}) { + return String(row && row.is_b2b || '').trim() === 'Y'; + } + + /** + * 校验订单集合中不含 B2B 订单,命中即整批驳回。 + * + * B2B 订单走备货/提货独立作业链路,不参与反审回待审核、波次抓取、批量发货、克隆等常规流程, + * 命中任意 B2B 订单时直接抛出业务异常(不做部分处理),由调用方整批返回不生效提示。 + * + * @param {Array} rows 订单行集合(需包含 id、is_b2b 字段)。 + * @param {string} actionName 操作名称,用于提示文案,如「反审回待审核」。 + * @return {void} 无返回值;命中 B2B 订单时抛错。 + */ + assertOrdersNotB2b(rows = [], actionName = '该操作') { + const b2bOrderIds = [ ...new Set((Array.isArray(rows) ? rows : []) + .filter(row => this.isB2bOrderRow(row)) + .map(row => Number(row && row.id || 0)) + .filter(orderId => Number.isInteger(orderId) && orderId > 0)) ] + .sort((a, b) => a - b); + + if (b2bOrderIds.length === 0) { + return; + } + + const displayOrderIds = b2bOrderIds.slice(0, 10).join(','); + const suffix = b2bOrderIds.length > 10 ? ` 等 ${b2bOrderIds.length} 单` : ''; + throw new Error(`B2B 订单不支持${actionName}(订单[${displayOrderIds}]${suffix}),操作不生效`); + } + /** * 从 where 中提取 B2B 作业明细筛选条件(仅 B2B 域列表使用)。 * @@ -2335,12 +2589,18 @@ class OrderBaseService extends MainService { ? [ ...new Set(expresses.map(expr => String(expr && expr.waybill_code || '').trim()).filter(Boolean)) ] : []; + // B2B 订单附加副表作业明细(备货/提货/箱数/车牌)与备货/提货照片;非 B2B 订单 b2b=null、images=[]、pickup_images=[] + const { b2b, images, pickup_images: pickupImages } = await this.buildB2bDetailExtras(order, warehouseId); + return { detail: order, items: orderItemsWithStockInfo, expresses, waybill_codes: waybillCodes, logs, + b2b, + images, + pickup_images: pickupImages, }; } diff --git a/app/service/systemMethods/order/deliveryOrder2b.js b/app/service/systemMethods/order/deliveryOrder2b.js index a904d64..fe10c08 100644 --- a/app/service/systemMethods/order/deliveryOrder2b.js +++ b/app/service/systemMethods/order/deliveryOrder2b.js @@ -36,6 +36,7 @@ class DeliveryOrder2bService extends OrderBaseService { const result = await this.listByModule('deliveryOrder', data, { fixedWhere: B2B_FIXED_WHERE, b2bDetailFilter: true, + urgentFirst: true, }); return { ...result, diff --git a/app/service/systemMethods/order/index.js b/app/service/systemMethods/order/index.js index 5a2ad88..5fc2c52 100644 --- a/app/service/systemMethods/order/index.js +++ b/app/service/systemMethods/order/index.js @@ -13,9 +13,9 @@ class OrderIndexService extends OrderBaseService { constructor(ctx) { super(ctx); const _noNeedLogin = ''; - const _noNeedRight = 'list,badgeCount,manualOutboundOrder,queryOrderLogs,queryOrderLogList,detail,updateExpressWeighingWeight,export,exportTaskProgress,bindExpressPackageMaterialByWaybill,convertToB2b,cancelB2b'; - const _noNeedLog = 'list,badgeCount,manualOutboundOrder,queryOrderLogs,queryOrderLogList,detail,updateExpressWeighingWeight,export,exportTaskProgress,bindExpressPackageMaterialByWaybill,convertToB2b,cancelB2b'; - const _noNeedAuth = 'list,badgeCount,manualOutboundOrder,queryOrderLogs,queryOrderLogList,detail,updateExpressWeighingWeight,export,exportTaskProgress,bindExpressPackageMaterialByWaybill,convertToB2b,cancelB2b'; + const _noNeedRight = 'list,badgeCount,manualOutboundOrder,queryOrderLogs,queryOrderLogList,detail,updateExpressWeighingWeight,export,exportTaskProgress,bindExpressPackageMaterialByWaybill,convertToB2b,cancelB2b,setB2bUrgent,cancelB2bUrgent,startB2bPrep,cancelB2bPrep,finishB2bPrep,updateB2bPackingItems,getB2bPackingSnapshot,setB2bPickupPlate,pickupB2b,updateB2bOrderImages'; + const _noNeedLog = 'list,badgeCount,manualOutboundOrder,queryOrderLogs,queryOrderLogList,detail,updateExpressWeighingWeight,export,exportTaskProgress,bindExpressPackageMaterialByWaybill,convertToB2b,cancelB2b,setB2bUrgent,cancelB2bUrgent,startB2bPrep,cancelB2bPrep,finishB2bPrep,updateB2bPackingItems,getB2bPackingSnapshot,setB2bPickupPlate,pickupB2b,updateB2bOrderImages'; + const _noNeedAuth = 'list,badgeCount,manualOutboundOrder,queryOrderLogs,queryOrderLogList,detail,updateExpressWeighingWeight,export,exportTaskProgress,bindExpressPackageMaterialByWaybill,convertToB2b,cancelB2b,setB2bUrgent,cancelB2bUrgent,startB2bPrep,cancelB2bPrep,finishB2bPrep,updateB2bPackingItems,getB2bPackingSnapshot,setB2bPickupPlate,pickupB2b,updateB2bOrderImages'; this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth); } @@ -115,6 +115,396 @@ class OrderIndexService extends OrderBaseService { return this.success('ok', result); } + /** + * 取消 B2B 订单加急(仅对 B2B 订单生效)。 + * + * 等价于 order.setB2bUrgent 传 is_urgent='N',入参 is_urgent 被强制覆盖为 N, + * 避免调用方误传导致加急未被取消。校验与跳过口径同 setB2bUrgent: + * 非 B2B 订单、已取消订单跳过并在 skipped_reasons 返回原因。 + * + * @param {Object} data 请求体。 + * @param {Array|number|string} [data.ids] 订单ID集合(优先)。 + * @param {Array|number|string} [data.order_ids] 订单ID集合别名。 + * @param {Array|number|string} [data.orderIds] 订单ID集合别名。 + * @param {number|string} [data.id] 订单ID单值别名。 + * @return {Promise} 统一成功包装响应(data.is_urgent 恒为 'N')。 + */ + async cancelB2bUrgent(data = {}) { + const requestData = this.isPlainObject(data) ? data : {}; + + return await this.setB2bUrgent({ + ...requestData, + is_urgent: 'N', + isUrgent: 'N', + urgent: 'N', + }); + } + + /** + * 设置 B2B 订单是否加急(仅对 B2B 订单生效)。 + * + * 非 B2B 订单跳过并在 skipped_reasons 返回原因;已取消订单同样跳过。 + * 订单在 current 分表查找,未命中兜底到 dispatch 分表;事务内更新 + * wms_order_b2b.is_urgent,提交后写操作日志。 + * + * @param {Object} data 请求体。 + * @param {Array|number|string} [data.ids] 订单ID集合(优先)。 + * @param {Array|number|string} [data.order_ids] 订单ID集合别名。 + * @param {Array|number|string} [data.orderIds] 订单ID集合别名。 + * @param {number|string} [data.id] 订单ID单值别名。 + * @param {string|boolean|number} [data.is_urgent='Y'] 是否加急(兼容 is_urgent/isUrgent/urgent,支持 Y/N、true/false、1/0)。 + * @return {Promise} 统一成功包装响应(data 含 updated/skipped/not_found 分流结果)。 + */ + async setB2bUrgent(data = {}) { + const requestData = this.isPlainObject(data) ? data : {}; + const rawIds = requestData.ids !== undefined ? requestData.ids + : requestData.order_ids !== undefined ? requestData.order_ids + : requestData.orderIds !== undefined ? requestData.orderIds + : requestData.id !== undefined ? requestData.id + : requestData.order_id !== undefined ? requestData.order_id + : requestData.orderId; + const orderIds = [ ...new Set( + (Array.isArray(rawIds) ? rawIds : [ rawIds ]) + .map(item => Number(item)) + .filter(item => Number.isInteger(item) && item > 0) + ) ]; + if (orderIds.length === 0) { + return this.fail('订单ID不能为空', {}, 400); + } + if (orderIds.length > 200) { + return this.fail('单次最多设置 200 个订单', {}, 400); + } + + const isUrgent = requestData.is_urgent !== undefined ? requestData.is_urgent + : requestData.isUrgent !== undefined ? requestData.isUrgent + : requestData.urgent; + const warehouseId = this.getWarehouseId(); + const operator = this.getOrderLogOperator(); + + let result; + try { + result = await this.service.systems.orderB2b.setOrdersB2bUrgent({ + warehouseId, + orderIds, + isUrgent, + operator, + }); + } catch (error) { + if (error && /is_urgent 参数不合法/.test(error.message)) { + return this.fail(error.message, {}, 400); + } + throw error; + } + + return this.success('ok', result); + } + + /** + * 备货开始(仅 B2B 订单,单订单作业):记录备货人工号与开始时间。 + * + * 操作人为当前登录工号(ctx.user);同工号重复开始幂等成功, + * 订单已由其他工号开始或已完成时返回失败。ids 仅允许传 1 个订单ID。 + * 作业前置条件:已打印(print_status=fin)、已分配储位(storage_status=fin)且未拦截 + * (intercept_status=none),不满足返回 failure 400 且不写入任何备货数据; + * 领料(claim_status)不校验——领料只在波次整波领单流程产生,B2B 订单无波次。 + * + * @param {Object} data 请求体。 + * @param {Array|number|string} [data.ids] 订单ID集合(优先)。 + * @param {Array|number|string} [data.order_ids] 订单ID集合别名。 + * @return {Promise} 统一响应。 + */ + async startB2bPrep(data = {}) { + return await this.runB2bSingleOrderAction( + data, + 'startOrdersB2bPrep', + d => ({ warehouseId: this.getWarehouseId(), orderIds: this.normalizeB2bPrepOrderIds(d), operator: this.getOrderLogOperator() }), + '备货作业' + ); + } + + /** + * 取消备货(仅 B2B 订单,单订单作业):重置备货人、开始时间与备货状态。 + * + * 仅备货中的订单可取消,且必须由记录在案的同一工号操作,否则返回失败。ids 仅允许传 1 个订单ID。 + * + * @param {Object} data 请求体(入参同 startB2bPrep)。 + * @return {Promise} 统一响应。 + */ + async cancelB2bPrep(data = {}) { + return await this.runB2bSingleOrderAction( + data, + 'cancelOrdersB2bPrep', + d => ({ warehouseId: this.getWarehouseId(), orderIds: this.normalizeB2bPrepOrderIds(d), operator: this.getOrderLogOperator() }), + '备货作业' + ); + } + + /** + * 备货结束(仅 B2B 订单,单订单作业):写入备货备注、总箱数、完成时间与备货用时。 + * + * 结束时间取提交时刻;仅备货中的订单可结束,且必须由同一工号提交,否则返回失败。ids 仅允许传 1 个订单ID。 + * + * @param {Object} data 请求体。 + * @param {Array|number|string} [data.ids] 订单ID集合(优先)。 + * @param {string} data.prep_remark 备货备注(必填,兼容 prepRemark)。 + * @param {number|string} data.total_box_count 总箱数(必填,兼容 totalBoxCount)。 + * @return {Promise} 统一响应。 + */ + async finishB2bPrep(data = {}) { + return await this.runB2bSingleOrderAction( + data, + 'finishOrdersB2bPrep', + d => ({ + warehouseId: this.getWarehouseId(), + orderIds: this.normalizeB2bPrepOrderIds(d), + operator: this.getOrderLogOperator(), + prepRemark: d.prep_remark !== undefined ? d.prep_remark : d.prepRemark, + totalBoxCount: d.total_box_count !== undefined ? d.total_box_count : d.totalBoxCount, + }), + '备货作业' + ); + } + + /** + * 全量更新单个 B2B 订单的商品分箱明细。 + * @param {Object} data 请求体。 + * @param {Array} data.items 分箱行:order_item_id、box_no、quantity。 + * @return {Promise} 更新结果。 + */ + async updateB2bPackingItems(data = {}) { + return await this.runB2bSingleOrderAction( + data, + 'updateB2bPackingItems', + d => ({ + warehouseId: this.getWarehouseId(), + orderIds: this.normalizeB2bPrepOrderIds(d), + operator: this.getOrderLogOperator(), + items: d.items, + }), + '更新分箱明细' + ); + } + + /** + * 获取单个 B2B 订单商品与分箱记录的完整快照。 + * @param {Object} data 请求体。 + * @return {Promise} 订单快照。 + */ + async getB2bPackingSnapshot(data = {}) { + return await this.runB2bSingleOrderAction( + data, + 'getB2bPackingSnapshot', + d => ({ + warehouseId: this.getWarehouseId(), + orderIds: this.normalizeB2bPrepOrderIds(d), + }), + '查询分箱快照' + ); + } + + /** + * 录入/修改 B2B 提货车牌(单订单,提货前可改)。 + * + * 仅 B2B 订单且未取消的订单可录入;订单已提货(is_picked_up='Y')后车牌锁定, + * 不允许再修改。作业明细行缺失时自动补建。传空字符串或 null 表示清空车牌; + * 车牌会去掉空格与分隔符并转大写后落库。ids 仅允许传 1 个订单ID。 + * + * @param {Object} data 请求体。 + * @param {number|string} [data.ids] 订单ID(单值或单元素数组)。 + * @param {string|null} data.pickup_plate_number 提货车牌(必传键;兼容 pickupPlateNumber,空串/null 清空)。 + * @return {Promise} 统一响应。 + */ + async setB2bPickupPlate(data = {}) { + return await this.runB2bSingleOrderAction( + data, + 'setOrdersB2bPickupPlate', + d => ({ + warehouseId: this.getWarehouseId(), + orderIds: this.normalizeB2bPrepOrderIds(d), + operator: this.getOrderLogOperator(), + pickupPlateNumber: d.pickup_plate_number !== undefined ? d.pickup_plate_number : d.pickupPlateNumber, + }), + '录入提货车牌' + ); + } + + /** + * B2B 提货(单订单作业):记录提货时间。仅 B2B 订单生效。 + * + * 要求备货已完成(prep_status=fin);已提货订单幂等成功(保留首次提货时间)。 + * 可选传 pickup_plate_number 在提货同时写入车牌(提货后不允许再改); + * 可选传 file_ids(标准字段,兼容 pickup_file_ids / pickupFileIds / pickup_images / pickupImages) + * 在提货同时写入提货照片,照片只做一轮存在性校验后追加到 business_type='b2b_pickup' 的关联下。 + * ids 仅允许传 1 个订单ID。 + * + * @param {Object} data 请求体。 + * @param {number|string} [data.ids] 订单ID(单值或单元素数组)。 + * @param {string|null} [data.pickup_plate_number] 提货车牌(可选,兼容 pickupPlateNumber)。 + * @param {Array} [data.file_ids] 提货照片列表(标准字段, + * 元素为 file_id 或 { file_id, display_order })。 + * @return {Promise} 统一响应。 + */ + async pickupB2b(data = {}) { + return await this.runB2bSingleOrderAction( + data, + 'pickupOrdersB2b', + d => ({ + warehouseId: this.getWarehouseId(), + orderIds: this.normalizeB2bPrepOrderIds(d), + operator: this.getOrderLogOperator(), + pickupPlateNumber: d.pickup_plate_number !== undefined ? d.pickup_plate_number : d.pickupPlateNumber, + pickupImages: this.resolveB2bPickupImageInput(d), + }), + '提货' + ); + } + + /** + * 解析 B2B 图片入参(统一标准字段 file_ids,兼容各别名)。 + * + * 标准写法:file_ids,元素为 file_id(数字/数字字符串)或 { file_id, display_order }。 + * 别名按传入顺序作为后备:同时传标准字段与别名时以 file_ids/fileIds 为准。 + * + * @param {Object} data 请求体。 + * @param {string[]} [aliasKeys=[]] 该场景额外接受的别名字段。 + * @return {*} 原始图片入参(未传时返回 undefined)。 + */ + resolveB2bFileIdsInput(data = {}, aliasKeys = []) { + const keys = [ 'file_ids', 'fileIds', ...aliasKeys ]; + for (const key of keys) { + if (data[key] !== undefined) { + return data[key]; + } + } + return undefined; + } + + /** + * 解析提货时随车提交的照片入参(标准 file_ids)。 + * + * 兼容别名:pickup_file_ids / pickupFileIds / pickup_images / pickupImages。 + * + * @param {Object} data 请求体。 + * @return {Array|undefined} 图片列表;未传时返回 undefined(表示本次不附带提货照片)。 + */ + resolveB2bPickupImageInput(data = {}) { + return this.resolveB2bFileIdsInput(data, [ 'pickup_file_ids', 'pickupFileIds', 'pickup_images', 'pickupImages' ]); + } + + /** + * 解析备货照片入参(标准 file_ids)。 + * + * 兼容别名:images(历史写法,语义等价于 file_ids)。 + * + * @param {Object} data 请求体。 + * @return {*} 原始图片入参(未传时返回 undefined,由业务层判定为非法)。 + */ + resolveB2bImageListInput(data = {}) { + return this.resolveB2bFileIdsInput(data, [ 'images' ]); + } + + /** + * 更新 B2B 订单图片(单订单,全量覆盖)。 + * + * 图片关系统一落在 wms_file_reference:business_type='b2b_order'、 + * business_id=订单ID、warehouse_id=当前仓库、display_order 控制展示顺序。 + * 标准入参为 file_ids(元素 file_id 或 { file_id, display_order }), + * 兼容别名 images / fileIds;全量覆盖语义:未包含的旧关联会被删除, + * 新关联按列表顺序写入;传空数组表示清空该订单图片。 + * 仅 B2B 订单(is_b2b='Y')且未取消的订单可更新。 + * + * @param {Object} data 请求体。 + * @param {number|string} [data.id] 订单ID(单值或单元素数组)。 + * @param {Array} data.file_ids 图片列表(标准字段),元素可为 + * { file_id, display_order } 或直接传 file_id;兼容 images / fileIds 简写。 + * @return {Promise} 统一响应。 + */ + async updateB2bOrderImages(data = {}) { + const requestData = this.isPlainObject(data) ? data : {}; + const orderIds = this.normalizeB2bPrepOrderIds(requestData); + + if (orderIds.length === 0) { + return this.fail('订单ID不能为空', {}, 400); + } + if (orderIds.length > 1) { + return this.fail('更新订单图片仅支持单个订单,请单条提交', { order_ids: orderIds }, 400); + } + + const rawImages = this.resolveB2bImageListInput(requestData); + + try { + const result = await this.service.systems.orderB2b.updateOrderImages({ + warehouseId: this.getWarehouseId(), + orderIds, + images: rawImages, + operator: this.getOrderLogOperator(), + }); + return this.success('ok', result); + } catch (error) { + const code = String(error && error.code || ''); + if (code.startsWith('B2B_IMAGE_')) { + return this.fail(error.message, error.data || {}, 400); + } + throw error; + } + } + + /** + * 归一化备货/提货单订单入参(6 种别名,单值或单元素数组)。 + * @param {Object} requestData 请求体。 + * @return {number[]} 订单ID数组。 + */ + normalizeB2bPrepOrderIds(requestData = {}) { + const rawIds = requestData.ids !== undefined ? requestData.ids + : requestData.order_ids !== undefined ? requestData.order_ids + : requestData.orderIds !== undefined ? requestData.orderIds + : requestData.id !== undefined ? requestData.id + : requestData.order_id !== undefined ? requestData.order_id + : requestData.orderId; + return [ ...new Set( + (Array.isArray(rawIds) ? rawIds : [ rawIds ]) + .map(item => Number(item)) + .filter(item => Number.isInteger(item) && item > 0) + ) ]; + } + + /** + * B2B 单订单作业统一执行壳:入参校验 → 调业务层 → 统一成功/失败包装。 + * + * 业务层抛出的备货/提货/车牌/图片校验错误(带 code/data, + * 前缀 B2B_PREP_ / B2B_PICKUP_ / B2B_PLATE_ / B2B_IMAGE_)统一转 failure 400, + * 便于前端展示原因;其它异常继续抛出(由控制器转 500)。 + * + * @param {Object} data 请求体。 + * @param {string} serviceMethod 业务方法名。 + * @param {Function} buildParams 参数构造器。 + * @param {string} [actionText='备货作业'] 动作文案(用于批量拒绝提示)。 + * @return {Promise} 统一响应。 + */ + async runB2bSingleOrderAction(data = {}, serviceMethod, buildParams, actionText = '备货作业') { + const requestData = this.isPlainObject(data) ? data : {}; + const params = buildParams(requestData); + + if (params.orderIds.length === 0) { + return this.fail('订单ID不能为空', {}, 400); + } + if (params.orderIds.length > 1) { + return this.fail(`${actionText}仅支持单个订单,请单条提交`, { order_ids: params.orderIds }, 400); + } + + try { + const result = await this.service.systems.orderB2b[serviceMethod](params); + return this.success('ok', result); + } catch (error) { + const code = String(error && error.code || ''); + if (code.startsWith('B2B_PREP_') || code.startsWith('B2B_PACKING_') || code.startsWith('B2B_PICKUP_') + || code.startsWith('B2B_PLATE_') || code.startsWith('B2B_IMAGE_')) { + return this.fail(error.message, error.data || {}, 400); + } + throw error; + } + } + /** * 提交订单导出任务。 * diff --git a/app/service/systemMethods/order/pendingOrder.js b/app/service/systemMethods/order/pendingOrder.js index a0f1110..99f9462 100644 --- a/app/service/systemMethods/order/pendingOrder.js +++ b/app/service/systemMethods/order/pendingOrder.js @@ -1012,11 +1012,17 @@ class PendingOrderService extends OrderBaseService { const expresses = await this.getOrderExpressesByOrderId(orderId, order); + // B2B 订单附加副表作业明细(备货/提货/箱数/车牌)与备货/提货照片;非 B2B 订单 b2b=null、images=[]、pickup_images=[] + const { b2b, images, pickup_images: pickupImages } = await this.buildB2bDetailExtras(order, warehouseId); + return { detail: order, items: orderItemsWithPicking, expresses, storage_items: storageItems, + b2b, + images, + pickup_images: pickupImages, }; } @@ -1044,7 +1050,7 @@ class PendingOrderService extends OrderBaseService { try { const targetOrders = await model.findAll({ - attributes: [ 'id', 'wave_id', 'wave_no' ], + attributes: [ 'id', 'wave_id', 'wave_no', 'is_b2b' ], where, raw: true, ...dbQueryOptions, @@ -1054,6 +1060,9 @@ class PendingOrderService extends OrderBaseService { throw new Error('订单不存在或不属于当前仓库'); } + // B2B 订单走备货/提货作业链路,不支持反审回待审核:命中即整批驳回 + this.assertOrdersNotB2b(targetOrders, '反审回待审核'); + const targetOrderIds = targetOrders .map(order => Number(order && order.id || 0)) .filter(id => Number.isInteger(id) && id > 0); @@ -3754,6 +3763,9 @@ class PendingOrderService extends OrderBaseService { } const original = existingOrders[0]; + // B2B 订单走备货/提货作业链路,不支持克隆(克隆会取消原单并重建普通订单) + this.assertOrdersNotB2b([ original ], '克隆订单'); + if (!this.isCancelablePendingOrder(original)) { throw new Error('订单当前状态不允许克隆'); } diff --git a/app/service/systemMethods/order/pendingOrder2b.js b/app/service/systemMethods/order/pendingOrder2b.js index 865ba02..cbed985 100644 --- a/app/service/systemMethods/order/pendingOrder2b.js +++ b/app/service/systemMethods/order/pendingOrder2b.js @@ -36,6 +36,7 @@ class PendingOrder2bService extends OrderBaseService { const result = await this.listByModule('pendingOrder', data, { fixedWhere: B2B_FIXED_WHERE, b2bDetailFilter: true, + urgentFirst: true, }); return { ...result, diff --git a/app/service/systemMethods/order/recheckOrder.js b/app/service/systemMethods/order/recheckOrder.js index cdfd851..048a567 100644 --- a/app/service/systemMethods/order/recheckOrder.js +++ b/app/service/systemMethods/order/recheckOrder.js @@ -4394,7 +4394,7 @@ class RecheckOrderService extends OrderBaseService { attributes: [ 'id', 'delivery_order_code', 'pre_delivery_order_code', 'storage_status', 'post_status', 'sync_status', 'status', 'intercept_status', - 'pick_status', 'recheck_status', 'wave_id', 'wave_no', 'has_sn_item', + 'pick_status', 'recheck_status', 'wave_id', 'wave_no', 'has_sn_item', 'is_b2b', ], raw: true, }); @@ -4404,6 +4404,9 @@ class RecheckOrderService extends OrderBaseService { orderMap.set(Number(row.id), row); } + // B2B 订单走备货/提货作业链路,不参与批量发货(快捷复核):命中即整批驳回 + this.assertOrdersNotB2b(orderRows, '批量发货'); + // ── 2. 前置条件检查:将订单分为有效订单与跳过订单 ── const validOrders = []; const failedOrders = []; @@ -4572,11 +4575,14 @@ class RecheckOrderService extends OrderBaseService { attributes: [ 'id', 'delivery_order_code', 'pre_delivery_order_code', 'storage_status', 'post_status', 'sync_status', 'status', 'intercept_status', - 'pick_status', 'recheck_status', 'wave_id', 'wave_no', 'has_sn_item', + 'pick_status', 'recheck_status', 'wave_id', 'wave_no', 'has_sn_item', 'is_b2b', ], raw: true, }); + // 按波次批量发货同样对 B2B 订单无效:波次内命中 B2B 订单即整批驳回 + this.assertOrdersNotB2b(orderRows, '批量发货'); + // 按 wave_id 分组 const waveOrderMap = new Map(); for (const row of orderRows) { diff --git a/app/service/systemMethods/order/wave.js b/app/service/systemMethods/order/wave.js index 4819e67..75f76bf 100644 --- a/app/service/systemMethods/order/wave.js +++ b/app/service/systemMethods/order/wave.js @@ -8482,12 +8482,8 @@ class WaveService extends OrderBaseService { .map(row => Number(row && row.id || 0)) .filter(id => Number.isInteger(id) && id > 0)) ] .sort((a, b) => a - b); - // B2B 订单不参与波次抓取(NULL 视为非 B2B,兼容存量行) - const excludedB2bOrderIds = [ ...new Set(normalizedOrderRows - .filter(row => String(row && row.is_b2b || '').trim() === 'Y') - .map(row => Number(row && row.id || 0)) - .filter(id => Number.isInteger(id) && id > 0)) ] - .sort((a, b) => a - b); + // B2B 订单走备货/提货作业链路,不参与波次抓取:命中即整批驳回(不做部分抓取) + this.assertOrdersNotB2b(normalizedOrderRows, '抓取散单'); // SN(序列号管理)订单允许按订单ID显式抓取散单:SN 策略只是「不自动出现在散单策略候选」, // 手工按订单抓取时不受限(manual_ids 波次在拣货侧固定走先拣后分 pick_mode=3,与 SN 策略一致), // 因此这里不再排除 SN 订单,excluded_sn_order_ids 保留在响应中但恒为空数组。 @@ -8515,11 +8511,6 @@ class WaveService extends OrderBaseService { return false; } - // B2B 订单不允许抓取波次 - if (String(row && row.is_b2b || '').trim() === 'Y') { - return false; - } - return true; }); @@ -8541,7 +8532,6 @@ class WaveService extends OrderBaseService { excluded_existing_wave_order_ids: excludedExistingWaveOrderIds, excluded_intercepted_order_ids: excludedInterceptedOrderIds, excluded_locked_order_ids: excludedLockedOrderIds, - excluded_b2b_order_ids: excludedB2bOrderIds, excluded_sn_order_ids: excludedSnOrderIds, skipped_order_ids: skippedOrderIds, not_found_order_ids: notFoundOrderIds, @@ -8662,7 +8652,6 @@ class WaveService extends OrderBaseService { excluded_existing_wave_order_ids: excludedExistingWaveOrderIds, excluded_intercepted_order_ids: excludedInterceptedOrderIds, excluded_locked_order_ids: excludedLockedOrderIds, - excluded_b2b_order_ids: excludedB2bOrderIds, excluded_sn_order_ids: excludedSnOrderIds, skipped_order_ids: skippedOrderIds, not_found_order_ids: notFoundOrderIds, diff --git a/app/service/systems/order_b2b.js b/app/service/systems/order_b2b.js index 935f7ec..dcfdd54 100644 --- a/app/service/systems/order_b2b.js +++ b/app/service/systems/order_b2b.js @@ -2,13 +2,181 @@ const Service = require('egg').Service; +const { isInterceptedOrderStatus } = require('../../lib/intercept_guard'); +const { FILE_BUSINESS_TYPE } = require('../../lib/file_business_types'); + /** 订单转 B2B 操作码 */ const ORDER_B2B_CONVERT_OPERATION_CODE = 'ORDER_B2B_CONVERT'; /** 取消 B2B(流转回正常订单)操作码 */ const ORDER_B2B_CANCEL_OPERATION_CODE = 'ORDER_B2B_CANCEL'; +/** 设置 B2B 加急操作码 */ +const ORDER_B2B_SET_URGENT_OPERATION_CODE = 'ORDER_B2B_SET_URGENT'; +/** 备货开始 / 取消备货 / 备货完成操作码 */ +const ORDER_B2B_PREP_START_OPERATION_CODE = 'ORDER_B2B_PREP_START'; +const ORDER_B2B_PREP_CANCEL_OPERATION_CODE = 'ORDER_B2B_PREP_CANCEL'; +const ORDER_B2B_PREP_FINISH_OPERATION_CODE = 'ORDER_B2B_PREP_FINISH'; +const ORDER_B2B_PACKING_ITEMS_OPERATION_CODE = 'ORDER_B2B_PACKING_ITEMS'; +/** B2B 提货操作码 */ +const ORDER_B2B_PICKUP_OPERATION_CODE = 'ORDER_B2B_PICKUP'; +/** B2B 提货车牌录入/修改操作码 */ +const ORDER_B2B_PICKUP_PLATE_OPERATION_CODE = 'ORDER_B2B_PICKUP_PLATE'; +/** B2B 订单图片更新操作码 */ +const ORDER_B2B_IMAGES_OPERATION_CODE = 'ORDER_B2B_IMAGES'; /** 单次转换订单数上限 */ const ORDER_B2B_CONVERT_BATCH_LIMIT = 200; +/** 备货状态 */ +const B2B_PREP_STATUS = Object.freeze({ + NONE: 'none', + PADDING: 'padding', + FIN: 'fin', +}); + +/** 备货作业校验错误码(方法层据此返回 failure 400) */ +const B2B_PREP_ERROR_CODE = Object.freeze({ + INPUT_INVALID: 'B2B_PREP_INPUT_INVALID', + OPERATOR_REQUIRED: 'B2B_PREP_OPERATOR_REQUIRED', + NOT_B2B: 'B2B_PREP_NOT_B2B', + OPERATOR_MISMATCH: 'B2B_PREP_OPERATOR_MISMATCH', + STATUS_INVALID: 'B2B_PREP_STATUS_INVALID', + NOT_STARTED: 'B2B_PREP_NOT_STARTED', + NOT_FOUND: 'B2B_PREP_ORDER_NOT_FOUND', + NOT_READY: 'B2B_PREP_NOT_READY', + PACKING_INCOMPLETE: 'B2B_PREP_PACKING_INCOMPLETE', +}); + +/** B2B 分箱明细接口校验错误码。 */ +const B2B_PACKING_ERROR_CODE = Object.freeze({ + INPUT_INVALID: 'B2B_PACKING_INPUT_INVALID', + NOT_B2B: 'B2B_PACKING_NOT_B2B', + NOT_FOUND: 'B2B_PACKING_ORDER_NOT_FOUND', + STATUS_INVALID: 'B2B_PACKING_STATUS_INVALID', +}); + +/** 提货校验错误码(方法层据此返回 failure 400) */ +const B2B_PICKUP_ERROR_CODE = Object.freeze({ + INPUT_INVALID: 'B2B_PICKUP_INPUT_INVALID', + NOT_B2B: 'B2B_PICKUP_NOT_B2B', + STATUS_INVALID: 'B2B_PICKUP_STATUS_INVALID', + NOT_FOUND: 'B2B_PICKUP_ORDER_NOT_FOUND', +}); + +/** 提货车牌校验错误码(方法层据此返回 failure 400) */ +const B2B_PLATE_ERROR_CODE = Object.freeze({ + INPUT_INVALID: 'B2B_PLATE_INPUT_INVALID', + NOT_B2B: 'B2B_PLATE_NOT_B2B', + STATUS_INVALID: 'B2B_PLATE_STATUS_INVALID', + NOT_FOUND: 'B2B_PLATE_ORDER_NOT_FOUND', +}); + +/** 提货车牌最大长度(与 wms_order_b2b.pickup_plate_number 字段长度一致) */ +const B2B_PICKUP_PLATE_MAX_LENGTH = 20; + +/** + * 提货车牌基础格式:首字符为汉字省份简称或字母(军/使/领/港澳等特殊牌照), + * 其余为汉字、字母或数字,整体 5~10 位;仅拦截明显无效输入(如纯数字、过短、超长)。 + */ +const B2B_PICKUP_PLATE_PATTERN = /^[\u4e00-\u9fa5A-Z][\u4e00-\u9fa5A-Z0-9]{4,9}$/; + +/** 订单图片校验错误码(方法层据此返回 failure 400) */ +const B2B_IMAGE_ERROR_CODE = Object.freeze({ + INPUT_INVALID: 'B2B_IMAGE_INPUT_INVALID', + NOT_B2B: 'B2B_IMAGE_NOT_B2B', + STATUS_INVALID: 'B2B_IMAGE_STATUS_INVALID', + NOT_FOUND: 'B2B_IMAGE_ORDER_NOT_FOUND', + FILE_INVALID: 'B2B_IMAGE_FILE_INVALID', +}); + +/** 单订单图片数量上限 */ +const B2B_ORDER_IMAGE_MAX = 20; + +/** B2B 订单图片业务类型:备货留证照片 */ +const B2B_PREP_IMAGE_BUSINESS_TYPE = FILE_BUSINESS_TYPE.B2B_ORDER; +/** B2B 订单图片业务类型:提货留证照片(与备货照片分开存放) */ +const B2B_PICKUP_IMAGE_BUSINESS_TYPE = FILE_BUSINESS_TYPE.B2B_PICKUP; + +/** 提货即出库完成:主表写入的出库状态与步骤(与 order.markOutboundOrder 口径一致) */ +const B2B_OUTBOUND_STATUS_FIN = 'fin'; +const B2B_OUTBOUND_STEP = 4; + +/** + * 构造带错误码与明细的 B2B 作业错误(备货/提货/图片等共用)。 + * @param {string} code 错误码。 + * @param {string} message 错误信息。 + * @param {Object} [data={}] 附加数据。 + * @return {Error} 错误对象。 + */ +function buildB2bError(code, message, data = {}) { + const error = new Error(message); + error.code = code; + error.data = data; + return error; +} + +/** + * 构造带错误码与明细的备货作业错误。 + * @param {string} code 错误码。 + * @param {string} message 错误信息。 + * @param {Object} [data={}] 附加数据。 + * @return {Error} 错误对象。 + */ +function buildPrepError(code, message, data = {}) { + return buildB2bError(code, message, data); +} + +/** + * 归一化操作人工号ID(工号,非用户主键)。 + * @param {Object|null} operator 操作人 { id, name }。 + * @param {string} actionText 动作文案(用于报错)。 + * @return {{ id: number, name: string|null }} 归一化后的操作人。 + */ +function resolvePrepOperator(operator, actionText) { + const rawId = operator && operator.id; + const operatorId = Number(rawId); + + if (!Number.isInteger(operatorId) || operatorId <= 0) { + throw buildPrepError( + B2B_PREP_ERROR_CODE.OPERATOR_REQUIRED, + `未识别到操作人工号,无法${actionText}` + ); + } + + return { + id: operatorId, + name: String(operator && operator.name || '').trim() || null, + }; +} + +/** + * 归一化"是否加急"入参,兼容 Y/N、true/false、1/0、是/否。 + * @param {*} value 原始取值。 + * @param {string} [defaultValue='Y'] 缺省值。 + * @return {string} 'Y' 或 'N'。 + */ +function normalizeUrgentFlag(value, defaultValue = 'Y') { + if (value === undefined || value === null || value === '') { + return defaultValue; + } + + if (value === true || value === 1) { + return 'Y'; + } + + if (value === false || value === 0) { + return 'N'; + } + + const normalized = String(value).trim().toUpperCase(); + if ([ 'Y', 'YES', 'TRUE', '1', '是' ].includes(normalized)) { + return 'Y'; + } + if ([ 'N', 'NO', 'FALSE', '0', '否' ].includes(normalized)) { + return 'N'; + } + + throw new Error('is_urgent 参数不合法,仅支持 Y/N(或 true/false、1/0)'); +} + /** * 允许转 B2B 的订单步骤白名单。 * @@ -88,7 +256,7 @@ class OrderB2bService extends Service { 'id', 'delivery_order_code', 'step', 'status', 'pick_status', 'recheck_status', 'print_status', 'lock_status', 'intercept_status', 'is_b2b', - 'wave_id', 'wave_no', + 'is_urgency', 'wave_id', 'wave_no', ], where: { id: { [Op.in]: normalizedOrderIds }, @@ -185,6 +353,8 @@ class OrderB2bService extends Service { warehouse_id: normalizedWarehouseId, order_id: orderId, }; + // 加急标记以订单表 is_urgency 作为初始值(Y 才视为加急,其余按普通) + const urgentFlag = String(row.is_urgency || '').trim().toUpperCase() === 'Y' ? 'Y' : 'N'; const existing = await b2bModel.findOne({ where: { warehouse_id: normalizedWarehouseId, @@ -199,6 +369,7 @@ class OrderB2bService extends Service { prep_remark: null, prep_duration_seconds: 0, prep_at: null, + is_urgent: urgentFlag, is_picked_up: 'N', picked_up_at: null, ...baseFields, @@ -206,6 +377,7 @@ class OrderB2bService extends Service { } else { await b2bModel.create({ ...baseFields, + is_urgent: urgentFlag, created_at: now, }, { transaction }); } @@ -520,6 +692,2238 @@ class OrderB2bService extends Service { return ''; } + + /** + * 批量设置 B2B 订单是否加急。 + * + * 仅对 B2B 订单(is_b2b='Y')生效:非 B2B 订单跳过并返回原因。 + * 订单先在 current 分表查找,未命中的再到 dispatch 分表兜底(配送域 B2B 订单); + * 两表都查不到计入 not_found。事务内按 warehouse_id + order_id 更新 + * wms_order_b2b.is_urgent(作业明细行缺失时补建),提交后写操作日志。 + * + * @param {Object} params 设置参数。 + * @param {number|string} params.warehouseId 仓库ID。 + * @param {Array} params.orderIds 订单ID数组。 + * @param {string|boolean|number} [params.isUrgent='Y'] 是否加急,兼容 Y/N、true/false、1/0。 + * @param {Object|null} [params.operator=null] 操作人 { id, name }。 + * @return {Promise} { is_urgent, updated_order_ids, updated_count, + * skipped_order_ids, skipped_count, skipped_reasons, not_found_order_ids } + */ + async setOrdersB2bUrgent(params = {}) { + const { ctx, app } = this; + const normalizedWarehouseId = Number(params && params.warehouseId || 0); + if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) { + throw new Error('未识别到当前仓库上下文'); + } + + const rawIds = params && params.orderIds; + const normalizedOrderIds = [ ...new Set( + (Array.isArray(rawIds) ? rawIds : [ rawIds ]) + .map(item => Number(item)) + .filter(item => Number.isInteger(item) && item > 0) + ) ]; + if (normalizedOrderIds.length === 0) { + throw new Error('订单ID不能为空'); + } + if (normalizedOrderIds.length > ORDER_B2B_CONVERT_BATCH_LIMIT) { + throw new Error(`单次最多设置 ${ORDER_B2B_CONVERT_BATCH_LIMIT} 个订单`); + } + + const isUrgent = normalizeUrgentFlag(params && params.isUrgent); + const operator = params && params.operator && typeof params.operator === 'object' + ? params.operator + : null; + const { Op } = app.Sequelize; + const factory = ctx.model.OrderDeliveryFactory; + const currentModel = await factory.getCurrentModel(normalizedWarehouseId); + + const ATTRIBUTES = [ 'id', 'delivery_order_code', 'step', 'status', 'is_b2b' ]; + const transaction = await ctx.model.transaction(); + const updatedRows = []; + const skippedReasons = []; + let notFoundOrderIds = []; + + try { + const currentRows = await currentModel.findAll({ + attributes: ATTRIBUTES, + where: { + id: { [Op.in]: normalizedOrderIds }, + warehouse_id: normalizedWarehouseId, + }, + raw: true, + transaction, + lock: transaction.LOCK.UPDATE, + }); + + const rowMap = new Map((Array.isArray(currentRows) ? currentRows : []) + .map(row => [ Number(row && row.id || 0), row ])); + + // 未在待处理表命中的订单,兜底到配送域分表(配送域 B2B 订单) + const missingIds = normalizedOrderIds.filter(orderId => !rowMap.has(orderId)); + if (missingIds.length > 0) { + const dispatchModel = await factory.getDispatchModel(normalizedWarehouseId); + const dispatchRows = await dispatchModel.findAll({ + attributes: ATTRIBUTES, + where: { + id: { [Op.in]: missingIds }, + warehouse_id: normalizedWarehouseId, + }, + raw: true, + transaction, + lock: transaction.LOCK.UPDATE, + }); + for (const row of (Array.isArray(dispatchRows) ? dispatchRows : [])) { + rowMap.set(Number(row && row.id || 0), row); + } + } + + notFoundOrderIds = normalizedOrderIds.filter(orderId => !rowMap.has(orderId)); + + for (const orderId of normalizedOrderIds) { + const row = rowMap.get(orderId); + if (!row) { + continue; + } + + const skipReason = this.resolveSetUrgentSkipReason(row); + if (skipReason) { + skippedReasons.push({ + order_id: orderId, + delivery_order_code: String(row.delivery_order_code || '').trim(), + reason: skipReason, + }); + continue; + } + + updatedRows.push(row); + } + + if (updatedRows.length > 0) { + const now = new Date(); + const b2bModel = ctx.model.OrderB2b; + for (const row of updatedRows) { + const orderId = Number(row.id); + const existing = await b2bModel.findOne({ + where: { + warehouse_id: normalizedWarehouseId, + order_id: orderId, + }, + transaction, + }); + if (existing) { + await existing.update({ is_urgent: isUrgent }, { transaction }); + } else { + // 兜底:B2B 订单缺少作业明细行时补建,其余作业字段取默认值 + await b2bModel.create({ + warehouse_id: normalizedWarehouseId, + order_id: orderId, + is_urgent: isUrgent, + created_at: now, + }, { transaction }); + } + } + } + + await transaction.commit(); + } catch (error) { + await transaction.rollback(); + throw error; + } + + // 操作日志在事务提交后写入,失败不影响主流程 + const changeSummary = isUrgent === 'Y' ? '设置B2B订单加急' : '取消B2B订单加急'; + for (const row of updatedRows) { + try { + await ctx.service.systems.operationLog.createOperationLog({ + businessType: 'order', + businessId: Number(row.id), + operationCode: ORDER_B2B_SET_URGENT_OPERATION_CODE, + operationAction: 'UPDATE', + changeSummary, + operator, + extras: { + warehouseId: normalizedWarehouseId, + orderId: Number(row.id), + orderNo: String(row.delivery_order_code || '').trim(), + isUrgent, + message: changeSummary, + }, + beforeChanges: null, + }); + } catch (error) { + ctx.logger.warn(`[orderB2b.setOrdersB2bUrgent] 写入操作日志失败,不影响业务, orderId=${row.id}, error=${error.message}`); + } + } + + const skippedOrderIds = [ ...new Set(skippedReasons.map(item => item.order_id)) ]; + return { + is_urgent: isUrgent, + updated_order_ids: [ ...new Set(updatedRows.map(row => Number(row.id))) ], + updated_count: updatedRows.length, + skipped_order_ids: skippedOrderIds, + skipped_count: skippedOrderIds.length, + skipped_reasons: skippedReasons, + not_found_order_ids: notFoundOrderIds, + }; + } + + /** + * 判断订单是否允许设置/取消 B2B 加急,返回跳过原因;可设置时返回空串。 + * + * 条件:是 B2B 订单(is_b2b = Y)、非已取消(status != cancel)。 + * 待处理表与配送域分表口径一致,拣货/复核/打印/锁定/拦截不影响加急标记。 + * + * @param {Object} row 订单行。 + * @return {string} 跳过原因,可设置返回空字符串。 + */ + resolveSetUrgentSkipReason(row = {}) { + if (String(row && row.is_b2b || '').trim() !== 'Y') { + return '订单不是B2B订单'; + } + + if (String(row && row.status || '').trim() === 'cancel') { + return '订单已取消,不允许设置加急'; + } + + return ''; + } + + /** + * 载入备货作业目标订单与对应作业明细行。 + * + * 订单先在 current 分表加锁查询,未命中的兜底到 dispatch 分表; + * 作业明细按 warehouse_id + order_id 读取(同样加锁)。 + * + * 同时返回 modelMap(订单ID → 该订单所在的物理模型),供提货时回写出库状态时 + * 精确更新订单所在表(current 或 dispatch),避免只更新 current 导致配送域订单漏写。 + * + * @param {Object} params 参数。 + * @param {number} params.warehouseId 仓库ID。 + * @param {number[]} params.orderIds 订单ID数组(单订单)。 + * @param {Object} params.transaction 事务对象。 + * @return {Promise<{ rowMap: Map, b2bMap: Map, modelMap: Map, sourceTypeMap: Map }>} 订单行、作业明细行与分表映射。 + */ + async loadPrepTargets({ warehouseId, orderIds, transaction }) { + const { ctx, app } = this; + const { Op } = app.Sequelize; + const factory = ctx.model.OrderDeliveryFactory; + const ATTRIBUTES = [ + 'id', 'delivery_order_code', 'status', 'is_b2b', + 'print_status', 'storage_status', 'intercept_status', + 'outbound_status', 'step', 'delivery_time', + ]; + const rowMap = new Map(); + const modelMap = new Map(); + const sourceTypeMap = new Map(); + + const currentModel = await factory.getCurrentModel(warehouseId); + const currentRows = await currentModel.findAll({ + attributes: ATTRIBUTES, + where: { + id: { [Op.in]: orderIds }, + warehouse_id: warehouseId, + }, + raw: true, + transaction, + lock: transaction.LOCK.UPDATE, + }); + for (const row of (Array.isArray(currentRows) ? currentRows : [])) { + const orderId = Number(row && row.id || 0); + rowMap.set(orderId, row); + modelMap.set(orderId, currentModel); + sourceTypeMap.set(orderId, 'current'); + } + + const missingIds = orderIds.filter(orderId => !rowMap.has(orderId)); + if (missingIds.length > 0) { + const dispatchModel = await factory.getDispatchModel(warehouseId); + const dispatchRows = await dispatchModel.findAll({ + attributes: ATTRIBUTES, + where: { + id: { [Op.in]: missingIds }, + warehouse_id: warehouseId, + }, + raw: true, + transaction, + lock: transaction.LOCK.UPDATE, + }); + for (const row of (Array.isArray(dispatchRows) ? dispatchRows : [])) { + const orderId = Number(row && row.id || 0); + rowMap.set(orderId, row); + modelMap.set(orderId, dispatchModel); + sourceTypeMap.set(orderId, 'dispatch'); + } + } + + const b2bRows = await ctx.model.OrderB2b.findAll({ + where: { + warehouse_id: warehouseId, + order_id: { [Op.in]: orderIds }, + }, + attributes: [ + 'id', 'order_id', 'prep_status', 'prep_operator_id', 'prep_operator_name', + 'prep_start_at', 'prep_at', 'prep_duration_seconds', 'is_picked_up', 'picked_up_at', + 'pickup_plate_number', 'created_at', + ], + raw: true, + transaction, + lock: transaction.LOCK.UPDATE, + }); + const b2bMap = new Map((Array.isArray(b2bRows) ? b2bRows : []) + .map(row => [ Number(row && row.order_id || 0), row ])); + + return { rowMap, b2bMap, modelMap, sourceTypeMap }; + } + + /** + * 读取订单所在分表的商品明细。 + * @param {Object} params 参数。 + * @param {number} params.warehouseId 仓库ID。 + * @param {number} params.orderId 订单ID。 + * @param {string} params.sourceType 分表类型。 + * @param {Object} params.transaction 事务对象。 + * @param {boolean} [params.lock=false] 是否加行锁。 + * @return {Promise>} 订单商品明细行。 + */ + async loadB2bOrderItems({ warehouseId, orderId, sourceType, transaction, lock = false }) { + const { ctx } = this; + const factory = ctx.model && ctx.model.OrderItemsFactory; + if (!factory) { + throw new Error('订单商品明细模型不可用'); + } + + const model = sourceType === 'dispatch' + ? await factory.getDispatchModel(warehouseId) + : await factory.getCurrentModel(warehouseId); + const options = { + where: { order_id: orderId }, + attributes: [ 'id', 'order_id', 'item_id', 'item_code', 'item_name', 'plan_qty', 'stock_id', 'item_snapshot' ], + order: [[ 'id', 'ASC' ]], + raw: true, + transaction, + }; + if (lock && transaction && transaction.LOCK) { + options.lock = transaction.LOCK.UPDATE; + } + return await model.findAll(options); + } + + /** + * 查询订单的取货储位(数据源 wms_picking,订单储位分配结果)。 + * + * 备货时按商品明细逐行告知去哪个库位取货;同一商品在同一储位的多条分配记录 + * 合并为一条(数量相加),按库位名称升序输出。排除 status=cancel(已取消的分配)。 + * + * @param {Object} params 参数。 + * @param {number} params.warehouseId 仓库ID。 + * @param {number} params.orderId 订单ID。 + * @param {Object} [params.transaction] 事务对象。 + * @return {Promise>>} order_item_id → [{ space_id, space_name, quantity }]。 + */ + async loadB2bPickLocationsByItem({ warehouseId, orderId, transaction }) { + const { ctx, app } = this; + const { Op } = app.Sequelize; + const result = new Map(); + if (!ctx.model.Picking) { + return result; + } + + const pickingRows = await ctx.model.Picking.findAll({ + where: { + warehouse_id: warehouseId, + order_id: orderId, + status: { [Op.ne]: 'cancel' }, + }, + attributes: [ 'order_item_id', 'space_id', 'space_name', 'quantity' ], + raw: true, + transaction, + }); + + const itemSpaces = new Map(); + for (const row of (Array.isArray(pickingRows) ? pickingRows : [])) { + const orderItemId = Number(row.order_item_id); + if (!Number.isInteger(orderItemId) || orderItemId <= 0) { + continue; + } + const spaceId = Number(row.space_id) || 0; + const spaceName = String(row.space_name || '').trim(); + const spaceKey = spaceId > 0 ? `id:${spaceId}` : `name:${spaceName}`; + + if (!itemSpaces.has(orderItemId)) { + itemSpaces.set(orderItemId, new Map()); + } + const spaces = itemSpaces.get(orderItemId); + if (!spaces.has(spaceKey)) { + spaces.set(spaceKey, { + space_id: spaceId > 0 ? spaceId : null, + space_name: spaceName || null, + quantity: 0, + }); + } + spaces.get(spaceKey).quantity += Number(row.quantity || 0); + } + + for (const [ orderItemId, spaces ] of itemSpaces.entries()) { + result.set(orderItemId, [ ...spaces.values() ] + .sort((left, right) => String(left.space_name || '') + .localeCompare(String(right.space_name || '')))); + } + return result; + } + + /** + * 查询仓库是否开启 B2B 分箱齐套校验。 + * @param {number} warehouseId 仓库ID。 + * @return {Promise} 是否开启。 + */ + async isB2bPackingQuantityCheckEnabled(warehouseId) { + const service = this.ctx.service && this.ctx.service.systems + && this.ctx.service.systems.deliveryOrder; + if (!service || typeof service.getStoreSubjectConfig !== 'function') { + return false; + } + const config = await service.getStoreSubjectConfig(warehouseId); + return !!(config && config.b2b_packing_quantity_check === true); + } + + /** + * 校验分箱数量逐订单商品齐套。 + * @param {Object} params 参数。 + * @param {number} params.warehouseId 仓库ID。 + * @param {number} params.orderId 订单ID。 + * @param {string} params.sourceType 分表类型。 + * @param {number} params.totalBoxCount 总箱数。 + * @param {Object} params.transaction 事务对象。 + * @return {Promise<{ boxCount: number }>} 箱数。 + */ + async assertB2bPackingQuantityComplete({ warehouseId, orderId, sourceType, totalBoxCount, transaction }) { + const { ctx } = this; + const orderItems = await this.loadB2bOrderItems({ + warehouseId, + orderId, + sourceType, + transaction, + lock: true, + }); + const packedItems = await ctx.model.OrderB2bItem.findAll({ + where: { warehouse_id: warehouseId, order_id: orderId }, + attributes: [ 'order_item_id', 'box_no', 'quantity' ], + order: [[ 'id', 'ASC' ]], + raw: true, + transaction, + lock: transaction.LOCK.UPDATE, + }); + const packedByItemId = new Map(); + const boxNumbers = new Set(); + + for (const packedItem of packedItems) { + const itemId = Number(packedItem.order_item_id); + const quantity = Number(packedItem.quantity); + packedByItemId.set(itemId, (packedByItemId.get(itemId) || 0) + quantity); + boxNumbers.add(String(packedItem.box_no)); + } + + const mismatches = []; + if (orderItems.length === 0) { + mismatches.push({ + order_item_id: null, + item_code: '', + item_name: '订单商品明细不存在', + expected_quantity: null, + packed_quantity: [ ...packedByItemId.values() ].reduce((sum, quantity) => sum + quantity, 0), + }); + } + const orderItemIds = new Set(); + for (const item of orderItems) { + const itemId = Number(item.id); + const expectedQuantity = Number(item.plan_qty); + const packedQuantity = Number(packedByItemId.get(itemId) || 0); + orderItemIds.add(itemId); + if (!Number.isInteger(expectedQuantity) || expectedQuantity < 0 || packedQuantity !== expectedQuantity) { + mismatches.push({ + order_item_id: itemId, + item_code: item.item_code || '', + item_name: item.item_name || '', + expected_quantity: Number.isInteger(expectedQuantity) ? expectedQuantity : null, + packed_quantity: packedQuantity, + }); + } + } + + for (const [ itemId, packedQuantity ] of packedByItemId) { + if (!orderItemIds.has(itemId)) { + mismatches.push({ + order_item_id: itemId, + item_code: '', + item_name: '订单商品明细不存在', + expected_quantity: 0, + packed_quantity: packedQuantity, + }); + } + } + + const boxCount = boxNumbers.size; + if (mismatches.length > 0 || boxCount !== Number(totalBoxCount)) { + throw buildPrepError( + B2B_PREP_ERROR_CODE.PACKING_INCOMPLETE, + mismatches.length > 0 + ? '分箱数量与订单商品应拣数量不一致,不能完成备货' + : `总箱数(${totalBoxCount})与分箱箱号数(${boxCount})不一致,不能完成备货`, + { + order_id: orderId, + item_mismatches: mismatches, + total_box_count: Number(totalBoxCount), + packed_box_count: boxCount, + } + ); + } + + return { boxCount }; + } + + /** + * 更新单个 B2B 订单的完整分箱明细(全量替换)。 + * @param {Object} params 参数。 + * @return {Promise} 更新结果。 + */ + async updateB2bPackingItems(params = {}) { + const { ctx } = this; + const warehouseId = Number(params.warehouseId || 0); + if (!Number.isInteger(warehouseId) || warehouseId <= 0) { + throw new Error('未识别到当前仓库上下文'); + } + const [ orderId ] = this.normalizeB2bOrderIds(params.orderIds, { + inputCode: B2B_PACKING_ERROR_CODE.INPUT_INVALID, + actionText: '更新分箱明细', + }); + const inputItems = params.items; + if (!Array.isArray(inputItems) || inputItems.length > 10000) { + throw buildB2bError(B2B_PACKING_ERROR_CODE.INPUT_INVALID, 'items 必须是最多 10000 条的数组'); + } + + const normalizedItems = []; + const uniqueItemBoxKeys = new Set(); + for (const item of inputItems) { + const orderItemId = Number(item && (item.order_item_id !== undefined ? item.order_item_id : item.orderItemId)); + const boxNo = String(item && (item.box_no !== undefined ? item.box_no : item.boxNo) || '').trim(); + const quantity = Number(item && item.quantity); + if (!Number.isSafeInteger(orderItemId) || orderItemId <= 0 + || !boxNo || boxNo.length > 50 + || !Number.isSafeInteger(quantity) || quantity <= 0) { + throw buildB2bError( + B2B_PACKING_ERROR_CODE.INPUT_INVALID, + '每条分箱明细必须包含有效 order_item_id、长度不超过 50 的箱号和正整数 quantity' + ); + } + const key = `${orderItemId}\u0000${boxNo.toUpperCase()}`; + if (uniqueItemBoxKeys.has(key)) { + throw buildB2bError(B2B_PACKING_ERROR_CODE.INPUT_INVALID, '同一商品明细与箱号不能重复'); + } + uniqueItemBoxKeys.add(key); + normalizedItems.push({ order_item_id: orderItemId, box_no: boxNo, quantity }); + } + + const transaction = await ctx.model.transaction(); + let boxCount = 0; + try { + const { rowMap, b2bMap, sourceTypeMap } = await this.loadPrepTargets({ + warehouseId, + orderIds: [ orderId ], + transaction, + }); + this.assertPrepOrders({ orderIds: [ orderId ], rowMap, actionText: '更新分箱明细' }); + const order = rowMap.get(orderId); + if (String(order.status || '').trim() === 'cancel') { + throw buildB2bError(B2B_PACKING_ERROR_CODE.STATUS_INVALID, '已取消订单不能更新分箱明细'); + } + const b2bDetail = b2bMap.get(orderId); + if (!b2bDetail || String(b2bDetail.prep_status || '').trim() !== B2B_PREP_STATUS.PADDING) { + throw buildB2bError(B2B_PACKING_ERROR_CODE.STATUS_INVALID, '订单未处于备货中,不能更新分箱明细'); + } + + const orderItems = await this.loadB2bOrderItems({ + warehouseId, + orderId, + sourceType: sourceTypeMap.get(orderId), + transaction, + lock: true, + }); + const validItemIds = new Set(orderItems.map(item => Number(item.id))); + const invalidItemIds = [ ...new Set(normalizedItems + .map(item => item.order_item_id) + .filter(itemId => !validItemIds.has(itemId))) ]; + if (invalidItemIds.length > 0) { + throw buildB2bError( + B2B_PACKING_ERROR_CODE.INPUT_INVALID, + '分箱明细包含不属于当前订单的商品行', + { invalid_order_item_ids: invalidItemIds } + ); + } + + const packingModel = ctx.model.OrderB2bItem; + await packingModel.destroy({ + where: { warehouse_id: warehouseId, order_id: orderId }, + transaction, + }); + if (normalizedItems.length > 0) { + const now = new Date(); + await packingModel.bulkCreate(normalizedItems.map(item => ({ + ...item, + warehouse_id: warehouseId, + order_id: orderId, + created_at: now, + updated_at: now, + })), { transaction }); + } + boxCount = new Set(normalizedItems.map(item => item.box_no)).size; + await ctx.model.OrderB2b.update({ + total_box_count: boxCount, + }, { + where: { warehouse_id: warehouseId, order_id: orderId }, + transaction, + }); + await transaction.commit(); + } catch (error) { + await transaction.rollback(); + throw error; + } + + await this.writePrepOperationLogs([ orderId ], { + warehouseId, + operator: params.operator, + operationCode: ORDER_B2B_PACKING_ITEMS_OPERATION_CODE, + message: `更新分箱明细(${normalizedItems.length} 条,${boxCount} 箱)`, + extras: { order_id: orderId, item_count: normalizedItems.length, box_count: boxCount }, + scene: 'updateB2bPackingItems', + }); + + return { + order_id: orderId, + item_count: normalizedItems.length, + box_count: boxCount, + }; + } + + /** + * 获取 B2B 订单头、商品应拣数量、分箱明细与取货储位快照。 + * @param {Object} params 参数。 + * @return {Promise} 订单快照。 + */ + async getB2bPackingSnapshot(params = {}) { + const { ctx } = this; + const warehouseId = Number(params.warehouseId || 0); + if (!Number.isInteger(warehouseId) || warehouseId <= 0) { + throw new Error('未识别到当前仓库上下文'); + } + const [ orderId ] = this.normalizeB2bOrderIds(params.orderIds, { + inputCode: B2B_PACKING_ERROR_CODE.INPUT_INVALID, + actionText: '查询分箱快照', + }); + const requirePackingQuantityMatch = await this.isB2bPackingQuantityCheckEnabled(warehouseId); + const transaction = await ctx.model.transaction(); + + try { + const factory = ctx.model.OrderDeliveryFactory; + const currentModel = await factory.getCurrentModel(warehouseId); + let order = await currentModel.findOne({ + where: { id: orderId, warehouse_id: warehouseId }, + raw: true, + transaction, + }); + let sourceType = 'current'; + if (!order) { + const dispatchModel = await factory.getDispatchModel(warehouseId); + order = await dispatchModel.findOne({ + where: { id: orderId, warehouse_id: warehouseId }, + raw: true, + transaction, + }); + sourceType = 'dispatch'; + } + if (!order) { + throw buildB2bError(B2B_PACKING_ERROR_CODE.NOT_FOUND, '订单不存在或不属于当前仓库', { + not_found_order_ids: [ orderId ], + }); + } + if (String(order.is_b2b || '').trim() !== 'Y') { + throw buildB2bError(B2B_PACKING_ERROR_CODE.NOT_B2B, '仅 B2B 订单支持查询分箱快照'); + } + + const orderItems = await this.loadB2bOrderItems({ + warehouseId, + orderId, + sourceType, + transaction, + }); + const packedItems = await ctx.model.OrderB2bItem.findAll({ + where: { warehouse_id: warehouseId, order_id: orderId }, + attributes: [ 'order_item_id', 'box_no', 'quantity' ], + order: [[ 'box_no', 'ASC' ], [ 'order_item_id', 'ASC' ]], + raw: true, + transaction, + }); + const b2b = await ctx.model.OrderB2b.findOne({ + where: { warehouse_id: warehouseId, order_id: orderId }, + raw: true, + transaction, + }); + const pickLocationMap = await this.loadB2bPickLocationsByItem({ + warehouseId, + orderId, + transaction, + }); + const pickLocationSpaceKeys = new Set(); + for (const locations of pickLocationMap.values()) { + for (const location of locations) { + pickLocationSpaceKeys.add(location.space_id ? `id:${location.space_id}` : `name:${location.space_name}`); + } + } + const packedByItemId = new Map(); + for (const packedItem of packedItems) { + const itemId = Number(packedItem.order_item_id); + if (!packedByItemId.has(itemId)) packedByItemId.set(itemId, []); + packedByItemId.get(itemId).push({ + box_no: packedItem.box_no, + quantity: Number(packedItem.quantity), + }); + } + const items = orderItems.map(item => { + const boxes = packedByItemId.get(Number(item.id)) || []; + return { + order_item_id: Number(item.id), + item_id: item.item_id, + stock_id: item.stock_id, + item_code: item.item_code, + item_name: item.item_name, + item_snapshot: item.item_snapshot, + plan_qty: item.plan_qty === null || item.plan_qty === undefined ? null : Number(item.plan_qty), + packed_quantity: boxes.reduce((sum, box) => sum + box.quantity, 0), + boxes, + pick_locations: pickLocationMap.get(Number(item.id)) || [], + }; + }); + + await transaction.commit(); + return { + order_id: orderId, + delivery_order_code: order.delivery_order_code || '', + status: order.status, + prep_status: b2b && b2b.prep_status || B2B_PREP_STATUS.NONE, + total_box_count: Number(b2b && b2b.total_box_count || 0), + require_packing_quantity_match: requirePackingQuantityMatch, + pick_location_count: pickLocationSpaceKeys.size, + items, + }; + } catch (error) { + await transaction.rollback(); + throw error; + } + } + + /** + * 断言目标订单存在且为 B2B 订单(不满足即整体失败)。 + * + * @param {Object} params 参数。 + * @param {number[]} params.orderIds 订单ID数组。 + * @param {Map} params.rowMap 订单行映射。 + * @param {string} params.actionText 动作文案。 + * @return {void} 无返回值。 + */ + assertPrepOrders({ orderIds, rowMap, actionText }) { + const notFoundOrderIds = orderIds.filter(orderId => !rowMap.has(orderId)); + if (notFoundOrderIds.length > 0) { + throw buildPrepError( + B2B_PREP_ERROR_CODE.NOT_FOUND, + `订单不存在或不属于当前仓库,无法${actionText}:${notFoundOrderIds.join(',')}`, + { not_found_order_ids: notFoundOrderIds } + ); + } + + const notB2bOrderIds = orderIds.filter(orderId => { + const row = rowMap.get(orderId); + return String(row && row.is_b2b || '').trim() !== 'Y'; + }); + if (notB2bOrderIds.length > 0) { + throw buildPrepError( + B2B_PREP_ERROR_CODE.NOT_B2B, + `仅 B2B 订单支持${actionText},以下订单不是B2B订单:${notB2bOrderIds.join(',')}`, + { not_b2b_order_ids: notB2bOrderIds } + ); + } + } + + /** + * 断言订单满足开始备货的作业前置条件(不满足即整体失败)。 + * + * 前置条件:已打印(print_status=fin)、已分配储位(storage_status=fin)、未拦截(intercept_status=none)。 + * B2B 订单实物在库内备货,缺少上述任一环节都会导致错发/漏发。 + * + * 领料(claim_status)不参与校验:领料只存在于「整波领料」流程(需订单在普通波次内, + * wave_id>0 且波次 source=0),而 B2B 订单不参与波次抓取、无波次,永远拿不到 claim_status=fin, + * 若把领料作为前置条件会永久卡死 B2B 备货。 + * + * @param {Object} params 参数。 + * @param {number} params.orderId 订单ID。 + * @param {Object} params.row 订单行(需含 print_status/storage_status/intercept_status)。 + * @return {void} 无返回值。 + */ + assertPrepStartReady({ orderId, row }) { + const printStatus = String(row && row.print_status || '').trim(); + const storageStatus = String(row && row.storage_status || '').trim(); + const interceptStatus = String(row && row.intercept_status || '').trim() || 'none'; + + const reject = reason => buildPrepError( + B2B_PREP_ERROR_CODE.NOT_READY, + `订单${reason},不允许开始备货:${orderId}`, + { + order_id: orderId, + print_status: printStatus, + storage_status: storageStatus, + intercept_status: interceptStatus, + } + ); + + // 已拦截订单禁止继续仓储作业(与 intercept_guard 口径一致:非 none 即已拦截) + if (isInterceptedOrderStatus(interceptStatus)) { + throw reject('已拦截'); + } + + if (printStatus !== 'fin') { + throw reject('未打印'); + } + + if (storageStatus !== 'fin') { + throw reject('未分配储位'); + } + } + + /** + * 备货开始(单订单作业):记录备货人工号与开始时间,状态置为 padding。 + * + * 前置条件:已打印、已分配储位且未拦截(见 assertPrepStartReady), + * 不满足直接失败、不写入任何备货记录。 + * 同工号重复开始幂等成功(保留首次开始时间);其他工号已开始或已完成一律失败。 + * + * @param {Object} params 参数。 + * @param {number|string} params.warehouseId 仓库ID。 + * @param {Array} params.orderIds 订单ID数组(仅 1 个)。 + * @param {Object|null} [params.operator=null] 操作人(备货人){ id, name }。 + * @return {Promise} 处理结果。 + */ + async startOrdersB2bPrep(params = {}) { + const { ctx } = this; + const normalizedWarehouseId = Number(params && params.warehouseId || 0); + if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) { + throw new Error('未识别到当前仓库上下文'); + } + + const normalizedOrderIds = this.normalizeB2bOrderIds(params && params.orderIds); + const prepOperator = resolvePrepOperator(params && params.operator, '开始备货'); + const transaction = await ctx.model.transaction(); + const startedRows = []; + + try { + const { rowMap, b2bMap } = await this.loadPrepTargets({ + warehouseId: normalizedWarehouseId, + orderIds: normalizedOrderIds, + transaction, + }); + this.assertPrepOrders({ orderIds: normalizedOrderIds, rowMap, actionText: '开始备货' }); + + const now = new Date(); + const b2bModel = ctx.model.OrderB2b; + + for (const orderId of normalizedOrderIds) { + const detail = b2bMap.get(orderId) || null; + const status = String(detail && detail.prep_status || B2B_PREP_STATUS.NONE).trim(); + const recordedOperatorId = Number(detail && detail.prep_operator_id || 0); + + if (status === B2B_PREP_STATUS.FIN) { + throw buildPrepError( + B2B_PREP_ERROR_CODE.STATUS_INVALID, + `订单已备货完成,不允许重新开始备货:${orderId}`, + { order_id: orderId, prep_status: status } + ); + } + + if (recordedOperatorId > 0 && recordedOperatorId !== prepOperator.id) { + throw buildPrepError( + B2B_PREP_ERROR_CODE.OPERATOR_MISMATCH, + `订单备货人为其他工号(${recordedOperatorId}),当前工号(${prepOperator.id})不允许开始备货:${orderId}`, + { order_id: orderId, prep_operator_id: recordedOperatorId, operator_id: prepOperator.id } + ); + } + + // 未打印 / 未分配储位 / 已拦截:禁止开始备货(幂等重复开始同样校验)。 + // 领料不参与校验:领料依赖波次整波领单,B2B 订单无波次、永远未领料。 + this.assertPrepStartReady({ orderId, row: rowMap.get(orderId) }); + + if (status === B2B_PREP_STATUS.PADDING && recordedOperatorId === prepOperator.id) { + // 同工号重复开始:幂等,保留原开始时间,仅补齐姓名为空的情况 + if (detail && !String(detail.prep_operator_name || '').trim() && prepOperator.name) { + await b2bModel.update( + { prep_operator_name: prepOperator.name }, + { where: { warehouse_id: normalizedWarehouseId, order_id: orderId }, transaction } + ); + } + startedRows.push({ orderId, started_at: detail && detail.prep_start_at || now, idempotent: true }); + continue; + } + + const payload = { + prep_status: B2B_PREP_STATUS.PADDING, + prep_operator_id: prepOperator.id, + prep_operator_name: prepOperator.name, + prep_start_at: now, + }; + + if (detail) { + await b2bModel.update(payload, { + where: { warehouse_id: normalizedWarehouseId, order_id: orderId }, + transaction, + }); + } else { + await b2bModel.create({ + warehouse_id: normalizedWarehouseId, + order_id: orderId, + created_at: now, + ...payload, + }, { transaction }); + } + + startedRows.push({ orderId, started_at: now, idempotent: false }); + } + + await transaction.commit(); + } catch (error) { + await transaction.rollback(); + throw error; + } + + await this.writePrepOperationLogs(startedRows.map(item => item.orderId), { + warehouseId: normalizedWarehouseId, + operator: params && params.operator, + operationCode: ORDER_B2B_PREP_START_OPERATION_CODE, + message: `备货开始(工号 ${prepOperator.id})`, + extras: { prep_operator_id: prepOperator.id }, + scene: 'startOrdersB2bPrep', + }); + + return { + prep_status: B2B_PREP_STATUS.PADDING, + prep_operator_id: prepOperator.id, + prep_operator_name: prepOperator.name, + started_order_ids: [ ...new Set(startedRows.map(item => item.orderId)) ], + started_count: startedRows.length, + idempotent_order_ids: startedRows.filter(item => item.idempotent).map(item => item.orderId), + }; + } + + /** + * 取消备货(单订单作业):重置备货人、开始时间与备货状态(仅备货中的订单可取消)。 + * + * @param {Object} params 参数。 + * @param {number|string} params.warehouseId 仓库ID。 + * @param {Array} params.orderIds 订单ID数组(仅 1 个)。 + * @param {Object|null} [params.operator=null] 操作人(备货人){ id, name }。 + * @return {Promise} 处理结果。 + */ + async cancelOrdersB2bPrep(params = {}) { + const { ctx } = this; + const normalizedWarehouseId = Number(params && params.warehouseId || 0); + if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) { + throw new Error('未识别到当前仓库上下文'); + } + + const normalizedOrderIds = this.normalizeB2bOrderIds(params && params.orderIds); + const prepOperator = resolvePrepOperator(params && params.operator, '取消备货'); + const transaction = await ctx.model.transaction(); + const canceledOrderIds = []; + + try { + const { rowMap, b2bMap } = await this.loadPrepTargets({ + warehouseId: normalizedWarehouseId, + orderIds: normalizedOrderIds, + transaction, + }); + this.assertPrepOrders({ orderIds: normalizedOrderIds, rowMap, actionText: '取消备货' }); + + for (const orderId of normalizedOrderIds) { + const detail = b2bMap.get(orderId) || null; + const status = String(detail && detail.prep_status || B2B_PREP_STATUS.NONE).trim(); + const recordedOperatorId = Number(detail && detail.prep_operator_id || 0); + + if (status !== B2B_PREP_STATUS.PADDING) { + throw buildPrepError( + B2B_PREP_ERROR_CODE.NOT_STARTED, + `订单未处于备货中,不允许取消备货:${orderId}`, + { order_id: orderId, prep_status: status } + ); + } + + if (recordedOperatorId !== prepOperator.id) { + throw buildPrepError( + B2B_PREP_ERROR_CODE.OPERATOR_MISMATCH, + `订单备货人为其他工号(${recordedOperatorId}),当前工号(${prepOperator.id})不允许取消备货:${orderId}`, + { order_id: orderId, prep_operator_id: recordedOperatorId, operator_id: prepOperator.id } + ); + } + + await ctx.model.OrderB2b.update({ + prep_status: B2B_PREP_STATUS.NONE, + prep_operator_id: null, + prep_operator_name: null, + prep_start_at: null, + prep_at: null, + prep_duration_seconds: 0, + }, { + where: { warehouse_id: normalizedWarehouseId, order_id: orderId }, + transaction, + }); + canceledOrderIds.push(orderId); + } + + await transaction.commit(); + } catch (error) { + await transaction.rollback(); + throw error; + } + + await this.writePrepOperationLogs(canceledOrderIds, { + warehouseId: normalizedWarehouseId, + operator: params && params.operator, + operationCode: ORDER_B2B_PREP_CANCEL_OPERATION_CODE, + message: `取消备货(工号 ${prepOperator.id})`, + extras: { prep_operator_id: prepOperator.id }, + scene: 'cancelOrdersB2bPrep', + }); + + return { + prep_status: B2B_PREP_STATUS.NONE, + canceled_order_ids: [ ...new Set(canceledOrderIds) ], + canceled_count: canceledOrderIds.length, + }; + } + + /** + * 备货结束(单订单作业):写入备货备注、总箱数、完成时间与备货用时,状态置为 fin。 + * + * 仅备货中的订单可结束,且必须由记录在案的同一工号提交。 + * + * @param {Object} params 参数。 + * @param {number|string} params.warehouseId 仓库ID。 + * @param {Array} params.orderIds 订单ID数组(仅 1 个)。 + * @param {string} params.prepRemark 备货备注。 + * @param {number|string} params.totalBoxCount 总箱数。 + * @param {Object|null} [params.operator=null] 操作人(备货人){ id, name }。 + * @return {Promise} 处理结果。 + */ + async finishOrdersB2bPrep(params = {}) { + const { ctx } = this; + const normalizedWarehouseId = Number(params && params.warehouseId || 0); + if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) { + throw new Error('未识别到当前仓库上下文'); + } + + const normalizedOrderIds = this.normalizeB2bOrderIds(params && params.orderIds); + const prepOperator = resolvePrepOperator(params && params.operator, '提交备货完成'); + + const prepRemark = String(params && params.prepRemark || '').trim(); + if (!prepRemark) { + throw buildPrepError(B2B_PREP_ERROR_CODE.INPUT_INVALID, '备货备注不能为空'); + } + if (prepRemark.length > 500) { + throw buildPrepError(B2B_PREP_ERROR_CODE.INPUT_INVALID, '备货备注不能超过 500 个字符'); + } + + const totalBoxCount = Number(params && params.totalBoxCount); + if (!Number.isInteger(totalBoxCount) || totalBoxCount < 0) { + throw buildPrepError(B2B_PREP_ERROR_CODE.INPUT_INVALID, '总箱数必须为大于等于 0 的整数'); + } + + const requirePackingQuantityMatch = await this.isB2bPackingQuantityCheckEnabled(normalizedWarehouseId); + const transaction = await ctx.model.transaction(); + const finishedRows = []; + let finishedAt = null; + + try { + const { rowMap, b2bMap, sourceTypeMap } = await this.loadPrepTargets({ + warehouseId: normalizedWarehouseId, + orderIds: normalizedOrderIds, + transaction, + }); + this.assertPrepOrders({ orderIds: normalizedOrderIds, rowMap, actionText: '提交备货完成' }); + + const now = new Date(); + finishedAt = now; + + for (const orderId of normalizedOrderIds) { + const detail = b2bMap.get(orderId) || null; + const status = String(detail && detail.prep_status || B2B_PREP_STATUS.NONE).trim(); + const recordedOperatorId = Number(detail && detail.prep_operator_id || 0); + + if (status !== B2B_PREP_STATUS.PADDING) { + throw buildPrepError( + B2B_PREP_ERROR_CODE.NOT_STARTED, + `订单未处于备货中,不允许提交备货完成:${orderId}`, + { order_id: orderId, prep_status: status } + ); + } + + if (recordedOperatorId !== prepOperator.id) { + throw buildPrepError( + B2B_PREP_ERROR_CODE.OPERATOR_MISMATCH, + `订单备货人为其他工号(${recordedOperatorId}),当前工号(${prepOperator.id})不允许提交备货完成:${orderId}`, + { order_id: orderId, prep_operator_id: recordedOperatorId, operator_id: prepOperator.id } + ); + } + + if (requirePackingQuantityMatch) { + await this.assertB2bPackingQuantityComplete({ + warehouseId: normalizedWarehouseId, + orderId, + sourceType: sourceTypeMap.get(orderId), + totalBoxCount, + transaction, + }); + } + + const startAt = detail && detail.prep_start_at ? new Date(detail.prep_start_at) : null; + const durationSeconds = startAt && !Number.isNaN(startAt.getTime()) + ? Math.max(0, Math.round((now.getTime() - startAt.getTime()) / 1000)) + : Number(detail && detail.prep_duration_seconds || 0); + + await ctx.model.OrderB2b.update({ + prep_status: B2B_PREP_STATUS.FIN, + prep_remark: prepRemark, + total_box_count: totalBoxCount, + prep_at: now, + prep_duration_seconds: durationSeconds, + }, { + where: { warehouse_id: normalizedWarehouseId, order_id: orderId }, + transaction, + }); + + // 备货完成同步扣减库存:与拣货完成(pick.wavePickTaskComplete / recheck._completePickForOrder)口径一致 + const stockResult = await this.completeB2bPrepStockOutbound({ + warehouseId: normalizedWarehouseId, + orderId, + operator: params && params.operator, + transaction, + }); + + finishedRows.push({ orderId, durationSeconds, stockResult }); + } + + await transaction.commit(); + } catch (error) { + await transaction.rollback(); + throw error; + } + + const durationSeconds = finishedRows.length > 0 ? finishedRows[0].durationSeconds : 0; + const stockResult = finishedRows.length > 0 && finishedRows[0].stockResult + ? finishedRows[0].stockResult + : { storage_ids: [], deducted_quantity: 0 }; + + await this.writePrepOperationLogs(finishedRows.map(item => item.orderId), { + warehouseId: normalizedWarehouseId, + operator: params && params.operator, + operationCode: ORDER_B2B_PREP_FINISH_OPERATION_CODE, + message: `备货完成(总箱数 ${totalBoxCount},用时 ${durationSeconds} 秒)`, + extras: { prep_operator_id: prepOperator.id, total_box_count: totalBoxCount }, + scene: 'finishOrdersB2bPrep', + }); + + return { + prep_status: B2B_PREP_STATUS.FIN, + prep_remark: prepRemark, + total_box_count: totalBoxCount, + prep_at: finishedAt, + finished_order_ids: [ ...new Set(finishedRows.map(item => item.orderId)) ], + finished_count: finishedRows.length, + prep_duration_seconds: durationSeconds, + stock_deducted_storage_ids: stockResult.storage_ids, + stock_deducted_quantity: stockResult.deducted_quantity, + }; + } + + /** + * 备货完成时同步扣减库存(与拣货完成口径一致)。 + * + * 处理内容与 systems/pick.js#wavePickTaskComplete / recheckOrder#_completePickForOrder 一致: + * 1. 锁定并读取该订单 status='pending' 且未删除的 wms_picking 记录; + * 2. 按 storage_id 汇总数量,加行锁校验 wms_storage.locked_quantity 足够; + * 3. 扣减 wms_storage 的 locked_quantity 与 quantity; + * 4. 写入 wms_storage_transaction 出库流水(OUTBOUND / PICK_OUTBOUND); + * 5. 将 wms_picking 记录置为 fin,避免后续拣货/复核重复扣减。 + * + * 无 pending 拣货记录(如 B2B 订单未走拣货流程或已扣减过)时不做任何变更。 + * + * @param {Object} params 参数。 + * @param {number} params.warehouseId 仓库ID。 + * @param {number} params.orderId 订单ID。 + * @param {Object|null} [params.operator=null] 操作人 { id, name }。 + * @param {Object} params.transaction 事务对象。 + * @param {string} [params.remark='备货完成出库(B2B)'] 流水备注。 + * @return {Promise<{ storage_ids: number[], deducted_quantity: number }>} 扣减结果。 + */ + async completeB2bPrepStockOutbound({ warehouseId, orderId, operator, transaction, remark }) { + const { ctx, app } = this; + const { Op } = app.Sequelize; + const normalizedWarehouseId = Number(warehouseId || 0); + const normalizedOrderId = Number(orderId || 0); + const emptyResult = { storage_ids: [], deducted_quantity: 0 }; + + if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0 + || !Number.isInteger(normalizedOrderId) || normalizedOrderId <= 0) { + return emptyResult; + } + + // 与拣货完成一致:先锁 pending 拣货记录,防止并发重复扣减 + const pickingRows = await ctx.model.query(` + SELECT id, storage_id, quantity, space_id + FROM wms_picking + WHERE order_id = :orderId + AND warehouse_id = :warehouseId + AND status = 'pending' + AND deleted_at IS NULL + FOR UPDATE + `, { + replacements: { orderId: normalizedOrderId, warehouseId: normalizedWarehouseId }, + type: ctx.model.QueryTypes.SELECT, + transaction, + }); + + const normalizedPickingRows = Array.isArray(pickingRows) ? pickingRows : []; + if (normalizedPickingRows.length === 0) { + return emptyResult; + } + + // 拣货记录置 fin(避免后续拣货/复核再次扣减) + await ctx.model.query(` + UPDATE wms_picking + SET status = 'fin', updated_at = NOW() + WHERE order_id = :orderId + AND warehouse_id = :warehouseId + AND status = 'pending' + AND deleted_at IS NULL + `, { + replacements: { orderId: normalizedOrderId, warehouseId: normalizedWarehouseId }, + type: ctx.model.QueryTypes.UPDATE, + transaction, + }); + + const storageQtyMap = new Map(); + for (const row of normalizedPickingRows) { + const storageId = Number(row && row.storage_id || 0); + if (!Number.isInteger(storageId) || storageId <= 0) { + continue; + } + const currentQty = storageQtyMap.get(storageId) || 0; + storageQtyMap.set(storageId, currentQty + (Number(row.quantity) || 0)); + } + + const storageIds = [ ...storageQtyMap.keys() ].filter(storageId => (storageQtyMap.get(storageId) || 0) > 0); + if (storageIds.length === 0) { + return emptyResult; + } + + const storageRows = await ctx.model.Storage.findAll({ + where: { + id: { [Op.in]: storageIds }, + warehouse_id: normalizedWarehouseId, + }, + attributes: [ + 'id', 'locked_quantity', 'quantity', + 'store_id', 'stock_id', 'batch_no', 'inventory_type', 'space_id', + ], + lock: transaction.LOCK.UPDATE, + raw: true, + transaction, + }); + + for (const storageRow of (Array.isArray(storageRows) ? storageRows : [])) { + const storageId = Number(storageRow && storageRow.id || 0); + const deduction = storageQtyMap.get(storageId) || 0; + const locked = Number(storageRow && storageRow.locked_quantity) || 0; + if (locked < deduction) { + throw buildPrepError( + B2B_PREP_ERROR_CODE.STATUS_INVALID, + `库存记录 ${storageId} 锁定数量不足:当前锁定 ${locked},需扣减 ${deduction}`, + { storage_id: storageId, locked_quantity: locked, deduction_quantity: deduction } + ); + } + } + + const caseClauses = storageIds + .map(storageId => `WHEN ${storageId} THEN ${storageQtyMap.get(storageId)}`) + .join(' '); + + await ctx.model.query(` + UPDATE wms_storage + SET locked_quantity = locked_quantity - CASE id ${caseClauses} END, + quantity = quantity - CASE id ${caseClauses} END, + updated_at = NOW() + WHERE id IN (:storageIds) + AND warehouse_id = :warehouseId + `, { + replacements: { + storageIds, + warehouseId: normalizedWarehouseId, + }, + transaction, + }); + + const operatorId = String(operator && operator.id || '').trim(); + const operatorName = String(operator && operator.name || 'system').trim() || 'system'; + const transactionRows = []; + let deductedQuantity = 0; + + for (const storageRow of (Array.isArray(storageRows) ? storageRows : [])) { + const storageId = Number(storageRow && storageRow.id || 0); + const deduction = storageQtyMap.get(storageId) || 0; + if (deduction <= 0) { + continue; + } + deductedQuantity += deduction; + const beforeQty = Number(storageRow.quantity) || 0; + const beforeLocked = Number(storageRow.locked_quantity) || 0; + transactionRows.push({ + transaction_type: 'OUTBOUND', + warehouse_id: normalizedWarehouseId, + store_id: Number(storageRow.store_id) || 0, + stock_id: Number(storageRow.stock_id) || 0, + storage_id: storageId, + space_id: Number(storageRow.space_id) || null, + quantity: deduction, + before_quantity: beforeQty, + after_quantity: Math.max(0, beforeQty - deduction), + before_locked_quantity: beforeLocked, + after_locked_quantity: Math.max(0, beforeLocked - deduction), + batch_no: storageRow.batch_no || null, + inventory_type: storageRow.inventory_type || 'ZP', + order_type: 'PICK_OUTBOUND', + order_no: String(normalizedOrderId), + order_id: normalizedOrderId, + source_order_codes: String(normalizedOrderId), + operator_id: operatorId, + operator_name: operatorName, + remark: String(remark || '备货完成出库(B2B)').slice(0, 500), + created_at: new Date(), + }); + } + + if (transactionRows.length > 0) { + await ctx.model.StorageTransaction.bulkCreate(transactionRows, { transaction }); + } + + return { + storage_ids: storageIds, + deducted_quantity: deductedQuantity, + }; + } + + /** + * 归一化提货车牌入参。 + * + * 去掉空格与常见分隔符(·、•、-、-、_)并转大写;空串 / null 表示清空,返回 null; + * 未传(undefined)视为参数缺失直接报错。仅做基础格式校验(首字符为汉字或字母, + * 整体 5~10 位),避免误拒军牌、使领馆牌、挂车等特殊牌照。 + * + * @param {*} value 原始车牌。 + * @return {string|null} 归一化车牌,清空时为 null。 + */ + normalizePickupPlateNumber(value) { + if (value === undefined) { + throw buildB2bError( + B2B_PLATE_ERROR_CODE.INPUT_INVALID, + 'pickup_plate_number 参数不能为空(清空车牌请传空字符串或 null)' + ); + } + + const normalized = String(value === null ? '' : value) + .replace(/[\s·•\--_]/g, '') + .toUpperCase(); + + if (!normalized) { + return null; + } + + if (normalized.length > B2B_PICKUP_PLATE_MAX_LENGTH) { + throw buildB2bError( + B2B_PLATE_ERROR_CODE.INPUT_INVALID, + `提货车牌不能超过 ${B2B_PICKUP_PLATE_MAX_LENGTH} 个字符`, + { pickup_plate_number: normalized, max_length: B2B_PICKUP_PLATE_MAX_LENGTH } + ); + } + + if (!B2B_PICKUP_PLATE_PATTERN.test(normalized)) { + throw buildB2bError( + B2B_PLATE_ERROR_CODE.INPUT_INVALID, + '提货车牌格式不正确(示例:粤A12345、粤AD12345、苏E1234挂)', + { pickup_plate_number: normalized } + ); + } + + return normalized; + } + + /** + * 录入/修改 B2B 提货车牌(单订单作业)。 + * + * 仅 B2B 订单可录入,且必须在提货前完成:已提货(is_picked_up='Y')后车牌锁定, + * 不允许再修改;已取消订单拒绝。作业明细行缺失时按默认值补建。 + * 传空字符串或 null 表示清空车牌;车牌去空格/分隔符并转大写后落库。 + * + * @param {Object} params 参数。 + * @param {number|string} params.warehouseId 仓库ID。 + * @param {Array} params.orderIds 订单ID数组(仅 1 个)。 + * @param {string|null} params.pickupPlateNumber 提货车牌(空串/null 表示清空)。 + * @param {Object|null} [params.operator=null] 操作人 { id, name }。 + * @return {Promise} { order_id, delivery_order_code, pickup_plate_number, + * previous_pickup_plate_number, changed, detail_created } + */ + async setOrdersB2bPickupPlate(params = {}) { + const { ctx } = this; + const normalizedWarehouseId = Number(params && params.warehouseId || 0); + if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) { + throw new Error('未识别到当前仓库上下文'); + } + + const normalizedOrderIds = this.normalizeB2bOrderIds(params && params.orderIds, { + inputCode: B2B_PLATE_ERROR_CODE.INPUT_INVALID, + actionText: '录入提货车牌', + }); + const pickupPlateNumber = this.normalizePickupPlateNumber(params && params.pickupPlateNumber); + const orderId = normalizedOrderIds[0]; + const transaction = await ctx.model.transaction(); + let previousPickupPlateNumber = null; + let detailCreated = false; + let deliveryOrderCode = ''; + + try { + const { rowMap, b2bMap } = await this.loadPrepTargets({ + warehouseId: normalizedWarehouseId, + orderIds: normalizedOrderIds, + transaction, + }); + + const orderRow = rowMap.get(orderId) || null; + if (!orderRow) { + throw buildB2bError( + B2B_PLATE_ERROR_CODE.NOT_FOUND, + `订单不存在或不属于当前仓库,无法录入提货车牌:${orderId}`, + { not_found_order_ids: [ orderId ] } + ); + } + + if (String(orderRow.is_b2b || '').trim() !== 'Y') { + throw buildB2bError( + B2B_PLATE_ERROR_CODE.NOT_B2B, + `仅 B2B 订单支持录入提货车牌,以下订单不是B2B订单:${orderId}`, + { not_b2b_order_ids: [ orderId ] } + ); + } + + if (String(orderRow.status || '').trim() === 'cancel') { + throw buildB2bError( + B2B_PLATE_ERROR_CODE.STATUS_INVALID, + `订单已取消,不允许录入提货车牌:${orderId}`, + { order_id: orderId, status: 'cancel' } + ); + } + + const detail = b2bMap.get(orderId) || null; + previousPickupPlateNumber = String(detail && detail.pickup_plate_number || '').trim() || null; + + // 车牌随提货锁定:提货即出库,出库后再改车牌会导致留证与实物/车辆对不上 + if (detail && String(detail.is_picked_up || '').trim() === 'Y') { + throw buildB2bError( + B2B_PLATE_ERROR_CODE.STATUS_INVALID, + `订单已提货,不允许修改提货车牌:${orderId}`, + { order_id: orderId, pickup_plate_number: previousPickupPlateNumber } + ); + } + + if (detail) { + await ctx.model.OrderB2b.update({ pickup_plate_number: pickupPlateNumber }, { + where: { warehouse_id: normalizedWarehouseId, order_id: orderId }, + transaction, + }); + } else { + detailCreated = true; + await ctx.model.OrderB2b.create({ + warehouse_id: normalizedWarehouseId, + order_id: orderId, + pickup_plate_number: pickupPlateNumber, + created_at: new Date(), + }, { transaction }); + } + + deliveryOrderCode = String(orderRow.delivery_order_code || '').trim(); + await transaction.commit(); + } catch (error) { + await transaction.rollback(); + throw error; + } + + const changed = previousPickupPlateNumber !== pickupPlateNumber; + if (changed) { + await this.writePrepOperationLogs([ orderId ], { + warehouseId: normalizedWarehouseId, + operator: params && params.operator, + operationCode: ORDER_B2B_PICKUP_PLATE_OPERATION_CODE, + message: pickupPlateNumber ? `录入提货车牌(${pickupPlateNumber})` : '清空提货车牌', + extras: { + pickup_plate_number: pickupPlateNumber, + previous_pickup_plate_number: previousPickupPlateNumber, + }, + scene: 'setOrdersB2bPickupPlate', + }); + } + + return { + order_id: orderId, + delivery_order_code: deliveryOrderCode, + pickup_plate_number: pickupPlateNumber, + previous_pickup_plate_number: previousPickupPlateNumber, + changed, + detail_created: detailCreated, + }; + } + + /** + * 归一化提货照片入参(提货时随单提交,追加语义)。 + * + * 支持 `[file_id]`、`['file_id']`、`[{ file_id, display_order }]` 混合写法; + * 按 file_id 去重并保留首次出现顺序,display_order 缺省按数组下标补 0 起序号。 + * 未传(undefined / null)返回空数组(表示本次不附带提货照片)。 + * + * @param {*} rawImages 原始入参。 + * @return {Array<{ file_id: number, display_order: number }>} 归一化后的图片列表。 + */ + normalizePickupImages(rawImages) { + if (rawImages === undefined || rawImages === null) { + return []; + } + return this.normalizeOrderImages(rawImages); + } + + /** + * 校验提货照片文件是否存在(仅一轮存在性校验,不校验仓库归属)。 + * + * @param {Array} fileIds 文件ID列表。 + * @param {Object|null} [transaction=null] 事务对象。 + * @return {Promise} 无返回值;存在缺失时抛 B2B_IMAGE_FILE_INVALID。 + */ + async assertPickupFilesExist(fileIds = [], transaction = null) { + const { ctx, app } = this; + const { Op } = app.Sequelize; + const normalizedFileIds = [ ...new Set( + (Array.isArray(fileIds) ? fileIds : []) + .map(item => Number(item)) + .filter(item => Number.isInteger(item) && item > 0) + ) ]; + if (normalizedFileIds.length === 0) { + return; + } + + const rows = await ctx.model.File.findAll({ + where: { + id: { [Op.in]: normalizedFileIds }, + is_deleted: false, + }, + attributes: [ 'id' ], + raw: true, + ...(transaction ? { transaction } : {}), + }); + + const existingFileIdSet = new Set((Array.isArray(rows) ? rows : []) + .map(row => Number(row && row.id || 0))); + const missingFileIds = normalizedFileIds.filter(fileId => !existingFileIdSet.has(fileId)); + if (missingFileIds.length > 0) { + throw buildB2bError( + B2B_IMAGE_ERROR_CODE.FILE_INVALID, + `提货照片文件不存在或已删除:${missingFileIds.join(',')}`, + { file_ids: missingFileIds } + ); + } + } + + /** + * 追加提货照片关联(仅新增,不删除已有照片)。 + * + * 落 wms_file_reference:business_type='b2b_pickup'、business_id=订单ID、 + * warehouse_id=当前仓库;display_order 在已有最大序号之后顺延。 + * + * @param {Object} params 参数。 + * @param {number} params.warehouseId 仓库ID。 + * @param {number} params.orderId 订单ID。 + * @param {Array<{ file_id: number }>} params.imageItems 图片列表。 + * @param {Object} params.transaction 事务对象。 + * @param {string} [params.createdBy='system'] 创建人。 + * @return {Promise} 本次新增的 file_id 列表。 + */ + async appendPickupImages({ warehouseId, orderId, imageItems, transaction, createdBy }) { + const { ctx } = this; + const items = Array.isArray(imageItems) ? imageItems : []; + const fileReferenceModel = ctx.model && ctx.model.FileReference; + if (items.length === 0 + || !fileReferenceModel + || typeof fileReferenceModel.findAll !== 'function' + || typeof fileReferenceModel.bulkCreate !== 'function') { + return []; + } + + const referenceWhere = { + business_type: B2B_PICKUP_IMAGE_BUSINESS_TYPE, + business_id: String(orderId), + warehouse_id: warehouseId, + }; + + const existingRefs = await fileReferenceModel.findAll({ + where: referenceWhere, + attributes: [ 'id', 'file_id', 'display_order' ], + raw: true, + transaction, + lock: transaction.LOCK.UPDATE, + }); + + const existingList = Array.isArray(existingRefs) ? existingRefs : []; + const existingFileIdSet = new Set(existingList.map(row => Number(row.file_id))); + const maxDisplayOrder = existingList.reduce( + (max, row) => Math.max(max, Number(row.display_order || 0)), + -1 + ); + + const toCreate = items + .filter(item => !existingFileIdSet.has(item.file_id)) + .map((item, index) => ({ + ...referenceWhere, + file_id: item.file_id, + display_order: maxDisplayOrder + 1 + index, + created_by: String(createdBy || 'system').trim() || 'system', + created_at: new Date(), + })); + + if (toCreate.length === 0) { + return []; + } + + await fileReferenceModel.bulkCreate(toCreate, { transaction, ignoreDuplicates: true }); + return toCreate.map(row => row.file_id); + } + + /** + * 读取订单提货照片(含文件 URL),按 display_order、id 升序。 + * + * @param {Object} params 参数。 + * @param {number} params.warehouseId 仓库ID。 + * @param {number} params.orderId 订单ID。 + * @param {Object|null} [params.transaction=null] 事务对象。 + * @return {Promise>} 提货照片列表。 + */ + async loadPickupImages({ warehouseId, orderId, transaction = null }) { + const { ctx } = this; + const fileReferenceModel = ctx.model && ctx.model.FileReference; + if (!fileReferenceModel || typeof fileReferenceModel.findAll !== 'function') { + return []; + } + const rows = await fileReferenceModel.findAll({ + where: { + business_type: B2B_PICKUP_IMAGE_BUSINESS_TYPE, + business_id: String(orderId), + warehouse_id: warehouseId, + }, + include: [{ + model: ctx.model.File, + as: 'file', + attributes: [ 'file_url' ], + required: false, + }], + order: [[ 'display_order', 'ASC' ], [ 'id', 'ASC' ]], + raw: true, + ...(transaction ? { transaction } : {}), + }); + + return (Array.isArray(rows) ? rows : []) + .map(row => ({ + file_id: Number(row && row.file_id || 0), + url: String(row && row['file.file_url'] || '').trim() || null, + display_order: Number(row && row.display_order || 0), + })) + .filter(item => Number.isInteger(item.file_id) && item.file_id > 0); + } + + /** + * B2B 提货(单订单作业):记录提货时间,is_picked_up 置为 Y,并把订单主表标记为已出库。 + * + * 仅 B2B 订单可提货,且要求备货已完成(prep_status='fin'); + * 已提货订单重复调用幂等成功(保留首次提货时间)。 + * 可选传 pickupPlateNumber 在同一事务内写入提货车牌;提货后车牌锁定,不允许再改。 + * + * 提货即出库完成:同一事务内把订单所在表(current 优先、dispatch 兜底)的 + * outbound_status 置 fin、step 置 4、delivery_time 置提货时间, + * 使出库迁移调度(schedule/sync_outbound_orders_to_delivery)按既有状态条件把订单搬到配送表; + * 已提货但主表未完成出库的历史订单在重复调用时按首次提货时间补写(自愈)。 + * + * @param {Object} params 参数。 + * @param {number|string} params.warehouseId 仓库ID。 + * @param {Array} params.orderIds 订单ID数组(仅 1 个)。 + * @param {string|null} [params.pickupPlateNumber] 提货车牌(可选;传空串/null 表示清空)。 + * @param {Array} [params.pickupImages] 提货照片 file_id 列表(可选;仅校验存在性后追加)。 + * @param {Object|null} [params.operator=null] 操作人 { id, name }。 + * @return {Promise} { is_picked_up, picked_up_at, pickup_plate_number, pickup_images, + * outbound_status, step, delivery_time, picked_up_order_ids, picked_up_count, already_picked_up } + */ + async pickupOrdersB2b(params = {}) { + const { ctx } = this; + const normalizedWarehouseId = Number(params && params.warehouseId || 0); + if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) { + throw new Error('未识别到当前仓库上下文'); + } + + const normalizedOrderIds = this.normalizeB2bOrderIds(params && params.orderIds, { + inputCode: B2B_PICKUP_ERROR_CODE.INPUT_INVALID, + actionText: '提货', + }); + const hasPickupPlateInput = params && Object.prototype.hasOwnProperty.call(params, 'pickupPlateNumber') + && params.pickupPlateNumber !== undefined; + const normalizedPickupPlate = hasPickupPlateInput + ? this.normalizePickupPlateNumber(params.pickupPlateNumber) + : null; + const pickupImageItems = this.normalizePickupImages(params && params.pickupImages); + const transaction = await ctx.model.transaction(); + let pickedUpAt = null; + let alreadyPickedUp = false; + let outboundMarked = false; + let pickupPlateNumber = null; + let addedPickupFileIds = []; + let pickupImages = []; + + try { + const { rowMap, b2bMap, modelMap } = await this.loadPrepTargets({ + warehouseId: normalizedWarehouseId, + orderIds: normalizedOrderIds, + transaction, + }); + + const orderId = normalizedOrderIds[0]; + const orderRow = rowMap.get(orderId) || null; + if (!orderRow) { + throw buildPrepError( + B2B_PICKUP_ERROR_CODE.NOT_FOUND, + `订单不存在或不属于当前仓库,无法提货:${orderId}`, + { not_found_order_ids: [ orderId ] } + ); + } + + if (String(orderRow.is_b2b || '').trim() !== 'Y') { + throw buildPrepError( + B2B_PICKUP_ERROR_CODE.NOT_B2B, + `仅 B2B 订单支持提货,以下订单不是B2B订单:${orderId}`, + { not_b2b_order_ids: [ orderId ] } + ); + } + + if (String(orderRow.status || '').trim() === 'cancel') { + throw buildPrepError( + B2B_PICKUP_ERROR_CODE.STATUS_INVALID, + `订单已取消,不允许提货:${orderId}`, + { order_id: orderId, status: 'cancel' } + ); + } + + const detail = b2bMap.get(orderId) || null; + if (!detail) { + throw buildPrepError( + B2B_PICKUP_ERROR_CODE.STATUS_INVALID, + `订单未备货完成,不允许提货:${orderId}`, + { order_id: orderId, prep_status: B2B_PREP_STATUS.NONE } + ); + } + + const storedPickupPlate = String(detail && detail.pickup_plate_number || '').trim() || null; + + if (String(detail.is_picked_up || '').trim() === 'Y') { + // 已提货:幂等成功,保留首次提货时间;车牌随提货锁定,不允许再改 + if (hasPickupPlateInput && normalizedPickupPlate !== storedPickupPlate) { + throw buildB2bError( + B2B_PICKUP_ERROR_CODE.STATUS_INVALID, + `订单已提货,不允许修改提货车牌:${orderId}`, + { order_id: orderId, pickup_plate_number: storedPickupPlate } + ); + } + alreadyPickedUp = true; + pickedUpAt = detail.picked_up_at || null; + pickupPlateNumber = storedPickupPlate; + } else { + if (String(detail.prep_status || B2B_PREP_STATUS.NONE).trim() !== B2B_PREP_STATUS.FIN) { + throw buildPrepError( + B2B_PICKUP_ERROR_CODE.STATUS_INVALID, + `订单未备货完成,不允许提货:${orderId}`, + { order_id: orderId, prep_status: String(detail.prep_status || B2B_PREP_STATUS.NONE).trim() } + ); + } + + pickedUpAt = new Date(); + const pickupPayload = { + is_picked_up: 'Y', + picked_up_at: pickedUpAt, + }; + if (hasPickupPlateInput) { + pickupPayload.pickup_plate_number = normalizedPickupPlate; + } + await ctx.model.OrderB2b.update(pickupPayload, { + where: { warehouse_id: normalizedWarehouseId, order_id: orderId }, + transaction, + }); + pickupPlateNumber = hasPickupPlateInput ? normalizedPickupPlate : storedPickupPlate; + } + + // 提货照片:只做一轮存在性校验后追加,不覆盖已有照片(提货前预传、提货时补充均走同一路径) + if (pickupImageItems.length > 0) { + await this.assertPickupFilesExist(pickupImageItems.map(item => item.file_id), transaction); + addedPickupFileIds = await this.appendPickupImages({ + warehouseId: normalizedWarehouseId, + orderId, + imageItems: pickupImageItems, + transaction, + createdBy: params && params.operator && params.operator.name + || ctx.user && (ctx.user.employees_name || ctx.user.name) + || 'system', + }); + } + + pickupImages = await this.loadPickupImages({ + warehouseId: normalizedWarehouseId, + orderId, + transaction, + }); + + // 提货即出库完成:主表写 outbound_status=fin / step=4 / delivery_time, + // 由出库迁移调度按既有状态条件把订单搬到配送表(无需给迁移脚本加 B2B 特判)。 + // 已提货的历史订单(is_picked_up=Y 但主表未完成)在此按首次提货时间补写,实现自愈。 + const currentOutboundStatus = String(orderRow.outbound_status || '').trim(); + const currentStep = Number(orderRow.step || 0); + const needMarkOutbound = currentOutboundStatus !== B2B_OUTBOUND_STATUS_FIN + || currentStep !== B2B_OUTBOUND_STEP; + + if (needMarkOutbound) { + const orderModelToUpdate = modelMap.get(orderId); + if (!orderModelToUpdate || typeof orderModelToUpdate.update !== 'function') { + throw new Error(`无法定位订单所在分表模型,出库状态写入失败:${orderId}`); + } + + const deliveryTime = pickedUpAt || orderRow.delivery_time || new Date(); + await orderModelToUpdate.update({ + outbound_status: B2B_OUTBOUND_STATUS_FIN, + step: B2B_OUTBOUND_STEP, + delivery_time: deliveryTime, + updated_at: new Date(), + }, { + where: { id: orderId, warehouse_id: normalizedWarehouseId }, + transaction, + }); + outboundMarked = true; + } + + await transaction.commit(); + } catch (error) { + await transaction.rollback(); + throw error; + } + + if (!alreadyPickedUp) { + await this.writePrepOperationLogs([ normalizedOrderIds[0] ], { + warehouseId: normalizedWarehouseId, + operator: params && params.operator, + operationCode: ORDER_B2B_PICKUP_OPERATION_CODE, + message: 'B2B订单提货', + extras: { + ...(hasPickupPlateInput ? { pickup_plate_number: pickupPlateNumber } : {}), + ...(addedPickupFileIds.length > 0 ? { pickup_file_ids: addedPickupFileIds } : {}), + }, + scene: 'pickupOrdersB2b', + }); + } + + return { + is_picked_up: 'Y', + picked_up_at: pickedUpAt, + pickup_plate_number: pickupPlateNumber, + pickup_images: pickupImages, + pickup_image_count: pickupImages.length, + outbound_status: B2B_OUTBOUND_STATUS_FIN, + step: B2B_OUTBOUND_STEP, + outbound_marked: outboundMarked, + picked_up_order_ids: [ normalizedOrderIds[0] ], + picked_up_count: 1, + already_picked_up: alreadyPickedUp, + }; + } + + /** + * 归一化订单图片入参。 + * + * 支持 `[{ file_id, display_order }]`、`[file_id]`、`['file_id']` 混合写法; + * 按 file_id 去重并保留首次出现顺序,display_order 缺省按数组下标补 0 起序号。 + * + * @param {*} rawImages 原始图片入参。 + * @return {Array<{ file_id: number, display_order: number }>} 归一化后的图片列表(可为空数组)。 + */ + normalizeOrderImages(rawImages) { + if (rawImages === undefined || rawImages === null) { + throw buildB2bError( + B2B_IMAGE_ERROR_CODE.INPUT_INVALID, + 'images 参数不能为空(清空图片请传空数组)' + ); + } + + if (!Array.isArray(rawImages)) { + throw buildB2bError(B2B_IMAGE_ERROR_CODE.INPUT_INVALID, 'images 必须为数组'); + } + + const seenFileIds = new Set(); + const normalized = []; + + for (const item of rawImages) { + const rawFileId = item && typeof item === 'object' && !Array.isArray(item) + ? (item.file_id ?? item.fileId ?? item.id) + : item; + const fileId = Number(rawFileId); + + if (!Number.isInteger(fileId) || fileId <= 0) { + throw buildB2bError( + B2B_IMAGE_ERROR_CODE.INPUT_INVALID, + '图片 file_id 必须为正整数', + { invalid_file_id: rawFileId } + ); + } + + if (seenFileIds.has(fileId)) { + continue; + } + seenFileIds.add(fileId); + + const rawDisplayOrder = item && typeof item === 'object' && !Array.isArray(item) + ? (item.display_order ?? item.displayOrder ?? item.sort_order ?? item.sortOrder) + : undefined; + const displayOrder = rawDisplayOrder === undefined || rawDisplayOrder === null || rawDisplayOrder === '' + ? normalized.length + : Number(rawDisplayOrder); + + if (!Number.isInteger(displayOrder) || displayOrder < 0) { + throw buildB2bError( + B2B_IMAGE_ERROR_CODE.INPUT_INVALID, + '图片 display_order 必须为非负整数', + { file_id: fileId, display_order: rawDisplayOrder } + ); + } + + normalized.push({ file_id: fileId, display_order: displayOrder }); + } + + if (normalized.length > B2B_ORDER_IMAGE_MAX) { + throw buildB2bError( + B2B_IMAGE_ERROR_CODE.INPUT_INVALID, + `单个订单最多维护 ${B2B_ORDER_IMAGE_MAX} 张图片,当前 ${normalized.length} 张`, + { max: B2B_ORDER_IMAGE_MAX, current: normalized.length } + ); + } + + return normalized; + } + + /** + * 更新 B2B 订单备货留证照片(全量覆盖)。 + * + * 图片关系统一落在 wms_file_reference:business_type='b2b_order'、business_id=订单ID、 + * warehouse_id=当前仓库、display_order 控制顺序;wms_file 只做文件本体复用,不做物理删除。 + * + * 入参 images 为全量覆盖语义:未包含的旧关联会被删除,新关联按列表顺序写入; + * 传空数组表示清空该订单备货照片。仅 B2B 订单(is_b2b='Y')且未取消的订单可更新。 + * 交易对象在 current 分表优先、dispatch 分表兜底查找;文件必须属于当前仓库且未删除。 + * + * @param {Object} params 参数。 + * @param {number|string} params.warehouseId 仓库ID。 + * @param {Array} params.orderIds 订单ID数组(仅 1 个)。 + * @param {Array} params.images 图片列表(file_id / display_order)。 + * @param {Object|null} [params.operator=null] 操作人 { id, name }。 + * @return {Promise} { order_id, business_type, image_count, images, added_file_ids, removed_file_ids } + */ + async updateOrderImages(params = {}) { + const { ctx, app } = this; + const { Op } = app.Sequelize; + const businessType = B2B_PREP_IMAGE_BUSINESS_TYPE; + const normalizedWarehouseId = Number(params && params.warehouseId || 0); + if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) { + throw new Error('未识别到当前仓库上下文'); + } + + const normalizedOrderIds = this.normalizeB2bOrderIds(params && params.orderIds, { + inputCode: B2B_IMAGE_ERROR_CODE.INPUT_INVALID, + actionText: '更新订单图片', + }); + const orderId = normalizedOrderIds[0]; + const imageItems = this.normalizeOrderImages(params && params.images); + const operator = params && params.operator && typeof params.operator === 'object' + ? params.operator + : null; + + // ── 1. 订单定位(current 优先、dispatch 兜底)与 B2B 校验 ── + const factory = ctx.model.OrderDeliveryFactory; + const ORDER_ATTRIBUTES = [ 'id', 'delivery_order_code', 'is_b2b', 'status' ]; + const orderWhere = { id: orderId, warehouse_id: normalizedWarehouseId }; + + const currentModel = await factory.getCurrentModel(normalizedWarehouseId); + let orderRow = await currentModel.findOne({ where: orderWhere, attributes: ORDER_ATTRIBUTES, raw: true }); + + if (!orderRow) { + const dispatchModel = await factory.getDispatchModel(normalizedWarehouseId); + orderRow = await dispatchModel.findOne({ where: orderWhere, attributes: ORDER_ATTRIBUTES, raw: true }); + } + + if (!orderRow) { + throw buildB2bError( + B2B_IMAGE_ERROR_CODE.NOT_FOUND, + `订单不存在或不属于当前仓库,无法更新图片:${orderId}`, + { order_id: orderId } + ); + } + + if (String(orderRow.is_b2b || '').trim() !== 'Y') { + throw buildB2bError( + B2B_IMAGE_ERROR_CODE.NOT_B2B, + `仅 B2B 订单支持更新订单图片,以下订单不是B2B订单:${orderId}`, + { order_id: orderId } + ); + } + + if (String(orderRow.status || '').trim() === 'cancel') { + throw buildB2bError( + B2B_IMAGE_ERROR_CODE.STATUS_INVALID, + `订单已取消,不允许更新图片:${orderId}`, + { order_id: orderId, status: 'cancel' } + ); + } + + // ── 2. 文件归属校验:必须属于当前仓库且未删除 ── + const fileIds = imageItems.map(item => item.file_id); + const fileUrlMap = new Map(); + if (fileIds.length > 0) { + const fileRows = await ctx.model.File.findAll({ + where: { + id: { [Op.in]: fileIds }, + warehouse_id: normalizedWarehouseId, + is_deleted: false, + }, + attributes: [ 'id', 'file_url' ], + raw: true, + }); + for (const row of (Array.isArray(fileRows) ? fileRows : [])) { + fileUrlMap.set(Number(row.id), String(row.file_url || '').trim()); + } + + const invalidFileIds = fileIds.filter(fileId => !fileUrlMap.has(fileId)); + if (invalidFileIds.length > 0) { + throw buildB2bError( + B2B_IMAGE_ERROR_CODE.FILE_INVALID, + `图片文件不存在、已删除或不属于当前仓库:${invalidFileIds.join(',')}`, + { file_ids: invalidFileIds } + ); + } + } + + // ── 3. 事务内全量同步 wms_file_reference ── + const businessId = String(orderId); + const referenceWhere = { + business_type: businessType, + business_id: businessId, + warehouse_id: normalizedWarehouseId, + }; + const createdBy = String( + operator && operator.name || ctx.user && (ctx.user.employees_name || ctx.user.name) || '' + ).trim() || 'system'; + + const transaction = await ctx.model.transaction(); + const addedFileIds = []; + const removedFileIds = []; + + try { + const existingRefs = await ctx.model.FileReference.findAll({ + where: referenceWhere, + attributes: [ 'id', 'file_id', 'display_order' ], + raw: true, + transaction, + lock: transaction.LOCK.UPDATE, + }); + + const existingRefsList = Array.isArray(existingRefs) ? existingRefs : []; + const existingFileIdSet = new Set(existingRefsList.map(row => Number(row.file_id))); + const keepFileIdSet = new Set(fileIds); + + const toDeleteIds = existingRefsList + .filter(row => !keepFileIdSet.has(Number(row.file_id))) + .map(row => Number(row.id)) + .filter(id => Number.isInteger(id) && id > 0); + const toCreate = imageItems.filter(item => !existingFileIdSet.has(item.file_id)); + const toUpdateOrder = imageItems.filter(item => { + if (!existingFileIdSet.has(item.file_id)) { + return false; + } + const existing = existingRefsList.find(row => Number(row.file_id) === item.file_id); + return Number(existing && existing.display_order || 0) !== item.display_order; + }); + + if (toDeleteIds.length > 0) { + await ctx.model.FileReference.destroy({ + where: { ...referenceWhere, id: { [Op.in]: toDeleteIds } }, + transaction, + }); + removedFileIds.push(...existingRefsList + .filter(row => toDeleteIds.includes(Number(row.id))) + .map(row => Number(row.file_id))); + } + + if (toCreate.length > 0) { + await ctx.model.FileReference.bulkCreate(toCreate.map(item => ({ + ...referenceWhere, + file_id: item.file_id, + display_order: item.display_order, + created_by: createdBy, + created_at: new Date(), + })), { transaction, ignoreDuplicates: true }); + addedFileIds.push(...toCreate.map(item => item.file_id)); + } + + for (const item of toUpdateOrder) { + await ctx.model.FileReference.update( + { display_order: item.display_order }, + { where: { ...referenceWhere, file_id: item.file_id }, transaction } + ); + } + + await transaction.commit(); + } catch (error) { + await transaction.rollback(); + throw error; + } + + // ── 4. 回读最终图片列表(含文件 URL) ── + const finalRefs = await ctx.model.FileReference.findAll({ + where: referenceWhere, + include: [{ + model: ctx.model.File, + as: 'file', + attributes: [ 'file_url' ], + required: false, + }], + order: [[ 'display_order', 'ASC' ], [ 'id', 'ASC' ]], + raw: true, + }); + + const images = (Array.isArray(finalRefs) ? finalRefs : []) + .map(row => ({ + file_id: Number(row.file_id), + url: String(row['file.file_url'] || '').trim() || null, + display_order: Number(row.display_order || 0), + })) + .filter(item => Number.isInteger(item.file_id) && item.file_id > 0); + + // ── 5. 操作日志(提交后写入,失败仅告警) ── + await this.writePrepOperationLogs([ orderId ], { + warehouseId: normalizedWarehouseId, + operator: params && params.operator, + operationCode: ORDER_B2B_IMAGES_OPERATION_CODE, + message: `更新B2B订单图片(共 ${images.length} 张)`, + extras: { + business_type: businessType, + image_count: images.length, + added_file_ids: addedFileIds, + removed_file_ids: removedFileIds, + }, + scene: 'updateOrderImages', + }); + + return { + order_id: orderId, + delivery_order_code: String(orderRow.delivery_order_code || '').trim(), + business_type: businessType, + image_count: images.length, + images, + added_file_ids: addedFileIds, + removed_file_ids: removedFileIds, + }; + } + + /** + * 归一化备货/提货单订单入参(单订单作业,仅允许 1 个订单ID)。 + * @param {*} rawIds 原始入参。 + * @param {Object} [options={}] 选项。 + * @param {string} [options.inputCode] 入参错误码。 + * @param {string} [options.actionText='处理'] 动作文案。 + * @return {number[]} 单元素订单ID数组。 + */ + normalizeB2bOrderIds(rawIds, options = {}) { + const errorCode = options.inputCode || B2B_PREP_ERROR_CODE.INPUT_INVALID; + const actionText = String(options.actionText || '备货作业').trim(); + + const normalized = [ ...new Set( + (Array.isArray(rawIds) ? rawIds : [ rawIds ]) + .map(item => Number(item)) + .filter(item => Number.isInteger(item) && item > 0) + ) ]; + if (normalized.length === 0) { + throw buildPrepError(errorCode, '订单ID不能为空'); + } + if (normalized.length > 1) { + throw buildPrepError( + errorCode, + `${actionText}仅支持单个订单,请单条提交`, + { order_ids: normalized } + ); + } + return normalized; + } + + /** + * 写备货作业操作日志(事务提交后调用,失败仅告警)。 + * + * @param {number[]} orderIds 订单ID数组。 + * @param {Object} params 日志参数。 + * @return {Promise} 无返回值。 + */ + async writePrepOperationLogs(orderIds = [], params = {}) { + const { ctx } = this; + const operator = params.operator && typeof params.operator === 'object' ? params.operator : null; + const extras = params.extras && typeof params.extras === 'object' && !Array.isArray(params.extras) + ? params.extras + : {}; + + for (const orderId of orderIds) { + try { + await ctx.service.systems.operationLog.createOperationLog({ + businessType: 'order', + businessId: Number(orderId), + operationCode: params.operationCode, + operationAction: 'UPDATE', + changeSummary: params.message, + operator, + extras: { + warehouseId: params.warehouseId, + orderId: Number(orderId), + ...extras, + message: params.message, + }, + beforeChanges: null, + }); + } catch (error) { + ctx.logger.warn(`[orderB2b.${params.scene}] 写入操作日志失败,不影响业务, orderId=${orderId}, error=${error.message}`); + } + } + } } module.exports = OrderB2bService; diff --git a/app/service/systems/setting/warehouse.js b/app/service/systems/setting/warehouse.js index 7b38ee1..cb8dc69 100644 --- a/app/service/systems/setting/warehouse.js +++ b/app/service/systems/setting/warehouse.js @@ -369,6 +369,14 @@ const WAREHOUSE_SETTING_FIELDS = Object.freeze([ required: false, description: '开启后散单称重(订单波次范围 wave_scope 非 1 大团购 / 3 小团购)须处于打包中或已打包(pack_status=padding/fin);未打包或打包异常时拒绝称重并返回错误,默认 false(关闭)', }), + Object.freeze({ + key: 'b2b_packing_quantity_check', + name: 'B2B备货完成校验分箱数量', + type: 'flag', + default: false, + required: false, + description: '开启后 B2B 备货完成前逐订单商品校验分箱数量合计等于应拣数量,并校验总箱数与分箱箱号数一致;默认 false(关闭)', + }), Object.freeze({ key: 'stock_warning_enabled', name: '是否开启库存预警', diff --git a/database/migrations/20261117180000-add-is-urgent-to-wms-order-b2b.js b/database/migrations/20261117180000-add-is-urgent-to-wms-order-b2b.js new file mode 100644 index 0000000..262e080 --- /dev/null +++ b/database/migrations/20261117180000-add-is-urgent-to-wms-order-b2b.js @@ -0,0 +1,90 @@ +'use strict'; + +/** + * wms_order_b2b 增加 is_urgent 列(是否加急,默认 N)与 idx_is_urgent 索引。 + * + * 背景:B2B 作业明细需要区分加急备货订单;列表(order.pendingOrder2b.list / + * order.deliveryOrder2b.list)输出该字段并支持 where.is_urgent 筛选, + * 转换时以订单表 is_urgency 作为初始值。 + * + * 幂等:列/索引存在性判断后再执行,重复运行安全。 + */ + +const TABLE_NAME = 'wms_order_b2b'; +const COLUMN_NAME = 'is_urgent'; +const INDEX_NAME = 'idx_is_urgent'; + +/** + * 判断索引是否存在。 + * @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(); + }); +} + +module.exports = { + /** + * 执行迁移:新增 is_urgent 列与索引。 + * @param {import('sequelize').QueryInterface} queryInterface 查询接口。 + * @param {Object} Sequelize Sequelize 类型集合。 + * @return {Promise} 无返回值。 + */ + async up(queryInterface, Sequelize) { + const { ENUM } = Sequelize; + const log = []; + + const columns = await queryInterface.describeTable(TABLE_NAME); + if (!columns || Object.keys(columns).length === 0) { + throw new Error(`表 ${TABLE_NAME} 不存在,无法新增 ${COLUMN_NAME}`); + } + + if (!Object.prototype.hasOwnProperty.call(columns, COLUMN_NAME)) { + await queryInterface.addColumn(TABLE_NAME, COLUMN_NAME, { + type: ENUM('Y', 'N'), + allowNull: false, + defaultValue: 'N', + comment: '是否加急:Y=加急 N=普通', + }); + log.push({ action: 'add-column', columnName: COLUMN_NAME }); + } else { + log.push({ action: 'skip-add-column', columnName: COLUMN_NAME, reason: 'exists' }); + } + + if (!(await indexExists(queryInterface, INDEX_NAME))) { + await queryInterface.addIndex(TABLE_NAME, [ COLUMN_NAME ], { name: INDEX_NAME }); + log.push({ action: 'add-index', indexName: INDEX_NAME }); + } else { + log.push({ action: 'skip-add-index', indexName: INDEX_NAME, reason: 'exists' }); + } + + console.log('[20261117180000-add-is-urgent-to-wms-order-b2b] up results:', JSON.stringify(log)); + }, + + /** + * 回滚迁移:移除 is_urgent 索引与列。 + * @param {import('sequelize').QueryInterface} queryInterface 查询接口。 + * @return {Promise} 无返回值。 + */ + async down(queryInterface) { + const log = []; + + if (await indexExists(queryInterface, INDEX_NAME)) { + await queryInterface.removeIndex(TABLE_NAME, INDEX_NAME); + log.push({ action: 'drop-index', indexName: INDEX_NAME }); + } + + const columns = await queryInterface.describeTable(TABLE_NAME); + if (Object.prototype.hasOwnProperty.call(columns, COLUMN_NAME)) { + await queryInterface.removeColumn(TABLE_NAME, COLUMN_NAME); + log.push({ action: 'drop-column', columnName: COLUMN_NAME }); + } + + console.log('[20261117180000-add-is-urgent-to-wms-order-b2b] down results:', JSON.stringify(log)); + }, +}; diff --git a/database/migrations/20261117200000-add-prep-fields-to-wms-order-b2b.js b/database/migrations/20261117200000-add-prep-fields-to-wms-order-b2b.js new file mode 100644 index 0000000..41c006f --- /dev/null +++ b/database/migrations/20261117200000-add-prep-fields-to-wms-order-b2b.js @@ -0,0 +1,140 @@ +'use strict'; + +/** + * wms_order_b2b 增加备货作业字段(B2B 备货开始 / 取消备货 / 备货结束)。 + * + * 新增: + * - prep_status ENUM('none','padding','fin') NOT NULL DEFAULT 'none' 备货状态 + * - prep_operator_id BIGINT UNSIGNED NULL 备货人工号ID + * - prep_operator_name VARCHAR(50) NULL 备货人姓名 + * - prep_start_at DATETIME NULL 备货开始时间 + * - idx_prep_status_operator (prep_status, prep_operator_id) 我的备货任务筛选 + * + * 已有字段复用:prep_remark(备货备注)、total_box_count(总箱数)、 + * prep_at(备货完成时间)、prep_duration_seconds(备货用时)。 + * + * 幂等:列/索引存在性判断后再执行,重复运行安全。 + */ + +const TABLE_NAME = 'wms_order_b2b'; +const INDEX_NAME = 'idx_prep_status_operator'; + +const COLUMNS = [ + { + name: 'prep_status', + definition: { + type: "ENUM('none', 'padding', 'fin')", + allowNull: false, + defaultValue: 'none', + comment: '备货状态:none=未开始 padding=备货中 fin=已完成', + }, + }, + { + name: 'prep_operator_id', + definition: { + type: 'BIGINT UNSIGNED', + allowNull: true, + comment: '备货人工号ID(工号,用于同工号校验)', + }, + }, + { + name: 'prep_operator_name', + definition: { + type: 'VARCHAR(50)', + allowNull: true, + comment: '备货人姓名', + }, + }, + { + name: 'prep_start_at', + definition: { + type: 'DATETIME', + allowNull: true, + comment: '备货开始时间', + }, + }, +]; + +/** + * 判断索引是否存在。 + * @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(); + }); +} + +module.exports = { + /** + * 执行迁移:新增备货作业字段与索引。 + * @param {import('sequelize').QueryInterface} queryInterface 查询接口。 + * @param {Object} Sequelize Sequelize 类型集合。 + * @return {Promise} 无返回值。 + */ + async up(queryInterface, Sequelize) { + const { DataTypes } = Sequelize; + const log = []; + + const columns = await queryInterface.describeTable(TABLE_NAME); + if (!columns || Object.keys(columns).length === 0) { + throw new Error(`表 ${TABLE_NAME} 不存在,无法新增备货字段`); + } + + for (const column of COLUMNS) { + if (Object.prototype.hasOwnProperty.call(columns, column.name)) { + log.push({ action: 'skip-add-column', columnName: column.name, reason: 'exists' }); + continue; + } + + const definition = column.name === 'prep_status' + ? { type: DataTypes.ENUM('none', 'padding', 'fin'), allowNull: false, defaultValue: 'none', comment: column.definition.comment } + : column.name === 'prep_operator_id' + ? { type: DataTypes.BIGINT.UNSIGNED, allowNull: true, comment: column.definition.comment } + : column.name === 'prep_operator_name' + ? { type: DataTypes.STRING(50), allowNull: true, comment: column.definition.comment } + : { type: DataTypes.DATE, allowNull: true, comment: column.definition.comment }; + + await queryInterface.addColumn(TABLE_NAME, column.name, definition); + log.push({ action: 'add-column', columnName: column.name }); + } + + if (!(await indexExists(queryInterface, INDEX_NAME))) { + await queryInterface.addIndex(TABLE_NAME, [ 'prep_status', 'prep_operator_id' ], { name: INDEX_NAME }); + log.push({ action: 'add-index', indexName: INDEX_NAME }); + } else { + log.push({ action: 'skip-add-index', indexName: INDEX_NAME, reason: 'exists' }); + } + + console.log('[20261117200000-add-prep-fields-to-wms-order-b2b] up results:', JSON.stringify(log)); + }, + + /** + * 回滚迁移:移除备货作业字段与索引。 + * @param {import('sequelize').QueryInterface} queryInterface 查询接口。 + * @return {Promise} 无返回值。 + */ + async down(queryInterface) { + const log = []; + + if (await indexExists(queryInterface, INDEX_NAME)) { + await queryInterface.removeIndex(TABLE_NAME, INDEX_NAME); + log.push({ action: 'drop-index', indexName: INDEX_NAME }); + } + + const columns = await queryInterface.describeTable(TABLE_NAME); + for (const column of [ ...COLUMNS ].reverse()) { + if (!Object.prototype.hasOwnProperty.call(columns, column.name)) { + continue; + } + await queryInterface.removeColumn(TABLE_NAME, column.name); + log.push({ action: 'drop-column', columnName: column.name }); + } + + console.log('[20261117200000-add-prep-fields-to-wms-order-b2b] down results:', JSON.stringify(log)); + }, +}; diff --git a/database/migrations/20261119090000-create-wms-order-b2b-items.js b/database/migrations/20261119090000-create-wms-order-b2b-items.js new file mode 100644 index 0000000..df39f6e --- /dev/null +++ b/database/migrations/20261119090000-create-wms-order-b2b-items.js @@ -0,0 +1,65 @@ +'use strict'; + +const TABLE_NAME = 'wms_order_b2b_items'; + +module.exports = { + async up(queryInterface, Sequelize) { + const { BIGINT, INTEGER, STRING, DATE } = Sequelize; + await queryInterface.createTable(TABLE_NAME, { + id: { + type: BIGINT(20).UNSIGNED, + primaryKey: true, + autoIncrement: true, + allowNull: false, + comment: '主键ID', + }, + warehouse_id: { + type: BIGINT(20).UNSIGNED, + allowNull: false, + comment: '仓库ID', + }, + order_id: { + type: BIGINT(20).UNSIGNED, + allowNull: false, + comment: '订单ID', + }, + order_item_id: { + type: BIGINT(20).UNSIGNED, + allowNull: false, + comment: '订单商品明细ID', + }, + box_no: { + type: STRING(50), + allowNull: false, + comment: '箱号', + }, + quantity: { + type: INTEGER(11).UNSIGNED, + allowNull: false, + comment: '该商品在该箱中的数量', + }, + created_at: { + type: DATE, + allowNull: false, + comment: '创建时间', + }, + updated_at: { + type: DATE, + allowNull: false, + comment: '更新时间', + }, + }); + + await queryInterface.addIndex(TABLE_NAME, + [ 'warehouse_id', 'order_id', 'order_item_id', 'box_no' ], + { unique: true, name: 'uk_warehouse_order_item_box' }); + await queryInterface.addIndex(TABLE_NAME, + [ 'warehouse_id', 'order_id' ], + { name: 'idx_warehouse_order' }); + await queryInterface.addIndex(TABLE_NAME, [ 'order_item_id' ], { name: 'idx_order_item' }); + }, + + async down(queryInterface) { + await queryInterface.dropTable(TABLE_NAME); + }, +}; diff --git a/methods/changes/system.json b/methods/changes/system.json index d4d1745..033b836 100644 --- a/methods/changes/system.json +++ b/methods/changes/system.json @@ -1,4 +1,129 @@ [ + { + "version": "2026.11.19-b2b-snapshot-pick-locations", + "date": "2026-11-19", + "type": "updated", + "summary": "B2B 分箱快照新增取货储位:order.getB2bPackingSnapshot 输出 pick_locations / pick_location_count(取代 order.pendingOrder2b.list 的列表级储位汇总)", + "methods": [ + "order.getB2bPackingSnapshot", + "order.pendingOrder2b.list" + ], + "notes": [ + "数据源 wms_picking(订单储位分配结果),按 warehouse_id + order_id + status != 'cancel' 一次查询,按 order_item_id 关联到商品明细行;同一商品在同一储位的多条记录合并数量,按库位名称升序。", + "响应新增 items[].pick_locations:[{ space_id, space_name, quantity }](该商品从哪些储位取多少货),以及订单级 pick_location_count(本单涉及的不同储位个数),未分配储位时为空数组与 0;返回只读,提交变更仍用 order.updateB2bPackingItems。", + "变更原因:取货储位属于单个订单的作业视图,应由分箱快照(order.getB2bPackingSnapshot)按商品行提供;order.pendingOrder2b.list 撤回 pick_locations / pick_location_count,避免列表分页响应携带储位明细。", + "实现:app/service/systems/order_b2b.js#loadB2bPickLocationsByItem(新增)由 getB2bPackingSnapshot 调用。", + "库表维护源说明:维护源为库表(wms_api_method_doc + wms_method_doc_meta),methods/system.json 是导出产物;本次按 docs/api-doc-update-workflow.md 走 npm run doc:api:update 写入 JSON 与变更记录后,再用 script/method-doc-import.cjs 回填开发库(127.0.0.1:3307/wms),import → export 往返校验与文件逐字节一致。" + ] + }, + { + "version": "2026.11.19-b2b-packing-items", + "date": "2026-11-19", + "type": "added", + "summary": "新增 B2B 按商品分箱明细、全量更新与订单分箱快照接口,并增加仓库级齐套校验开关", + "methods": [ + "order.updateB2bPackingItems", + "order.getB2bPackingSnapshot", + "order.finishB2bPrep", + "setting.warehouse.getSettings", + "setting.warehouse.getFieldMeta", + "setting.warehouse.saveSettings" + ], + "notes": [ + "新增 wms_order_b2b_items,按 warehouse_id + order_id + order_item_id + box_no 保存箱号及箱内数量;不修改订单明细分表。", + "order.updateB2bPackingItems 对单个备货中 B2B 订单全量替换分箱快照,items 为空数组可清空;每条商品行 ID 必须属于该订单,并同步 wms_order_b2b.total_box_count 为不同箱号数。", + "order.getB2bPackingSnapshot 返回订单号/状态、应拣商品明细、每个商品已分箱数量与箱号分布,以及 total_box_count 和齐套校验开关。", + "仓库 subject_config 新增 b2b_packing_quantity_check(flag,默认 false)。开启后 order.finishB2bPrep 逐商品明细校验分箱数量合计等于 plan_qty,并校验总箱数与分箱箱号数一致;失败时事务回滚。", + "操作日志新增 ORDER_B2B_PACKING_ITEMS;更新与校验均不改变既有库存扣减流程。" + ] + }, + { + "version": "2026.11.19-b2b-pickup-images-merge", + "date": "2026-11-19", + "type": "updated", + "summary": "B2B 提货照片收敛到提货接口:取消独立维护接口 order.setB2bPickupImages,改为提货时随单提交 file_id", + "methods": [ + "order.pickupB2b" + ], + "notes": [ + "删除 order.setB2bPickupImages:提货照片不再提供独立的全量维护接口,避免一个业务两个入口。", + "order.pickupB2b 入参 pickup_file_ids(兼容 pickupFileIds / file_ids / fileIds / pickup_images)保持有效:上传接口已返回文件ID,提货时一并提交即可。", + "校验口径:只做一轮存在性校验(wms_file 命中且 is_deleted=false,不校验仓库归属),缺失则整个提货事务回滚并返回 B2B_IMAGE_FILE_INVALID。", + "落库口径:写入 wms_file_reference(business_type=b2b_pickup,display_order 顺延已有最大序号),追加语义、重复提交同一批 file_id 幂等。", + "明细与列表的 pickup_images 字段保持不变(order.pendingOrder.detail / order.deliveryOrder.detail / order.pendingOrder2b.list / order.deliveryOrder2b.list)。" + ] + }, + { + "version": "2026.11.19-b2b-pickup-images", + "date": "2026-11-19", + "type": "added", + "summary": "新增 B2B 提货照片:order.setB2bPickupImages;order.pickupB2b 支持提货时追加照片;明细/列表新增 pickup_images 字段", + "methods": [ + "order.setB2bPickupImages", + "order.pickupB2b", + "order.updateB2bOrderImages", + "order.pendingOrder.detail", + "order.deliveryOrder.detail", + "order.pendingOrder2b.list", + "order.deliveryOrder2b.list" + ], + "notes": [ + "新增 order.setB2bPickupImages:单订单全量覆盖提货照片,business_type=b2b_pickup;文件只做一轮存在性校验(不校验仓库归属);仅 B2B 且未取消订单可更新,提货前预传与提货后补传均允许。", + "order.pickupB2b 新增可选入参 pickup_file_ids / pickupFileIds / file_ids / fileIds / pickup_images(追加语义),响应新增 pickup_images 与 pickup_image_count。", + "业务类型区分:备货照片保持 b2b_order(order.updateB2bOrderImages 文案同步改为「备货留证照片」),提货照片使用 b2b_pickup,两者互不覆盖。", + "明细与列表输出:order.pendingOrder.detail / order.deliveryOrder.detail / order.pendingOrder2b.list / order.deliveryOrder2b.list 新增 pickup_images(与 images 一次查询后按业务类型分组,无 N+1)。", + "操作日志新增 ORDER_B2B_PICKUP_IMAGES(更新B2B提货照片);order.pickupB2b 的 ORDER_B2B_PICKUP 日志 extras 增加 pickup_file_ids。" + ] + }, + { + "version": "2026.11.18-b2b-pickup-plate", + "date": "2026-11-18", + "type": "added", + "summary": "新增 B2B 提货车牌录入/修改:order.setB2bPickupPlate;order.pickupB2b 支持提货时顺带写入车牌", + "methods": [ + "order.setB2bPickupPlate", + "order.pickupB2b" + ], + "notes": [ + "order.setB2bPickupPlate:单订单作业,仅 B2B 订单且未取消可录入;提货后车牌锁定不允许修改;传空字符串或 null 清空;车牌去空格/分隔符并转大写后落库,值变化写 ORDER_B2B_PICKUP_PLATE 操作日志。", + "order.pickupB2b:新增可选入参 pickup_plate_number / pickupPlateNumber,同一事务内随提货写入车牌;响应新增 pickup_plate_number。已提货订单传入不同车牌返回 failure 400。", + "车牌基础校验:首字符为汉字或字母、整体 5~10 位的汉字/字母/数字组合,兼容军牌、使领馆牌、挂车等特殊牌照,仅拦截明显无效输入。", + "字段复用说明:wms_order_b2b.pickup_plate_number 此前只有模型/列表/筛选,没有写入入口,本次补齐写入链路。" + ] + }, + { + "version": "0.3.374-b2b-detail-fields", + "date": "2026-11-18", + "type": "updated", + "summary": "order.pendingOrder.detail / order.deliveryOrder.detail 为 B2B 订单附加副表作业明细 b2b 与订单图片 images", + "methods": [ + "order.pendingOrder.detail", + "order.deliveryOrder.detail" + ], + "notes": [ + "变更:两个详情接口在响应顶层新增 b2b(wms_order_b2b 作业明细对象)与 images(B2B 订单图片数组);仅 is_b2b=Y 的订单查询副表与图片,非 B2B 订单 b2b=null、images=[],结构稳定、不额外查库。", + "b2b 字段:total_box_count / pickup_plate_number / prep_remark / prep_duration_seconds / prep_status / prep_operator_id / prep_operator_name / prep_start_at / is_urgent / is_picked_up / picked_up_at / created_at / prep_at;副表行缺失时输出空值占位(与 B2B 列表口径一致)。", + "images 字段:wms_file_reference business_type=b2b_order,按 display_order、id 升序,元素 { id: file_id, url, display_order };与 order.pendingOrder2b.list / order.deliveryOrder2b.list 的行内 images 同源。", + "实现:app/service/systemMethods/order/base.js 新增 formatB2bDetailFields(列表/详情共用字段映射)与 buildB2bDetailExtras(is_b2b=Y 时查副表 + 图片),由 base.js#detail 与 pendingOrder.js#detail 返回前调用;列表 attachB2bJobDetail 改为复用同一映射,避免两处字段漂移。" + ] + }, + { + "version": "0.3.373-b2b-pickup-outbound-status", + "date": "2026-11-18", + "type": "updated", + "summary": "order.pickupB2b 提货即出库完成:写主表 outbound_status=fin / step=4 / delivery_time,触发出库迁移到配送表", + "methods": [ + "order.pickupB2b" + ], + "notes": [ + "变更:提货成功时在同一事务内把订单所在分表(current 优先、dispatch 兜底,按 modelMap 精确定位)的 outbound_status 置 fin、step 置 4、delivery_time 置提货时间、updated_at 置当前时间,与 order.markOutboundOrder 的出库口径一致。", + "迁移触发:定时任务 schedule/sync_outbound_orders_to_delivery 按 outbound_status IN (fin,padding) 且 step IN (4,9) 选源,因此提货后无需人工干预即会迁移到配送表(dispatch_lane=m4),order.deliveryOrder2b.list 可见;迁移脚本本身不做任何 B2B 特判。", + "统计联动:warehouse_panel#queryB2b(B2B 今日出库)按 outbound_status=fin + delivery_time 当日统计,此前 B2B 从不写这两个字段导致统计恒为 0,本次一并修复。", + "历史数据自愈:is_picked_up=Y 但主表未出库的订单重复调用提货时,按首次 picked_up_at 补写 delivery_time,不重复写 ORDER_B2B_PICKUP 日志;已出库则跳过(outbound_marked=false)。", + "响应新增 outbound_status / step / outbound_marked 三个字段。", + "实现:app/service/systems/order_b2b.js#pickupOrdersB2b、#loadPrepTargets(新增 modelMap 与 outbound_status/step/delivery_time 查询字段)。" + ] + }, { "version": "0.3.373-express-interface-goods-description", "date": "2026-11-18", diff --git a/methods/system.json b/methods/system.json index 6f769b3..c75b2e7 100644 --- a/methods/system.json +++ b/methods/system.json @@ -1,8 +1,8 @@ { "module": "system", "description": "系统接口标准入口,method 对应系统内置方法,全部使用 POST 请求,参数统一放在 body 内", - "version": "0.3.372", - "updatedAt": "2026-11-18", + "version": "0.3.375", + "updatedAt": "2026-11-19", "headers": [ { "name": "platform", @@ -4242,12 +4242,157 @@ "时间口径:prep_at 取服务端提交时刻;prep_duration_seconds = max(0, round((prep_at - prep_start_at)/1000)),prep_start_at 缺失时沿用原值(通常为 0)。", "操作日志:每个订单写一条 ORDER_B2B_PREP_FINISH(操作名称「备货完成」),提交后写入,失败仅告警。", "配套接口:order.startB2bPrep / order.cancelB2bPrep;列表侧 order.pendingOrder2b.list、order.deliveryOrder2b.list 输出 prep_status / prep_operator_id / prep_operator_name / prep_start_at 等字段并支持筛选。", - "库存扣减口径(与拣货完成一致):备货完成在同一事务内按 wms_picking(order_id + warehouse_id + status=pending + 未删除,FOR UPDATE)汇总各 storage_id 数量 → 校验 wms_storage.locked_quantity 足够(不足直接失败回滚)→ 同时扣减 locked_quantity 与 quantity → 写入 wms_storage_transaction(transaction_type=OUTBOUND、order_type=PICK_OUTBOUND、order_id=订单ID、operator 为当前工号、remark=备货完成出库(B2B))→ 把 wms_picking 置 fin。订单无 pending 拣货记录时(未走拣货流程或已扣减过)不做任何库存变更,备货仍正常完成。" + "库存扣减口径(与拣货完成一致):备货完成在同一事务内按 wms_picking(order_id + warehouse_id + status=pending + 未删除,FOR UPDATE)汇总各 storage_id 数量 → 校验 wms_storage.locked_quantity 足够(不足直接失败回滚)→ 同时扣减 locked_quantity 与 quantity → 写入 wms_storage_transaction(transaction_type=OUTBOUND、order_type=PICK_OUTBOUND、order_id=订单ID、operator 为当前工号、remark=备货完成出库(B2B))→ 把 wms_picking 置 fin。订单无 pending 拣货记录时(未走拣货流程或已扣减过)不做任何库存变更,备货仍正常完成。", + "分箱齐套校验:读取当前仓库 subject_config.b2b_packing_quantity_check(默认 false);开启后,备货完成时逐个 wms_order_items 明细行校验 wms_order_b2b_items.quantity 合计等于 plan_qty,并校验 total_box_count 等于分箱箱号数,任一不符返回 failure 400(data.item_mismatches 带商品行、应拣与已分箱数量),事务回滚,不完成备货。" + ] + }, + { + "method": "order.updateB2bPackingItems", + "description": "全量更新单个 B2B 订单的分箱商品明细。每条记录关联订单商品明细 order_item_id,并保存箱号 box_no 与该箱数量 quantity;本接口按整单全量替换,items 传空数组可清空,同时按不同箱号数同步 wms_order_b2b.total_box_count。仅当前仓库的 B2B 且备货中的订单可更新。", + "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(仅允许传 1 个;支持单值或单元素数组)" + }, + { + "name": "items", + "type": "array", + "required": true, + "source": "body", + "description": "完整分箱明细数组,最多 10000 条;每项包含 order_item_id(订单商品明细ID)、box_no(箱号,最长 50 字符)、quantity(该商品在该箱的正整数数量);同一商品行与箱号不能重复。支持驼峰别名 orderItemId / boxNo。" + } + ], + "response": [ + { + "name": "order_id", + "type": "number", + "required": true, + "description": "订单ID" + }, + { + "name": "item_count", + "type": "number", + "required": true, + "description": "本次保存的分箱明细行数" + }, + { + "name": "box_count", + "type": "number", + "required": true, + "description": "不同箱号的数量" + } + ], + "errors": [ + { + "code": "400", + "message": "订单ID、items 或分箱明细格式不合法;订单非 B2B、已取消、未备货中或商品行不属于该订单" + } + ], + "notes": [ + "数据表 wms_order_b2b_items 按 warehouse_id + order_id 隔离,关联订单明细 ID;更新在事务内先删除该订单旧分箱行,再写入新快照,并同步总箱数。", + "分箱数量和应拣数量是否必须相等由仓库配置 subject_config.b2b_packing_quantity_check 控制;本接口只校验数据格式与商品行归属。" + ] + }, + { + "method": "order.getB2bPackingSnapshot", + "description": "查询单个 B2B 订单的商品明细与分箱快照。商品明细返回应拣数量、已分箱数量、对应箱号/箱内数量,以及该商品需要从哪些储位取货(取货储位来自订单储位分配表 wms_picking);同时返回订单号、订单状态、备货状态、总箱数、取货储位数量与当前仓库是否开启齐套校验。", + "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(仅允许传 1 个;支持单值或单元素数组)" + } + ], + "response": [ + { + "name": "order_id", + "type": "number", + "required": true, + "description": "订单ID" + }, + { + "name": "delivery_order_code", + "type": "string", + "required": true, + "description": "发货单号" + }, + { + "name": "status", + "type": "string", + "required": false, + "description": "订单状态" + }, + { + "name": "prep_status", + "type": "string", + "required": true, + "description": "备货状态,无作业明细时为 none" + }, + { + "name": "total_box_count", + "type": "number", + "required": true, + "description": "订单总箱数" + }, + { + "name": "pick_location_count", + "type": "number", + "required": true, + "description": "取货储位数量(本单 wms_picking 涉及的不同储位个数),未分配储位时为 0" + }, + { + "name": "require_packing_quantity_match", + "type": "boolean", + "required": true, + "description": "当前仓库是否启用分箱数量齐套校验" + }, + { + "name": "items", + "type": "array", + "required": true, + "description": "订单商品明细数组;每项含 order_item_id、item_id、stock_id、item_code、item_name、item_snapshot、plan_qty、packed_quantity、boxes({box_no, quantity} 数组)、pick_locations(取货储位数组)" + } + ], + "errors": [ + { + "code": "400", + "message": "订单ID不合法、订单不存在或订单不是 B2B" + } + ], + "notes": [ + "先查当前订单分表,未命中时查配送分表;商品明细从对应分表读取,分箱数据按 warehouse_id + order_id 读取。", + "该接口返回只读完整快照;提交变更请使用 order.updateB2bPackingItems。", + "取货储位口径:按 warehouse_id + order_id 查询 wms_picking(订单储位分配结果,排除 status=cancel),按 order_item_id 分到每个商品明细行,同一商品在同一储位(space_id,缺失时退回 space_name)的多条分配记录合并为一条并累加数量,按库位名称升序输出 pick_locations:[{ space_id, space_name, quantity }];pick_location_count 为本单涉及的不同储位个数,未分配储位时 items[].pick_locations 输出空数组、pick_location_count 为 0。" ] }, { "method": "order.pickupB2b", - "description": "B2B 提货(仅 B2B 订单,单订单作业)。传入单个订单ID,记录提货时间:把 wms_order_b2b.is_picked_up 置为 'Y'、picked_up_at 置为提交时刻(即提货时间)。要求订单为 B2B(is_b2b=Y)、未取消,且备货已完成(prep_status=fin);已提货订单重复调用幂等成功并返回首次提货时间。订单先在 current 分表查找,未命中兜底 dispatch 分表。提货时间写入后,order.pendingOrder2b.list / order.deliveryOrder2b.list 的 is_picked_up、picked_up_at 字段立即反映。", + "description": "B2B 提货(仅 B2B 订单,单订单作业)。传入单个订单ID,记录提货时间:把 wms_order_b2b.is_picked_up 置为 'Y'、picked_up_at 置为提交时刻(即提货时间)。要求订单为 B2B(is_b2b=Y)、未取消,且备货已完成(prep_status=fin);已提货订单重复调用幂等成功并返回首次提货时间。订单先在 current 分表查找,未命中兜底 dispatch 分表。提货时间写入后,order.pendingOrder2b.list / order.deliveryOrder2b.list 的 is_picked_up、picked_up_at 字段立即反映。提货即出库完成:同一事务内把订单所在分表(current 优先、dispatch 兜底)的 outbound_status 置 fin、step 置 4、delivery_time 置提货时间,由既有出库迁移调度(schedule/sync_outbound_orders_to_delivery:outbound_status IN (fin,padding) 且 step IN (4,9))把订单搬到配送表(dispatch_lane=m4),随后可从 order.deliveryOrder2b.list 查询;大屏 B2B 今日出库统计(outbound_status=fin + delivery_time 当日)同步生效。已提货但主表未完成出库的历史订单,重复调用会按首次提货时间补写(自愈),不重复写操作日志。可选传 pickup_plate_number 与 pickup_file_ids:车牌在同一事务内写入提货车牌(归一化后落库),提货照片只做存在性校验后追加到 business_type=b2b_pickup 的关联下;提货完成后车牌随提货锁定,不允许再改。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -4265,6 +4410,20 @@ "required": true, "source": "body", "description": "订单ID(单订单作业,仅允许传 1 个;支持单值或单元素数组)。取值优先级:ids > order_ids > orderIds > id > order_id > orderId;传多个订单ID返回 failure 400「提货仅支持单个订单,请单条提交」。" + }, + { + "name": "pickup_plate_number / pickupPlateNumber", + "type": "string", + "required": false, + "source": "body", + "description": "提货车牌(可选)。传空字符串或 null 表示清空;归一化规则:去掉空格与 ·/•/-/-/_ 分隔符并转大写,首字符须为汉字或字母、整体 5~10 位(兼容军牌、使领馆牌、挂车等特殊牌照)。订单已提货时传与原车牌不同的值返回 failure 400。" + }, + { + "name": "pickup_file_ids / pickupFileIds / file_ids / fileIds / pickup_images", + "type": "array|array", + "required": false, + "source": "body", + "description": "提货照片 file_id 列表(可选)。上传接口(index/ajax/upload 等)返回 file_id 后,提货时随单一次性提交即可,无需再调其它接口维护。元素支持 file_id 或 { file_id, display_order };只做一轮存在性校验(wms_file 未删除、不校验仓库归属),通过后追加写入 business_type=b2b_pickup 的关联,不覆盖已有提货照片;不传则不写任何照片。" } ], "response": [ @@ -4280,6 +4439,24 @@ "required": true, "description": "提货时间:本次写入时为提交时刻;已提货幂等命中时为首次提货时间" }, + { + "name": "pickup_plate_number", + "type": "string", + "required": false, + "description": "订单当前提货车牌:本次传入时为新值,未传时为库中已有值,均无车牌时为 null" + }, + { + "name": "pickup_images", + "type": "array", + "required": true, + "description": "订单当前提货照片列表(business_type=b2b_pickup),元素 { file_id, url, display_order };无照片输出空数组" + }, + { + "name": "pickup_image_count", + "type": "number", + "required": true, + "description": "订单当前提货照片数量" + }, { "name": "picked_up_order_ids", "type": "number[]", @@ -4297,6 +4474,24 @@ "type": "boolean", "required": true, "description": "是否为重复提货(true=已提货幂等命中,未改写提货时间与操作日志;false=本次首次提货)" + }, + { + "name": "outbound_status", + "type": "string", + "required": true, + "description": "提货后订单主表出库状态,固定为 fin" + }, + { + "name": "step", + "type": "number", + "required": true, + "description": "提货后订单主表步骤,固定为 4(已出库,等待迁移到配送表)" + }, + { + "name": "outbound_marked", + "type": "boolean", + "required": true, + "description": "本次调用是否写入了主表出库状态(已提货且主表已完成出库时为 false)" } ], "errors": [ @@ -4319,6 +4514,18 @@ { "code": "500", "message": "未识别到当前仓库上下文,HTTP 500,message 为「接口错误: 未识别到当前仓库上下文」" + }, + { + "code": "400", + "message": "订单已提货,不允许修改提货车牌(响应体 flag=failure、code=400,data 带 order_id 与现有 pickup_plate_number)" + }, + { + "code": "400", + "message": "车牌格式不正确 / 车牌超过 20 个字符(响应体 flag=failure、code=400,data 带 pickup_plate_number)" + }, + { + "code": "400", + "message": "提货照片文件不存在或已删除:{file_ids}(响应体 flag=failure、code=400,data.file_ids 返回缺失文件ID;整个提货事务回滚)" } ], "notes": [ @@ -4328,12 +4535,20 @@ "落库位置:wms_order_b2b 按 warehouse_id + order_id 更新 is_picked_up、picked_up_at;不改订单主表状态。", "操作日志:首次提货写一条 ORDER_B2B_PICKUP(操作名称「B2B提货」,说明「B2B订单提货」),提交后写入,失败仅告警。", "单订单口径:只接受 1 个订单ID,传多个直接 failure 400,不做部分处理;批量提货请由前端按订单循环调用。", - "配套接口:order.startB2bPrep / order.cancelB2bPrep / order.finishB2bPrep(备货作业),order.setB2bUrgent / order.cancelB2bUrgent(加急)。" + "配套接口:order.startB2bPrep / order.cancelB2bPrep / order.finishB2bPrep(备货作业),order.setB2bUrgent / order.cancelB2bUrgent(加急)。", + "出库联动(提货即出库完成):提货成功时在同一事务内更新订单所在分表 outbound_status=fin、step=4、delivery_time=提货时间、updated_at=当前时间,与 order.markOutboundOrder(手动出库)口径一致;此后由定时任务 sync_outbound_orders_to_delivery 按 outbound_status IN (fin,padding) 且 step IN (4,9) 把订单迁移到配送表(写入 dispatch_lane=m4、dispath_time),迁移脚本无需为 B2B 增加任何特判条件。", + "历史数据自愈:is_picked_up=Y 但主表 outbound_status 非 fin 或 step 非 4 的订单,再次调用提货会以首次 picked_up_at 作为 delivery_time 补写出库状态;已提货且主表已出库时不做任何更新(outbound_marked=false)。", + "为什么不把 B2B 条件加进迁移脚本:迁移是通用表搬运,按订单状态驱动(不 join 业务副表);若以 wms_order_b2b.is_picked_up 作为迁移条件,会重复业务判定、无法同时修正主表状态与 delivery_time 统计口径,且迁移后源行被删除、current 表状态与配送域语义不一致。", + "提货车牌(可选):传 pickup_plate_number / pickupPlateNumber 时,在同一事务内随提货写入 wms_order_b2b.pickup_plate_number;不传则保持库中原值不变。", + "车牌锁定口径:提货即出库,已提货订单的车牌不允许再修改——重复提货时传入与原车牌不同的值返回 failure 400「订单已提货,不允许修改提货车牌」,传入相同值时幂等成功。", + "车牌归一化与校验同 order.setB2bPickupPlate:去空格与分隔符后转大写;首字符为汉字或字母、整体 5~10 位,仅拦截明显无效输入。", + "提货前单独录入/修改车牌请使用 order.setB2bPickupPlate。", + "提货照片(可选):传 pickup_file_ids(兼容 pickupFileIds / file_ids / fileIds / pickup_images)时,在同一事务内先做一轮存在性校验,再追加写入 wms_file_reference(business_type=b2b_pickup,display_order 顺延已有最大序号);重复提货传同一批照片幂等,不会重复插入。" ] }, { "method": "order.updateB2bOrderImages", - "description": "更新 B2B 订单图片(单订单,全量覆盖)。图片关系统一落在 wms_file_reference:business_type 固定为 b2b_order、business_id 为订单ID(字符串)、warehouse_id 为当前登录仓库、display_order 控制展示顺序,文件本体复用 wms_file(不做物理删除)。传入 images 为全量覆盖语义:未包含的旧关联会被删除、新关联按列表顺序写入,传空数组表示清空该订单图片;仅 B2B 订单(is_b2b=Y)且未取消的订单可更新,订单在 current 分表优先、dispatch 分表兜底查找,文件必须属于当前仓库且未删除。", + "description": "更新 B2B 订单备货留证照片(单订单,全量覆盖)。图片关系统一落在 wms_file_reference:business_type 固定为 b2b_order(备货留证照片,与提货照片 b2b_pickup 分开存放)、business_id 为订单ID(字符串)、warehouse_id 为当前登录仓库、display_order 控制展示顺序,文件本体复用 wms_file(不做物理删除)。传入 images 为全量覆盖语义:未包含的旧关联会被删除、新关联按列表顺序写入,传空数组表示清空该订单图片;仅 B2B 订单(is_b2b=Y)且未取消的订单可更新,订单在 current 分表优先、dispatch 分表兜底查找,文件必须属于当前仓库且未删除。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -4383,7 +4598,7 @@ "name": "images", "type": "array", "required": true, - "description": "更新后的图片列表(按 display_order、id 升序)", + "description": "更新后的备货照片列表(按 display_order、id 升序)", "children": [ { "name": "file_id", @@ -4456,7 +4671,116 @@ "订单校验:仅 is_b2b=Y 的订单可更新;status=cancel 的订单不允许更新;订单查找 current 分表优先、dispatch 分表兜底(配送域 B2B 订单)。", "操作日志:成功后写一条 ORDER_B2B_IMAGES(操作名称「更新B2B订单图片」),extras 带 image_count / added_file_ids / removed_file_ids;失败仅告警不影响主流程。", "列表联动:order.pendingOrder2b.list / order.deliveryOrder2b.list 已按页批量挂载 images: [{ id: file_id, url, display_order }](按 display_order 升序),无图片输出空数组。", - "实现:app/service/systems/order_b2b.js#updateOrderImages(含 normalizeOrderImages 归一化),出口 app/service/systemMethods/order/index.js#updateB2bOrderImages;列表挂载见 app/service/systemMethods/order/base.js#attachB2bJobDetail / #attachB2bOrderImages。" + "实现:app/service/systems/order_b2b.js#updateOrderImages(含 normalizeOrderImages 归一化),出口 app/service/systemMethods/order/index.js#updateB2bOrderImages;列表挂载见 app/service/systemMethods/order/base.js#attachB2bJobDetail / #attachB2bOrderImages。", + "业务类型区分:备货照片固定 business_type=b2b_order,提货照片固定 business_type=b2b_pickup(提货时随 order.pickupB2b 传入 pickup_file_ids 写入),两者在 order.pendingOrder.detail / order.deliveryOrder.detail 中分别输出 images 与 pickup_images,互不覆盖。" + ] + }, + { + "method": "order.setB2bPickupPlate", + "description": "录入/修改 B2B 提货车牌(仅 B2B 订单,单订单作业,提货前可改)。传单个订单ID与车牌,车牌归一化(去空格与 ·/•/-/-/_ 分隔符后转大写)并写入 wms_order_b2b.pickup_plate_number;传空字符串或 null 表示清空车牌。仅 is_b2b=Y 且未取消的订单可录入,作业明细行缺失时按默认值补建。订单已提货(is_picked_up=Y)后车牌随提货锁定,不允许再修改。车牌也可在 order.pickupB2b 提货时通过 pickup_plate_number 一并写入。", + "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(单订单作业,仅允许传 1 个;支持单值或单元素数组)。取值优先级:ids > order_ids > orderIds > id > order_id > orderId;传多个订单ID返回 failure 400「录入提货车牌仅支持单个订单,请单条提交」。" + }, + { + "name": "pickup_plate_number / pickupPlateNumber", + "type": "string", + "required": true, + "source": "body", + "description": "提货车牌(键必须传;传空字符串或 null 表示清空)。归一化:去掉空格与 ·/•/-/-/_ 分隔符并转大写;基础格式校验为首字符为汉字或字母、整体 5~10 位汉字/字母/数字组合(兼容军牌、使领馆牌、挂车等特殊牌照),超长(>20 字符)或明显无效返回 failure 400。" + } + ], + "response": [ + { + "name": "order_id", + "type": "number", + "required": true, + "description": "订单ID" + }, + { + "name": "delivery_order_code", + "type": "string", + "required": true, + "description": "发货单号" + }, + { + "name": "pickup_plate_number", + "type": "string", + "required": false, + "description": "本次落库的提货车牌(归一化后);清空时为 null" + }, + { + "name": "previous_pickup_plate_number", + "type": "string", + "required": false, + "description": "修改前的提货车牌;原本无车牌时为 null" + }, + { + "name": "changed", + "type": "boolean", + "required": true, + "description": "车牌是否发生变化(false 表示与原值一致,未重复写操作日志)" + }, + { + "name": "detail_created", + "type": "boolean", + "required": true, + "description": "作业明细行是否本次补建(true=原无 wms_order_b2b 行)" + } + ], + "errors": [ + { + "code": "400", + "message": "订单ID不能为空(HTTP 仍为 200,响应体 flag=failure、code=400)" + }, + { + "code": "400", + "message": "pickup_plate_number 参数不能为空(未传该键;清空请传空字符串或 null)" + }, + { + "code": "400", + "message": "车牌格式不正确 / 车牌超过 20 个字符(响应体 flag=failure、code=400,data 带 pickup_plate_number)" + }, + { + "code": "400", + "message": "仅 B2B 订单支持录入提货车牌 / 订单不存在(响应体 flag=failure、code=400,data 带 not_b2b_order_ids 或 not_found_order_ids)" + }, + { + "code": "400", + "message": "订单已取消 / 订单已提货不允许修改提货车牌(响应体 flag=failure、code=400,data 带 order_id 与 pickup_plate_number)" + }, + { + "code": "400", + "message": "录入提货车牌仅支持单个订单,请单条提交(响应体 flag=failure、code=400,data.order_ids 返回传入的多个订单ID)" + }, + { + "code": "500", + "message": "未识别到当前仓库上下文,HTTP 500,message 为「接口错误: 未识别到当前仓库上下文」" + } + ], + "notes": [ + "单订单口径:只接受 1 个订单ID,传多个直接 failure 400,不做部分处理;批量录入请由前端按订单循环调用。", + "生效范围(仅 B2B 订单):订单必须存在于当前仓库(current 分表优先、dispatch 分表兜底)且 is_b2b=Y,否则返回 failure 400。", + "可改时机:提货前(is_picked_up=N)可反复录入/修改/清空;提货后车牌锁定,返回 failure 400「订单已提货,不允许修改提货车牌」,避免出库后留证与实物/车辆对不上。", + "落库位置:wms_order_b2b 按 warehouse_id + order_id 更新 pickup_plate_number;作业明细行缺失时按默认值补建(total_box_count=0、prep_duration_seconds=0、is_picked_up=N 等)。", + "车牌归一化:去掉空格与 ·/•/-/-/_ 分隔符并转大写,例如「 粤b·12345 」→「粤B12345」;基础格式校验为首字符为汉字或字母、整体 5~10 位(兼容军牌、使领馆牌、挂车等特殊牌照)。", + "操作日志:车牌实际发生变化时写一条 ORDER_B2B_PICKUP_PLATE(操作名称「录入B2B提货车牌」,extras 带新旧车牌),提交后写入,失败仅告警不影响主流程;值未变化不写日志。", + "列表联动:order.pendingOrder2b.list / order.deliveryOrder2b.list 的 pickup_plate_number 字段与 where.pickup_plate_number 筛选立即生效,可用于提货台按车牌找单。", + "配套接口:order.pickupB2b(提货时可用 pickup_plate_number 一并写入)、order.finishB2bPrep(备货完成)、order.updateB2bOrderImages(订单留证图片)。" ] } ] @@ -4831,7 +5155,7 @@ }, { "method": "order.pendingOrder.detail", - "description": "查询单个订单详情,返回订单头、商品明细和运单信息;忽略传入的表位参数,固定先查配送表(dispatch),查不到再兜底查询待处理表(current);运单信息强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号", + "description": "查询单个订单详情,返回订单头、商品明细和运单信息;忽略传入的表位参数,固定先查配送表(dispatch),查不到再兜底查询待处理表(current);运单信息强制同仓校验:wms_order_express 按「订单ID + 订单所属仓库ID」隔离读取,禁止仅凭订单ID跨仓串读运单号B2B 订单额外返回副表 b2b 作业明细与 images 订单图片。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -4882,6 +5206,24 @@ "type": "array", "description": "按库位平铺的储位分配明细(附商品编码、名称、规格、单位等库存信息)", "required": true + }, + { + "name": "b2b", + "type": "object|null", + "required": true, + "description": "B2B 作业明细对象(仅 is_b2b=Y 输出,非 B2B 为 null;副表无行时输出空值占位)。子字段:total_box_count / pickup_plate_number / prep_remark / prep_duration_seconds / prep_status / prep_operator_id / prep_operator_name / prep_start_at / is_urgent / is_picked_up / picked_up_at / created_at / prep_at。" + }, + { + "name": "images", + "type": "array", + "required": true, + "description": "B2B 订单备货留证照片(business_type=b2b_order),元素 { id: file_id, url, display_order };无图片输出空数组。" + }, + { + "name": "pickup_images", + "type": "array", + "required": true, + "description": "B2B 订单提货留证照片(business_type=b2b_pickup),元素 { id: file_id, url, display_order };无图片输出空数组;与 images(备货照片)分开输出。" } ], "errors": [ @@ -4897,6 +5239,10 @@ "code": "500", "message": "内部错误" } + ], + "notes": [ + "B2B 订单附加字段(仅 is_b2b=Y 的订单):b2b 为副表 wms_order_b2b 作业明细对象(total_box_count 总箱数 / pickup_plate_number 提货车牌 / prep_remark 备货备注 / prep_duration_seconds 备货用时 / prep_status 备货状态 none|padding|fin / prep_operator_id 备货人工号 / prep_operator_name 备货人姓名 / prep_start_at 备货开始时间 / is_urgent 是否加急 / is_picked_up 是否提货 / picked_up_at 提货时间 / created_at 副表创建时间 / prep_at 备货完成时间);副表行缺失时输出空值占位(total_box_count=0、prep_status=none、is_urgent=N、is_picked_up=N 等),字段结构稳定。非 B2B 订单 b2b 固定为 null。", + "images 为 B2B 订单图片数组:[{ id: file_id, url: 文件地址, display_order: 展示顺序 }],数据源 wms_file_reference(business_type=b2b_order,按 display_order、id 升序);非 B2B 或无图片时输出空数组。图片维护接口见 order.updateB2bOrderImages。" ] }, { @@ -7550,6 +7896,18 @@ "type": "string", "required": false, "description": "B2B 作业明细创建时间(wms_order_b2b.created_at),与订单自身的 create_at 不同;无作业明细行时为 null" + }, + { + "name": "images", + "type": "array", + "required": true, + "description": "B2B 订单备货留证照片(wms_file_reference business_type=b2b_order),元素 { id: file_id, url, display_order };无图片输出空数组" + }, + { + "name": "pickup_images", + "type": "array", + "required": true, + "description": "B2B 订单提货留证照片(wms_file_reference business_type=b2b_pickup),元素 { id: file_id, url, display_order };与 images(备货照片)一次查询后分组输出,无图片输出空数组" } ], "errors": [ @@ -13733,7 +14091,7 @@ }, { "method": "order.deliveryOrder.detail", - "description": "查询单个订单详情,返回订单头、商品明细和运单信息", + "description": "查询单个订单详情,返回订单头、商品明细和运单信息B2B 订单额外返回副表 b2b 作业明细与 images 订单图片。", "isNeedAuth": false, "isNeedLogin": true, "headers": [ @@ -13790,6 +14148,24 @@ "type": "array", "required": true, "description": "去重后的运单号字符串数组" + }, + { + "name": "b2b", + "type": "object|null", + "required": true, + "description": "B2B 作业明细对象(仅 is_b2b=Y 输出,非 B2B 为 null;副表无行时输出空值占位)。子字段:total_box_count / pickup_plate_number / prep_remark / prep_duration_seconds / prep_status / prep_operator_id / prep_operator_name / prep_start_at / is_urgent / is_picked_up / picked_up_at / created_at / prep_at。" + }, + { + "name": "images", + "type": "array", + "required": true, + "description": "B2B 订单备货留证照片(business_type=b2b_order),元素 { id: file_id, url, display_order };无图片输出空数组。" + }, + { + "name": "pickup_images", + "type": "array", + "required": true, + "description": "B2B 订单提货留证照片(business_type=b2b_pickup),元素 { id: file_id, url, display_order };无图片输出空数组;与 images(备货照片)分开输出。" } ], "errors": [ @@ -13805,6 +14181,10 @@ "code": "500", "message": "内部错误" } + ], + "notes": [ + "B2B 订单附加字段(仅 is_b2b=Y 的订单):b2b 为副表 wms_order_b2b 作业明细对象(total_box_count 总箱数 / pickup_plate_number 提货车牌 / prep_remark 备货备注 / prep_duration_seconds 备货用时 / prep_status 备货状态 none|padding|fin / prep_operator_id 备货人工号 / prep_operator_name 备货人姓名 / prep_start_at 备货开始时间 / is_urgent 是否加急 / is_picked_up 是否提货 / picked_up_at 提货时间 / created_at 副表创建时间 / prep_at 备货完成时间);副表行缺失时输出空值占位(total_box_count=0、prep_status=none、is_urgent=N、is_picked_up=N 等),字段结构稳定。非 B2B 订单 b2b 固定为 null。", + "images 为 B2B 订单图片数组:[{ id: file_id, url: 文件地址, display_order: 展示顺序 }],数据源 wms_file_reference(business_type=b2b_order,按 display_order、id 升序);非 B2B 或无图片时输出空数组。图片维护接口见 order.updateB2bOrderImages。" ] }, { @@ -14367,6 +14747,18 @@ "type": "string", "required": false, "description": "B2B 作业明细创建时间(wms_order_b2b.created_at),与订单自身的 create_at 不同;无作业明细行时为 null" + }, + { + "name": "images", + "type": "array", + "required": true, + "description": "B2B 订单备货留证照片(wms_file_reference business_type=b2b_order),元素 { id: file_id, url, display_order };无图片输出空数组" + }, + { + "name": "pickup_images", + "type": "array", + "required": true, + "description": "B2B 订单提货留证照片(wms_file_reference business_type=b2b_pickup),元素 { id: file_id, url, display_order };与 images(备货照片)一次查询后分组输出,无图片输出空数组" } ], "errors": [ @@ -17068,6 +17460,12 @@ "required": false, "description": "散单称重是否需要打包(flag,默认 false 关闭):开启后散单称重(订单波次范围 wave_scope 非 1 大团购/3 小团购)须处于打包中或已打包(pack_status=padding/fin);未打包或打包异常时拒绝称重并返回错误" }, + { + "name": "subject_config.b2b_packing_quantity_check", + "type": "boolean", + "required": false, + "description": "B2B备货完成是否校验逐商品分箱齐套,默认 false;开启后分箱数量合计须等于订单商品 plan_qty,且总箱数须等于箱号数" + }, { "name": "subject_config.return_unpack_max_record_minutes", "type": "number", @@ -17447,6 +17845,13 @@ "source": "body.subject_config", "description": "散单称重是否需要打包(flag,默认 false 关闭):开启后散单称重(wave_scope 非 1 大团购/3 小团购)须处于打包中或已打包(pack_status=padding/fin)。仅接受布尔/like-flag(true/1/'1'/'true' → true;false/0/'0'/'false' → false),非法值报 400:subject_config.single_weigh_require_pack 必须是布尔值" }, + { + "name": "subject_config.b2b_packing_quantity_check", + "type": "boolean", + "required": false, + "source": "body.subject_config", + "description": "B2B备货完成是否校验逐商品分箱齐套,默认 false。仅接受布尔/like-flag(true/1/'1'/'true' → true;false/0/'0'/'false' → false),非法值报 400" + }, { "name": "subject_config.return_unpack_max_record_minutes", "type": "number", diff --git a/test/app/controller/system.order.pendingOrder.reverseReviewOrder.test.js b/test/app/controller/system.order.pendingOrder.reverseReviewOrder.test.js index ca0f4b6..181c46a 100644 --- a/test/app/controller/system.order.pendingOrder.reverseReviewOrder.test.js +++ b/test/app/controller/system.order.pendingOrder.reverseReviewOrder.test.js @@ -378,6 +378,70 @@ describe('test/app/controller/system.order.pendingOrder.reverseReviewOrder.test. ); }); + it('should reject reversing when any order is B2B and keep all orders unchanged', async () => { + const { service, capture } = createPendingOrderService(buildRows(3, index => ({ + id: index + 1, + warehouse_id: 100000, + step: 1, + inspection_status: 'fin', + is_b2b: index === 1 ? 'Y' : 'N', + updated_at: '2026-04-12 00:00:00', + }))); + + await assert.rejects( + async () => await service.reverseReviewOrder({ + ids: [ 1, 2, 3 ], + }), + /B2B 订单不支持反审回待审核(订单\[2\]),操作不生效/ + ); + + // 整批驳回:不更新任何订单 + assert.equal(capture.updateValues, undefined); + for (const row of capture.rows) { + assert.equal(row.inspection_status, 'fin'); + assert.equal(row.step, 1); + } + }); + + it('should reverse orders when is_b2b is null or N', async () => { + const { service, capture } = createPendingOrderService(buildRows(2, index => ({ + id: index + 1, + warehouse_id: 100000, + step: 1, + inspection_status: 'fin', + is_b2b: index === 0 ? null : 'N', + updated_at: '2026-04-12 00:00:00', + }))); + + const result = await service.reverseReviewOrder({ ids: [ 1, 2 ] }); + + assert.equal(capture.updateValues.inspection_status, 'none'); + assert.equal(result.updated_count, 2); + }); + + it('should reject cloning a B2B order without cancelling it', async () => { + const { service, capture } = createPendingOrderService(buildRows(1, () => ({ + id: 9, + warehouse_id: 100000, + step: 1, + status: 'created', + inspection_status: 'fin', + is_b2b: 'Y', + storage_status: 'none', + updated_at: '2026-04-12 00:00:00', + }))); + + await assert.rejects( + async () => await service.cloneOrder({ order_id: 9 }), + /B2B 订单不支持克隆订单(订单\[9\]),操作不生效/ + ); + + // 原订单未被取消 + assert.equal(capture.updateValues, undefined); + assert.equal(capture.rows[0].status, 'created'); + assert.equal(capture.rows[0].step, 1); + }); + it('should write back to pending review status', async () => { const { service, capture } = createPendingOrderService(buildRows(1, index => ({ id: index + 1, diff --git a/test/app/service/systemMethods/order/wave.singleFetchByIds.test.js b/test/app/service/systemMethods/order/wave.singleFetchByIds.test.js index a2c5fd0..42e90c7 100644 --- a/test/app/service/systemMethods/order/wave.singleFetchByIds.test.js +++ b/test/app/service/systemMethods/order/wave.singleFetchByIds.test.js @@ -309,20 +309,51 @@ describe('test/app/service/systemMethods/order/wave.singleFetchByIds.test.js', ( assert.deepEqual(result.skipped_order_ids, []); }); - it('should still exclude B2B and intercepted orders while allowing SN orders', async () => { + it('should still fetch SN orders while excluding intercepted orders', async () => { const { service } = createHarness({ orders: [ { id: 501, wave_id: 0, wave_no: '', step: 1, status: 'new', outbound_status: 'none', has_sn_item: 'Y' }, - { id: 502, wave_id: 0, wave_no: '', step: 1, status: 'new', outbound_status: 'none', is_b2b: 'Y' }, { id: 503, wave_id: 0, wave_no: '', step: 1, status: 'new', outbound_status: 'none', intercept_status: 'padding' }, ], }); - const result = await service.singleFetchByIds({ ids: [ 501, 502, 503 ] }); + const result = await service.singleFetchByIds({ ids: [ 501, 503 ] }); assert.deepEqual(result.fetched_order_ids, [ 501 ]); - assert.deepEqual(result.excluded_b2b_order_ids, [ 502 ]); assert.deepEqual(result.excluded_intercepted_order_ids, [ 503 ]); assert.deepEqual(result.excluded_sn_order_ids, []); }); + + it('should reject the whole request when any B2B order is included', async () => { + const { service, state } = createHarness({ + orders: [ + { id: 601, wave_id: 0, wave_no: '', step: 1, status: 'new', outbound_status: 'none' }, + { id: 602, wave_id: 0, wave_no: '', step: 1, status: 'new', outbound_status: 'none', is_b2b: 'Y' }, + { id: 603, wave_id: 0, wave_no: '', step: 1, status: 'new', outbound_status: 'none', is_b2b: 'N' }, + ], + }); + + await assert.rejects( + async () => await service.singleFetchByIds({ ids: [ 601, 602, 603 ] }), + /B2B 订单不支持抓取散单(订单\[602\]),操作不生效/ + ); + + // 整批驳回:不建波次、不写订单日志,事务回滚 + assert.equal(state.createWaveCalls.length, 0); + assert.equal(state.orderLogItems.length, 0); + assert.equal(state.committed, false); + assert.equal(state.rolledBack, true); + }); + + it('should treat null is_b2b as non B2B order', async () => { + const { service } = createHarness({ + orders: [ + { id: 701, wave_id: 0, wave_no: '', step: 1, status: 'new', outbound_status: 'none', is_b2b: null }, + ], + }); + + const result = await service.singleFetchByIds({ ids: [ 701 ] }); + + assert.deepEqual(result.fetched_order_ids, [ 701 ]); + }); }); diff --git a/test/app/service/systems/order_b2b_packing.test.js b/test/app/service/systems/order_b2b_packing.test.js new file mode 100644 index 0000000..eab423f --- /dev/null +++ b/test/app/service/systems/order_b2b_packing.test.js @@ -0,0 +1,218 @@ +'use strict'; + +const assert = require('assert'); +const OrderB2bService = require('../../../../app/service/systems/order_b2b'); + +describe('OrderB2bService packing quantity validation', () => { + function createService({ orderItems, packedItems }) { + const service = Object.create(OrderB2bService.prototype); + service.ctx = { + model: { + OrderItemsFactory: { + getCurrentModel: async () => ({ + findAll: async () => orderItems, + }), + }, + OrderB2bItem: { + findAll: async () => packedItems, + }, + }, + }; + return service; + } + + it('accepts exact per-line quantities and matching carton count', async () => { + const service = createService({ + orderItems: [ + { id: 11, item_code: 'SKU-A', item_name: '商品A', plan_qty: 3 }, + { id: 12, item_code: 'SKU-B', item_name: '商品B', plan_qty: 1 }, + ], + packedItems: [ + { order_item_id: 11, box_no: 'A01', quantity: 2 }, + { order_item_id: 11, box_no: 'A02', quantity: 1 }, + { order_item_id: 12, box_no: 'A02', quantity: 1 }, + ], + }); + + const result = await service.assertB2bPackingQuantityComplete({ + warehouseId: 7, + orderId: 99, + sourceType: 'current', + totalBoxCount: 2, + transaction: { LOCK: { UPDATE: 'UPDATE' } }, + }); + assert.deepStrictEqual(result, { boxCount: 2 }); + }); + + it('rejects underpacked product lines with per-item mismatch details', async () => { + const service = createService({ + orderItems: [ + { id: 11, item_code: 'SKU-A', item_name: '商品A', plan_qty: 3 }, + ], + packedItems: [ + { order_item_id: 11, box_no: 'A01', quantity: 2 }, + ], + }); + + await assert.rejects( + service.assertB2bPackingQuantityComplete({ + warehouseId: 7, + orderId: 99, + sourceType: 'current', + totalBoxCount: 1, + transaction: { LOCK: { UPDATE: 'UPDATE' } }, + }), + error => { + assert.strictEqual(error.code, 'B2B_PREP_PACKING_INCOMPLETE'); + assert.deepStrictEqual(error.data.item_mismatches, [ + { + order_item_id: 11, + item_code: 'SKU-A', + item_name: '商品A', + expected_quantity: 3, + packed_quantity: 2, + }, + ]); + return true; + } + ); + }); + + it('replaces all packing rows only with item lines from the target order', async () => { + const transaction = { + LOCK: { UPDATE: 'UPDATE' }, + commit: async () => {}, + rollback: async () => {}, + }; + const deleted = []; + const created = []; + const service = Object.create(OrderB2bService.prototype); + service.ctx = { + model: { + transaction: async () => transaction, + OrderItemsFactory: { + getCurrentModel: async () => ({ + findAll: async () => [{ id: 11 }], + }), + }, + OrderB2bItem: { + destroy: async options => deleted.push(options), + bulkCreate: async (rows, options) => created.push({ rows, options }), + }, + OrderB2b: { + update: async () => {}, + }, + }, + }; + service.loadPrepTargets = async () => ({ + rowMap: new Map([[ 99, { is_b2b: 'Y', status: 'pending' }]]), + b2bMap: new Map([[ 99, { prep_status: 'padding' }]]), + sourceTypeMap: new Map([[ 99, 'current' ]]), + }); + service.assertPrepOrders = () => {}; + service.writePrepOperationLogs = async () => {}; + + const result = await service.updateB2bPackingItems({ + warehouseId: 7, + orderIds: [ 99 ], + items: [ + { order_item_id: 11, box_no: 'A01', quantity: 2 }, + ], + }); + + assert.deepStrictEqual(result, { order_id: 99, item_count: 1, box_count: 1 }); + assert.deepStrictEqual(deleted[0].where, { warehouse_id: 7, order_id: 99 }); + assert.strictEqual(created[0].rows[0].order_item_id, 11); + assert.strictEqual(created[0].rows[0].quantity, 2); + assert.strictEqual(created[0].options.transaction, transaction); + }); + + it('returns per-item pick locations from wms_picking merged by space', async () => { + const transaction = { commit: async () => {}, rollback: async () => {} }; + const pickQueries = []; + const service = Object.create(OrderB2bService.prototype); + service.app = { Sequelize: { Op: { ne: Symbol('ne') } } }; + service.ctx = { + model: { + transaction: async () => transaction, + OrderDeliveryFactory: { + getCurrentModel: async () => ({ + findOne: async () => ({ id: 99, is_b2b: 'Y', status: 'pending', delivery_order_code: 'DO-99' }), + }), + }, + OrderItemsFactory: { + getCurrentModel: async () => ({ + findAll: async () => [ + { id: 11, item_code: 'SKU-A', item_name: '商品A', plan_qty: 3 }, + { id: 12, item_code: 'SKU-B', item_name: '商品B', plan_qty: 1 }, + ], + }), + }, + OrderB2bItem: { findAll: async () => [{ order_item_id: 11, box_no: 'A01', quantity: 3 }] }, + OrderB2b: { findOne: async () => ({ prep_status: 'padding', total_box_count: 1 }) }, + Picking: { + findAll: async options => { + pickQueries.push(options); + return [ + { order_item_id: 11, space_id: 31, space_name: 'B-02-01', quantity: 2 }, + { order_item_id: 11, space_id: 30, space_name: 'A-01-01', quantity: 1 }, + { order_item_id: 11, space_id: 31, space_name: 'B-02-01', quantity: 1 }, + { order_item_id: 12, space_id: 30, space_name: 'A-01-01', quantity: 1 }, + { order_item_id: 12, space_id: null, space_name: '', quantity: 1 }, + ]; + }, + }, + }, + }; + service.isB2bPackingQuantityCheckEnabled = async () => false; + + const result = await service.getB2bPackingSnapshot({ warehouseId: 7, orderIds: [ 99 ] }); + + assert.strictEqual(pickQueries.length, 1); + assert.deepStrictEqual(pickQueries[0].where, { + warehouse_id: 7, + order_id: 99, + status: { [service.app.Sequelize.Op.ne]: 'cancel' }, + }); + assert.strictEqual(result.pick_location_count, 3); + assert.deepStrictEqual(result.items[0].pick_locations, [ + { space_id: 30, space_name: 'A-01-01', quantity: 1 }, + { space_id: 31, space_name: 'B-02-01', quantity: 3 }, + ]); + assert.deepStrictEqual(result.items[1].pick_locations, [ + { space_id: null, space_name: null, quantity: 1 }, + { space_id: 30, space_name: 'A-01-01', quantity: 1 }, + ]); + }); + + it('outputs empty pick locations when the order has no allocation rows', async () => { + const transaction = { commit: async () => {}, rollback: async () => {} }; + const service = Object.create(OrderB2bService.prototype); + service.app = { Sequelize: { Op: { ne: Symbol('ne') } } }; + service.ctx = { + model: { + transaction: async () => transaction, + OrderDeliveryFactory: { + getCurrentModel: async () => ({ + findOne: async () => ({ id: 99, is_b2b: 'Y', status: 'pending', delivery_order_code: 'DO-99' }), + }), + }, + OrderItemsFactory: { + getCurrentModel: async () => ({ + findAll: async () => [{ id: 11, item_code: 'SKU-A', item_name: '商品A', plan_qty: 1 }], + }), + }, + OrderB2bItem: { findAll: async () => [] }, + OrderB2b: { findOne: async () => null }, + Picking: { findAll: async () => [] }, + }, + }; + service.isB2bPackingQuantityCheckEnabled = async () => false; + + const result = await service.getB2bPackingSnapshot({ warehouseId: 7, orderIds: [ 99 ] }); + + assert.strictEqual(result.pick_location_count, 0); + assert.deepStrictEqual(result.items[0].pick_locations, []); + assert.strictEqual(result.items[0].packed_quantity, 0); + }); +});