liufumingren b07d7bca33 feat(stockout): 出库单转订单全链路(receiverInfo 落库、出库单默认快递、updateInfo、TRANSFERRED)
- toOrder:create_channel=STOCKOUT、库存锁转移、收货必填校验、同快递/兜底平台、转单后置 TRANSFERRED(禁止一键出库)

- stockout.create:解析 receiverInfo 13 字段落库,快递兜底改用出库单默认快递(stockout_default_express_code,默认 ZT 自提)

- 新增 storage.stockout.updateInfo:收货/地址/快递/平台修改,仅 CREATED/PENDING,收货缺失禁止提交

- 迁移:wms_order_stockout 新增 receiver_* 13 列、order_status 增 TRANSFERRED、source_platform 两列

- 附带:storeWarehouse.createUser、奇门取消订单配送表幂等、express_platform Uint64 打包、方法与变更文档同步
2026-08-25 23:40:42 +08:00

799 lines
29 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use strict';
const MainService = require('../../main');
/**
* 系统方法层:storage.stockout(非订单出库单)。
* 说明:直接读写 wms_order_stockout + wms_order_stockout_items 表。
*/
class StorageStockoutService extends MainService {
constructor(ctx) {
super(ctx);
const _noNeedLogin = '';
const _noNeedRight = 'list,toOrder,listItems';
const _noNeedLog = 'list,toOrder,listItems';
const _noNeedAuth = 'list,toOrder,listItems';
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
}
/**
* 出库单列表查询。
* @param {Object} data 请求体
* @param {Object} [data.where] 查询条件
* @param {Object} [data.pagination] 分页参数
* @param {Object} [data.sort] 排序参数
* @return {Promise<Object>} 统一成功包装响应
*/
async list(data = {}) {
const { ctx } = this;
const { Op } = this.app.Sequelize;
const { pagination = {}, sort = {} } = data;
const { parsed } = this.prepareWhereContext(data, {
specialFieldMap: {
quickWhere: {
bucket: 'quick',
},
},
});
const page = Math.max(Number(pagination.page) || 1, 1);
const pageSize = Math.max(Number(pagination.pageSize) || 20, 1);
const warehouseId = Number(ctx.user && ctx.user.store_id) || 0;
const OrderStockoutModel = ctx.model.OrderStockout;
const andConditions = [
{ warehouse_id: warehouseId },
{ deleted_at: null },
];
const dynamicConditions = Array.isArray(parsed && parsed.dynamicConditions) ? parsed.dynamicConditions : [];
if (dynamicConditions.length > 0) {
andConditions.push({ [Op.and]: dynamicConditions });
}
const quickWhereCondition = parsed && parsed.rawConditionsByField && parsed.rawConditionsByField.quickWhere;
const quickValue = quickWhereCondition && Object.prototype.hasOwnProperty.call(quickWhereCondition, 'value')
? quickWhereCondition.value
: null;
if (quickValue !== null && quickValue !== undefined && String(quickValue).trim() !== '') {
const keyword = String(quickValue).trim();
andConditions.push({
[Op.or]: [
{ stockout_order_code: { [Op.like]: `%${keyword}%` } },
{ remark: { [Op.like]: `%${keyword}%` } },
],
});
}
const validSortFields = [
'id',
'stockout_order_code',
'order_status',
'order_type',
'updated_at',
'created_at',
'order_create_time',
];
const sortField = validSortFields.includes(String(sort.sortField || '').trim())
? String(sort.sortField).trim()
: 'updated_at';
const sortOrder = String(sort.sortOrder || 'DESC').toUpperCase() === 'ASC' ? 'ASC' : 'DESC';
const finalWhere = { [Op.and]: andConditions };
const { count, rows } = await OrderStockoutModel.findAndCountAll({
where: finalWhere,
order: [[ sortField, sortOrder ], [ 'id', 'DESC' ]],
limit: pageSize,
offset: (page - 1) * pageSize,
raw: true,
});
return this.success('ok', {
list: rows,
pagination: {
page,
pageSize,
total: count,
totalPages: Math.ceil(count / pageSize),
hasPrevious: page > 1,
hasNext: page < Math.ceil(count / pageSize),
},
});
}
/**
* 出库单转订单。
*
* 将非订单出库单(wms_order_stockout)转为正式销售订单:
* 1. 新订单 create_channel 固定为 STOCKOUT;
* 2. 释放出库单占用的库存锁定,转由新订单重新锁定;
* 3. 转单成功后原出库单置为 CANCELLED,并记录已转订单号(幂等)。
*
* 仅 CREATED / PENDING 状态的出库单允许转单;建单失败时自动补偿恢复出库单锁定。
*
* @param {Object} data 请求体
* @param {number} data.id 出库单ID(必填)
* @param {string} [data.delivery_order_code] 新订单号,不传自动生成(SK 前缀)
* @param {Object} [data.receiverInfo] 收件人信息(name/mobile/tel/province/city/area/town/detailAddress/zipCode)
* @return {Promise<Object>} 统一成功/失败包装响应
*/
async toOrder(data = {}) {
const { ctx } = this;
const id = Number(data.id || 0);
if (!id) {
return this.fail('缺少出库单ID');
}
const warehouseId = Number(ctx.user && ctx.user.store_id) || 0;
if (warehouseId <= 0) {
return this.fail('缺少仓库上下文');
}
const order = await ctx.model.OrderStockout.findOne({
where: { id, warehouse_id: warehouseId, deleted_at: null },
});
if (!order) {
return this.fail('出库单不存在');
}
// 幂等:已转订单的出库单直接返回原订单信息
const currentExtendProps =
order.extend_props && typeof order.extend_props === 'object' && !Array.isArray(order.extend_props)
? order.extend_props
: {};
if (currentExtendProps.transferred_order_id) {
return this.success('出库单已转订单', {
id: order.id,
stockout_order_code: order.stockout_order_code,
order_id: currentExtendProps.transferred_order_id,
delivery_order_code: currentExtendProps.transferred_order_code || '',
});
}
if (![ 'CREATED', 'PENDING' ].includes(order.order_status)) {
return this.fail(`出库单当前状态(${order.order_status})不允许转订单`);
}
const items = await ctx.model.OrderStockoutItems.findAll({
where: { order_id: order.id },
order: [[ 'id', 'ASC' ]],
raw: true,
});
if (!items || items.length === 0) {
return this.fail('出库单没有明细,无法转订单');
}
// 收货信息:出库单已存的 receiver_* 字段为基础,接口传入的非空 receiverInfo 字段覆盖
const storedReceiverInfo = {
company: order.receiver_company || '',
name: order.receiver_name || '',
zipCode: order.receiver_zip_code || '',
tel: order.receiver_tel || '',
mobile: order.receiver_mobile || '',
email: order.receiver_email || '',
countryCode: order.receiver_country_code || '',
province: order.receiver_province || '',
city: order.receiver_city || '',
area: order.receiver_area || '',
town: order.receiver_town || '',
detailAddress: order.receiver_detail_address || '',
};
const passedReceiverInfo = data.receiverInfo && typeof data.receiverInfo === 'object'
? data.receiverInfo
: {};
const receiverInfo = { ...storedReceiverInfo };
for (const [ key, value ] of Object.entries(passedReceiverInfo)) {
if (value !== undefined && value !== null && String(value).trim() !== '') {
receiverInfo[key] = String(value).trim();
}
}
// 收货信息必填校验:name、(tel/mobile) 其一、省市区镇详细地址,缺失禁止转订单
const missingFields = [];
if (!String(receiverInfo.name || '').trim()) {
missingFields.push('name(收件人姓名)');
}
const receiverTel = String(receiverInfo.tel || '').trim();
const receiverMobile = String(receiverInfo.mobile || '').trim();
if (!receiverTel && !receiverMobile) {
missingFields.push('tel/mobile(固定电话或移动电话至少一项)');
}
const addressFields = [
[ 'province', '省' ],
[ 'city', '市' ],
[ 'area', '区' ],
[ 'town', '镇' ],
[ 'detailAddress', '详细地址' ],
];
for (const [ key, label ] of addressFields) {
if (!String(receiverInfo[key] || '').trim()) {
missingFields.push(`${key}(${label})`);
}
}
if (missingFields.length > 0) {
return this.fail(`收货信息缺失,不能转订单:缺少 ${missingFields.join('、')}`);
}
const stockStoreService = ctx.service.systems.stockStore;
const lockMeta = {
orderType: 'QM_STOCKOUT',
orderNo: order.stockout_order_code,
orderId: order.id,
};
// 第一步:释放出库单占用的库存锁定(新订单创建时会重新锁定)
const releaseTransaction = await ctx.model.transaction();
try {
for (const item of items) {
const qty = Number(item.plan_qty) || 0;
if (qty <= 0) continue;
const releaseResult = await stockStoreService.lockItemStorages(
item.stock_id,
-qty,
releaseTransaction,
null,
{ ...lockMeta, remark: '出库单转订单释放锁定' }
);
if (!releaseResult.success) {
throw new Error(`库存${item.stock_id}释放锁定失败: ${releaseResult.error}`);
}
}
await releaseTransaction.commit();
} catch (err) {
await releaseTransaction.rollback().catch(() => {});
ctx.logger.error(`[stockout.toOrder] 释放出库单锁定失败: ${err.message}`);
return this.fail(`转订单失败:${err.message}`);
}
// 第二步:创建订单(create_channel=STOCKOUT,内部重新锁定库存)
// 快递编码沿用出库单已解析的 express_code(系统快递编码),平台不传 sourcePlatformCode 走兜底平台
const deliveryOrderCode = String(data.delivery_order_code || '').trim()
|| `SK${Date.now()}${Math.floor(Math.random() * 9000) + 1000}`;
const orderLines = items.map((item, idx) => ({
itemCode: item.item_code || '',
itemId: Number(item.item_id) || 0,
itemName: item.item_name || '',
planQty: Number(item.plan_qty) || 0,
stockId: Number(item.stock_id) || 0,
inventoryType: item.inventory_type || '',
orderLineNo: String(item.order_line_no || idx + 1),
ownerCode: item.owner_code || '',
sourceOrderCode: order.stockout_order_code,
}));
const addOrderData = {
request: {
deliveryOrder: {
deliveryOrderCode,
orderType: order.order_type || 'QTCK',
createChannel: 'STOCKOUT',
logisticsCode: order.express_code || '',
sourcePlatformCode: order.source_platform_code || '',
receiverInfo,
remark: order.remark || '',
sourceOrderCode: order.stockout_order_code,
},
orderLines: { orderLine: orderLines },
},
};
const info = {
storeId: order.store_id,
warehouseId,
appKey: (ctx.user && ctx.user.app_key) || '',
};
let addOrderResult = null;
try {
addOrderResult = await ctx.service.systems.deliveryOrder.addOrder(addOrderData, info, 'STOCKOUT');
} catch (err) {
addOrderResult = { success: false, message: err.message, data: null };
}
const orderId = addOrderResult && addOrderResult.data && addOrderResult.data.orderId;
const isDuplicate = !!(addOrderResult && addOrderResult.success && addOrderResult.message === '订单已存在');
if (!addOrderResult || !addOrderResult.success || !orderId || isDuplicate) {
// 建单失败/订单号重复:补偿恢复出库单锁定
await this._restoreStockoutLocks(stockStoreService, items, lockMeta, ctx);
return this.fail(`转订单失败:${(addOrderResult && addOrderResult.message) || '订单创建失败'}`);
}
// 第三步:标记出库单已转订单(状态推进到 TRANSFERRED,该状态下禁止一键出库)
try {
await ctx.model.OrderStockout.update(
{
order_status: 'TRANSFERRED',
sync_message: `已转订单 ${deliveryOrderCode}`,
extend_props: {
...currentExtendProps,
transferred_order_id: orderId,
transferred_order_code: deliveryOrderCode,
transferred_at: new Date(),
},
updated_at: new Date(),
},
{ where: { id: order.id } }
);
} catch (updateErr) {
// 订单已创建成功,仅出库单标记失败:记录告警,不回滚订单
ctx.logger.error(`[stockout.toOrder] 标记出库单已转失败: ${updateErr.message}`);
}
return this.success('转订单成功', {
id: order.id,
stockout_order_code: order.stockout_order_code,
order_id: orderId,
delivery_order_code: deliveryOrderCode,
step: addOrderResult.data.step,
});
}
/**
* 转订单失败时恢复出库单库存锁定(补偿)。
* @param {Object} stockStoreService 库存服务
* @param {Array} items 出库单明细
* @param {Object} lockMeta 锁元信息
* @param {Object} ctx 请求上下文
* @return {Promise<void>} 无返回值
*/
async _restoreStockoutLocks(stockStoreService, items, lockMeta, ctx) {
const restoreTransaction = await ctx.model.transaction();
try {
for (const item of items) {
const qty = Number(item.plan_qty) || 0;
if (qty <= 0) continue;
const restoreResult = await stockStoreService.lockItemStorages(
item.stock_id,
qty,
restoreTransaction,
null,
{ ...lockMeta, remark: '出库单转订单失败恢复锁定' }
);
if (!restoreResult.success) {
throw new Error(`库存${item.stock_id}恢复锁定失败: ${restoreResult.error}`);
}
}
await restoreTransaction.commit();
} catch (err) {
await restoreTransaction.rollback().catch(() => {});
ctx.logger.error(`[stockout.toOrder] 恢复出库单锁定失败: ${err.message}`);
}
}
/**
* 出库单明细查询。
* @param {Object} data 请求体
* @param {number} [data.id] 出库单ID
* @param {string} [data.stockout_order_code] 出库单号
* @return {Promise<Object>} 统一成功包装响应
*/
async listItems(data = {}) {
const { ctx } = this;
const warehouseId = Number(ctx.user && ctx.user.store_id) || 0;
const id = Number(data.id || 0);
// 兼容 delivery_order_code 旧参数名
const stockoutOrderCode = String(data.stockout_order_code || data.delivery_order_code || '').trim();
if (!id && !stockoutOrderCode) {
return this.fail('id 或 stockout_order_code 至少传一个');
}
const OrderStockoutModel = ctx.model.OrderStockout;
const OrderStockoutItemsModel = ctx.model.OrderStockoutItems;
const where = {
warehouse_id: warehouseId,
deleted_at: null,
};
if (id > 0) {
where.id = id;
} else {
where.stockout_order_code = stockoutOrderCode;
}
const order = await OrderStockoutModel.findOne({
where,
raw: true,
});
if (!order || !order.id) {
return this.success('ok', {
order: null,
list: [],
});
}
const list = await OrderStockoutItemsModel.findAll({
where: {
order_id: order.id,
},
order: [[ 'id', 'ASC' ]],
raw: true,
});
return this.success('ok', {
order,
list,
});
}
/**
* 出库单确认(直出)。
* 不改变内部库存,直接按出库单明细的计划数量确认。
* 出站同步 taobao.qimen.stockout.confirm 成功后,状态才推进到 COMPLETED。
* 要求 express_code 已填写,否则拒绝确认。
* @param {Object} data 请求体
* @param {number} data.id 出库单ID(必填)
* @return {Promise<Object>} 统一成功/失败包装响应
*/
async confirm(data = {}) {
const { ctx } = this;
const id = Number(data.id || 0);
if (!id) {
return this.fail('缺少出库单ID');
}
const order = await ctx.model.OrderStockout.findByPk(id);
if (!order) {
return this.fail('出库单不存在');
}
if (!order.canConfirm || !order.canConfirm()) {
return this.fail(`出库单当前状态(${order.order_status})不允许确认`);
}
// 校验运单号是否已填写
if (!order.waybill_code) {
return this.fail('出库单未填写运单号(waybill_code),请先更新运单号后再确认');
}
// 第一步:事务内写入明细 actual_qty(暂不改变 order_status)
const transaction = await ctx.model.transaction();
let items;
try {
items = await ctx.model.OrderStockoutItems.findAll({
where: { order_id: id },
transaction,
});
for (const item of items) {
await item.update({
actual_qty: item.plan_qty,
updated_at: new Date(),
}, { transaction });
}
await transaction.commit();
} catch (err) {
await transaction.rollback();
ctx.logger.error('[stockout.confirm] 明细更新失败:', err);
return this.fail(`确认失败:${err.message}`);
}
// 第二步:出站通知 ERP(taobao.qimen.stockout.confirm)
const { app } = this;
let qimenSuccess = false;
let qimenMessage = '';
if (app.qimenClient && order.qimen_owner_code && order.qimen_warehouse_code) {
try {
const now = app.formatDate(new Date());
const waybillCodes = Array.isArray(order.waybill_codes) && order.waybill_codes.length > 0
? order.waybill_codes
: [ order.waybill_code ].filter(Boolean);
const outboundData = {
deliveryOrder: {
totalOrderLines: order.total_order_lines,
deliveryOrderCode: order.stockout_order_code,
deliveryOrderId: order.id,
warehouseCode: order.qimen_warehouse_code,
orderType: order.order_type,
status: 'DELIVERED',
outBizCode: order.stockout_order_code,
confirmType: 0,
orderConfirmTime: now,
operatorCode: '',
operatorName: '',
},
packages: {
package: waybillCodes.map(code => ({
logisticsCode: order.express_code || 'OTHER',
logisticsName: order.express_name || 'OTHER',
expressCode: code,
packageCode: order.stockout_order_code,
items: items.map(item => ({
itemCode: item.item_code || '',
itemId: item.item_id || '',
quantity: item.plan_qty || 0,
})),
})),
},
orderLines: items.map(item => ({
orderLineNo: item.order_line_no || '',
ownerCode: item.owner_code || order.qimen_owner_code,
itemCode: item.item_code || '',
itemId: item.item_id || '',
itemName: item.item_name || '',
planQty: item.plan_qty || 0,
actualQty: item.plan_qty || 0,
inventoryType: item.inventory_type || 'ZP',
})),
};
const sendResult = await app.qimenClient.send(
'taobao.qimen.stockout.confirm',
order.qimen_owner_code,
outboundData,
{ ctx }
);
// 解析奇门响应
const response = (sendResult && sendResult.xmlArray && sendResult.xmlArray.response)
? (Array.isArray(sendResult.xmlArray.response) ? sendResult.xmlArray.response[0] : sendResult.xmlArray.response)
: {};
qimenSuccess = String(response.flag || '').trim() === 'success';
qimenMessage = qimenSuccess ? '' : `${response.code || ''} ${response.message || '未知错误'}`.trim();
} catch (outboundErr) {
qimenMessage = outboundErr.message || '出站通知异常';
ctx.logger.error(`[stockout.confirm] 出站通知异常: ${qimenMessage}`);
}
} else {
ctx.logger.warn(`[stockout.confirm] 跳过出站通知: qimenClient=${!!app.qimenClient}, ownerCode=${order.qimen_owner_code}, warehouseCode=${order.qimen_warehouse_code}`);
}
// 第三步:根据出站结果更新状态
if (qimenSuccess) {
await ctx.model.OrderStockout.update(
{ order_status: 'COMPLETED', sync_status: 'SUCCESS', sync_message: '', updated_at: new Date() },
{ where: { id: order.id } }
);
ctx.logger.info(`[stockout.confirm] 确认完成: ${order.stockout_order_code}`);
return this.success('确认成功', {
id: order.id,
stockout_order_code: order.stockout_order_code,
order_status: 'COMPLETED',
logisticsName: 'OTHER',
expressCode: order.express_code,
expressCodes: order.express_codes,
qimenSync: 'success',
});
}
// 出站失败:更新 sync_status,order_status 不变
await ctx.model.OrderStockout.update(
{ sync_status: 'FAILED', sync_message: qimenMessage, updated_at: new Date() },
{ where: { id: order.id } }
);
ctx.logger.error(`[stockout.confirm] 出站同步失败: ${order.stockout_order_code} - ${qimenMessage}`);
return this.fail(`出站同步失败: ${qimenMessage || '未发起出站通知'}`);
}
/**
* 更新出库单快递和运单号。
* 用于在确认前填写 express_code / waybill_code / waybill_codes。
* express_code 传入后自动从系统快递表解析 express_name。
* @param {Object} data 请求体
* @param {number} data.id 出库单ID(必填)
* @param {string} [data.express_code] 快递公司编码(如 SF、STO),传入后自动解析 express_name
* @param {string} [data.waybill_code] 运单号
* @param {string[]} [data.waybill_codes] 运单号列表
* @return {Promise<Object>} 统一成功/失败包装响应
*/
async updateExpress(data = {}) {
const { ctx } = this;
const id = Number(data.id || 0);
if (!id) {
return this.fail('缺少出库单ID');
}
const order = await ctx.model.OrderStockout.findByPk(id);
if (!order) {
return this.fail('出库单不存在');
}
const updateData = { updated_at: new Date() };
// express_code:自动解析 express_name
if (data.express_code !== undefined) {
updateData.express_code = data.express_code || null;
if (data.express_code) {
try {
const expressMap = await ctx.service.systems.setting.express.getSystemExpressMap();
const info = expressMap.get(String(data.express_code).trim().toUpperCase());
updateData.express_name = info ? info.name : '';
} catch (e) {
ctx.logger.warn('[updateExpress] 解析快递名称失败: ' + e.message);
updateData.express_name = '';
}
} else {
updateData.express_name = null;
}
}
if (data.waybill_code !== undefined) {
updateData.waybill_code = data.waybill_code || null;
}
if (data.waybill_codes !== undefined) {
const codes = data.waybill_codes;
if (codes !== null && !Array.isArray(codes)) {
return this.fail('waybill_codes 必须是数组或 null');
}
updateData.waybill_codes = codes;
}
if (Object.keys(updateData).length <= 1) {
return this.fail('没有需要更新的字段');
}
await order.update(updateData);
await order.reload();
return this.success('更新成功', {
id: order.id,
stockout_order_code: order.stockout_order_code,
express_code: order.express_code,
express_name: order.express_name,
waybill_code: order.waybill_code,
waybill_codes: order.waybill_codes,
});
}
/**
* 修改出库单信息。
*
* 可修改范围:收件人(name/tel/mobile 等)、地址(province/city/area/town/detailAddress 等)、
* 快递编码(express_code,自动解析 express_name)、来源平台(source_platform_code/name)。
* 未传入的字段不修改;快递编码与平台相关字段不传即保持原值。
*
* 限制:仅 CREATED / PENDING 状态允许修改;修改后收货信息不完整(name、(tel/mobile) 其一、
* 省市区镇详细地址缺任一)时禁止提交。
*
* @param {Object} data 请求体
* @param {number} data.id 出库单ID(必填)
* @param {string} [data.name] 收件人姓名
* @param {string} [data.tel] 固定电话
* @param {string} [data.mobile] 移动电话
* @param {string} [data.company] 公司名称
* @param {string} [data.email] 电子邮箱
* @param {string} [data.zipCode] 邮编
* @param {string} [data.countryCode] 国家二字码
* @param {string} [data.province] 省份
* @param {string} [data.city] 城市
* @param {string} [data.area] 区/县
* @param {string} [data.town] 镇/街道
* @param {string} [data.detailAddress] 详细地址
* @param {string} [data.express_code] 快递公司编码(自动解析 express_name)
* @param {string} [data.source_platform_code] 来源平台编码
* @param {string} [data.source_platform_name] 来源平台名称
* @return {Promise<Object>} 统一成功/失败包装响应
*/
async updateInfo(data = {}) {
const { ctx } = this;
const id = Number(data.id || 0);
if (!id) {
return this.fail('缺少出库单ID');
}
const warehouseId = Number(ctx.user && ctx.user.store_id) || 0;
if (warehouseId <= 0) {
return this.fail('缺少仓库上下文');
}
const order = await ctx.model.OrderStockout.findOne({
where: { id, warehouse_id: warehouseId, deleted_at: null },
});
if (!order) {
return this.fail('出库单不存在');
}
if (![ 'CREATED', 'PENDING' ].includes(order.order_status)) {
return this.fail(`出库单当前状态(${order.order_status})不允许修改`);
}
const updateData = { updated_at: new Date() };
// 收件人 / 地址字段:传入才更新,空串置 NULL
const receiverFieldMap = {
receiver_name: 'name',
receiver_tel: 'tel',
receiver_mobile: 'mobile',
receiver_company: 'company',
receiver_email: 'email',
receiver_zip_code: 'zipCode',
receiver_country_code: 'countryCode',
receiver_province: 'province',
receiver_city: 'city',
receiver_area: 'area',
receiver_town: 'town',
receiver_detail_address: 'detailAddress',
receiver_id: 'id',
};
for (const [ column, param ] of Object.entries(receiverFieldMap)) {
if (data[param] !== undefined) {
updateData[column] = data[param] === null
? null
: String(data[param]).trim() || null;
}
}
// 快递编码:传入才更新,并自动解析 express_name(与 updateExpress 同口径)
if (data.express_code !== undefined) {
const expressCode = String(data.express_code || '').trim();
if (expressCode) {
let expressName = '';
try {
const expressMap = await ctx.service.systems.setting.express.getSystemExpressMap();
const info = expressMap.get(expressCode.toUpperCase());
expressName = info ? info.name : '';
} catch (e) {
ctx.logger.warn('[updateInfo] 解析快递名称失败: ' + e.message);
}
updateData.express_code = expressCode;
updateData.express_name = expressName;
} else {
updateData.express_code = null;
updateData.express_name = null;
}
}
// 来源平台:传入才更新,空串置 NULL
if (data.source_platform_code !== undefined) {
updateData.source_platform_code = String(data.source_platform_code || '').trim() || null;
}
if (data.source_platform_name !== undefined) {
updateData.source_platform_name = String(data.source_platform_name || '').trim() || null;
}
// 修改后的收货信息完整性校验:name、(tel/mobile) 其一、省市区镇详细地址必填,缺失禁止提交
const mergedReceiver = {
name: updateData.receiver_name !== undefined ? updateData.receiver_name : order.receiver_name,
tel: updateData.receiver_tel !== undefined ? updateData.receiver_tel : order.receiver_tel,
mobile: updateData.receiver_mobile !== undefined ? updateData.receiver_mobile : order.receiver_mobile,
province: updateData.receiver_province !== undefined ? updateData.receiver_province : order.receiver_province,
city: updateData.receiver_city !== undefined ? updateData.receiver_city : order.receiver_city,
area: updateData.receiver_area !== undefined ? updateData.receiver_area : order.receiver_area,
town: updateData.receiver_town !== undefined ? updateData.receiver_town : order.receiver_town,
detailAddress: updateData.receiver_detail_address !== undefined ? updateData.receiver_detail_address : order.receiver_detail_address,
};
const missingFields = [];
if (!String(mergedReceiver.name || '').trim()) {
missingFields.push('name(收件人姓名)');
}
if (!String(mergedReceiver.tel || '').trim() && !String(mergedReceiver.mobile || '').trim()) {
missingFields.push('tel/mobile(固定电话或移动电话至少一项)');
}
const addressFields = [
[ 'province', '省' ],
[ 'city', '市' ],
[ 'area', '区' ],
[ 'town', '镇' ],
[ 'detailAddress', '详细地址' ],
];
for (const [ key, label ] of addressFields) {
if (!String(mergedReceiver[key] || '').trim()) {
missingFields.push(`${key}(${label})`);
}
}
if (missingFields.length > 0) {
return this.fail(`收货信息缺失,禁止提交:缺少 ${missingFields.join('、')}`);
}
await ctx.model.OrderStockout.update(updateData, { where: { id: order.id } });
const updated = await ctx.model.OrderStockout.findByPk(order.id, { raw: true });
return this.success('修改成功', updated);
}
}
module.exports = StorageStockoutService;