WMS_MAIN/app/service/systems/order_print.js
liufumingren 9845a239e2 1
2026-05-16 02:44:53 +08:00

1391 lines
46 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 fs = require('node:fs');
const path = require('node:path');
const { Op } = require('sequelize');
const OrderBaseService = require('../systemMethods/order/base');
const PrinterDataBuilder = require('../../lib/printer_data_builder');
class OrderPrintSystemService extends OrderBaseService {
/**
* 判断当前配置是否需要补查拣货明细。
*
* 未配置时默认按类型5处理,因此也需要补查。
*
* @param {Object} policyConfig 策略配置。
* @return {boolean} 是否需要补查拣货明细。
*/
shouldLoadPickingDetails(policyConfig = {}) {
const config = this.isPlainObject(policyConfig) ? policyConfig : {};
const displayType = Object.prototype.hasOwnProperty.call(config, 'waybill_custom_display_type')
? String(config.waybill_custom_display_type || '').trim()
: '5';
return [ '2', '3', '4', '5' ].includes(displayType);
}
/**
* 归一化商品快照,兼容 JSON 字符串。
*
* @param {*} rawSnapshot 原始商品快照。
* @return {Object} 快照对象。
*/
normalizeItemSnapshot(rawSnapshot) {
if (this.isPlainObject(rawSnapshot)) {
return rawSnapshot;
}
if (typeof rawSnapshot === 'string') {
const text = rawSnapshot.trim();
if (!text) {
return {};
}
try {
const parsed = JSON.parse(text);
return this.isPlainObject(parsed) ? parsed : {};
} catch (error) {
return {};
}
}
return {};
}
/**
* 从候选字段中读取首个非空文本。
*
* @param {Object} source 源对象。
* @param {Array<string>} keys 候选键。
* @return {string} 首个非空文本。
*/
getFirstNonEmptyFieldText(source, keys = []) {
if (!this.isPlainObject(source)) {
return '';
}
for (const key of keys) {
const value = source[key];
if (value === undefined || value === null) {
continue;
}
const text = String(value).trim();
if (text) {
return text;
}
}
return '';
}
/**
* 批量补查打印所需的拣货明细。
*
* 优先使用 wms_picking.space_name,只有缺失时才查询库位表,减少额外 SQL。
*
* @param {Array<Object>} orderRows 订单列表。
* @param {number} warehouseId 仓库ID。
* @return {Promise<Map<number, Object>>} 订单ID到补齐后订单对象的映射。
*/
async buildPrintOrderRowMapWithPicking(orderRows = [], warehouseId) {
const rows = Array.isArray(orderRows) ? orderRows : [];
const orderIds = Array.from(new Set(rows
.map(row => Number(row && row.id || 0))
.filter(orderId => Number.isInteger(orderId) && orderId > 0)));
const resultMap = new Map();
if (orderIds.length === 0) {
return resultMap;
}
const pickingModel = this.ctx.model && this.ctx.model.Picking;
if (!pickingModel || typeof pickingModel.findAll !== 'function') {
return resultMap;
}
const pickingRows = await pickingModel.findAll({
where: {
order_id: {
[Op.in]: orderIds,
},
status: {
[Op.ne]: 'cancel',
},
},
attributes: [ 'id', 'order_id', 'order_item_id', 'quantity', 'space_id', 'space_name', 'status' ],
order: [[ 'order_id', 'ASC' ], [ 'id', 'ASC' ]],
raw: true,
});
const normalizedPickingRows = Array.isArray(pickingRows) ? pickingRows : [];
if (normalizedPickingRows.length === 0) {
return resultMap;
}
const orderItemIds = Array.from(new Set(normalizedPickingRows
.map(row => Number(row && row.order_item_id || 0))
.filter(orderItemId => Number.isInteger(orderItemId) && orderItemId > 0)));
const orderItemModelFactory = this.ctx.model && this.ctx.model.OrderItemsFactory;
const orderItemModel = orderItemModelFactory && typeof orderItemModelFactory.getCurrentModel === 'function'
? await orderItemModelFactory.getCurrentModel(warehouseId)
: null;
const orderItemRows = orderItemModel && typeof orderItemModel.findAll === 'function' && orderItemIds.length > 0
? await orderItemModel.findAll({
where: {
id: {
[Op.in]: orderItemIds,
},
},
attributes: [ 'id', 'order_id', 'item_code', 'item_name', 'plan_qty', 'item_snapshot' ],
raw: true,
})
: [];
const orderItemMap = new Map();
for (const row of Array.isArray(orderItemRows) ? orderItemRows : []) {
const orderItemId = Number(row && row.id || 0);
if (orderItemId > 0) {
orderItemMap.set(orderItemId, row);
}
}
const locationFallbackSpaceIds = Array.from(new Set(normalizedPickingRows
.filter(row => !String(row && row.space_name || '').trim())
.map(row => Number(row && row.space_id || 0))
.filter(spaceId => Number.isInteger(spaceId) && spaceId > 0)));
const locationModel = this.ctx.model && this.ctx.model.LocationSpace;
const locationRows = locationModel
&& typeof locationModel.findAll === 'function'
&& locationFallbackSpaceIds.length > 0
? await locationModel.findAll({
where: {
id: {
[Op.in]: locationFallbackSpaceIds,
},
warehouse_id: warehouseId,
},
attributes: [ 'id', 'space_code', 'custom_name', 'custom_barcode' ],
raw: true,
})
: [];
const locationMap = new Map((Array.isArray(locationRows) ? locationRows : [])
.map(row => [ Number(row && row.id || 0), row ]));
const pickingRowsByOrderId = new Map();
for (const row of normalizedPickingRows) {
const orderId = Number(row && row.order_id || 0);
if (orderId <= 0) {
continue;
}
const list = pickingRowsByOrderId.get(orderId) || [];
list.push(row);
pickingRowsByOrderId.set(orderId, list);
}
for (const orderRow of rows) {
const orderId = Number(orderRow && orderRow.id || 0);
const pickingList = pickingRowsByOrderId.get(orderId) || [];
if (pickingList.length === 0) {
continue;
}
const printItems = pickingList.map(pickingRow => {
const orderItemId = Number(pickingRow && pickingRow.order_item_id || 0);
const orderItemRow = orderItemMap.get(orderItemId) || {};
const itemSnapshot = this.normalizeItemSnapshot(orderItemRow.item_snapshot);
const locationRow = locationMap.get(Number(pickingRow && pickingRow.space_id || 0)) || {};
const pickLocation = this.getFirstNonEmptyFieldText({
space_name: pickingRow && pickingRow.space_name,
space_code: locationRow.space_code,
custom_name: locationRow.custom_name,
custom_barcode: locationRow.custom_barcode,
}, [ 'space_name', 'space_code', 'custom_name', 'custom_barcode' ]);
const itemName = this.getFirstNonEmptyFieldText({
snapshot_item_name: itemSnapshot.item_name,
snapshot_name: itemSnapshot.name,
snapshot_title: itemSnapshot.title,
item_name: orderItemRow.item_name,
}, [ 'snapshot_item_name', 'snapshot_name', 'snapshot_title', 'item_name' ]);
const barcode = this.getFirstNonEmptyFieldText({
barcode: itemSnapshot.barcode,
item_barcode: itemSnapshot.item_barcode,
bar_code: itemSnapshot.bar_code,
item_code: orderItemRow.item_code,
sku_code: itemSnapshot.sku_code,
sku: itemSnapshot.sku,
}, [ 'barcode', 'item_barcode', 'bar_code', 'item_code', 'sku_code', 'sku' ]);
const quantity = Number(pickingRow && pickingRow.quantity || orderItemRow.plan_qty || 0);
return {
order_item_id: orderItemId,
item_name: itemName,
barcode,
quantity: quantity > 0 ? quantity : 0,
pick_location: pickLocation,
};
}).filter(item => {
return String(item.item_name || '').trim()
|| String(item.barcode || '').trim()
|| String(item.pick_location || '').trim();
});
if (printItems.length === 0) {
continue;
}
resultMap.set(orderId, {
...orderRow,
items: JSON.stringify(printItems),
});
}
return resultMap;
}
/**
* 归一化签约策略配置,兼容缓存中的字符串形态。
*
* @param {*} rawPolicyConfig 原始策略配置。
* @return {Object} 归一化后的策略配置对象。
*/
normalizeContractPolicyConfig(rawPolicyConfig) {
if (this.isPlainObject(rawPolicyConfig)) {
return rawPolicyConfig;
}
if (typeof rawPolicyConfig === 'string') {
const text = rawPolicyConfig.trim();
if (!text) {
return {};
}
try {
const parsed = JSON.parse(text);
return this.isPlainObject(parsed) ? parsed : {};
} catch (error) {
this.ctx.logger.warn('[orderPrint.normalizeContractPolicyConfig] policy_config 解析失败: %s', error.message);
}
}
return {};
}
/**
* 获取波次打印数据。
*
* @param {Object} params 请求参数。
* @param {Array<number|string>} params.waveIds 波次ID数组。
* @param {number|string} params.warehouseId 仓库ID。
* @return {Promise<Object>} 通用打印数据结构。
*/
async getWavePrintData(params = {}) {
const requestParams = this.isPlainObject(params) ? params : {};
const {
waveIds,
warehouseId,
} = requestParams;
const normalizedWaveIds = this.normalizeWaveIds(waveIds);
if (normalizedWaveIds.length === 0) {
throw new Error('wave_ids 必填,且必须为非空数组');
}
const normalizedWarehouseId = this.resolveWarehouseId(warehouseId);
const waveRows = await this.queryWavesByIds(normalizedWarehouseId, normalizedWaveIds);
if (waveRows.length === 0) {
return this.buildEmptyResult(normalizedWaveIds);
}
const hitWaveIdSet = new Set(waveRows.map(row => Number(row.wave_id)));
const missingWaveIds = normalizedWaveIds.filter(waveId => !hitWaveIdSet.has(waveId));
const hitWaveIds = normalizedWaveIds.filter(waveId => hitWaveIdSet.has(waveId));
const orderRows = await this.queryOrdersByWaveIds(hitWaveIds, normalizedWarehouseId);
const {
validWaveIds,
filteredWaveIds,
} = this.filterFullyAssignedExpressWaves(hitWaveIds, orderRows);
return this.buildWavePrintResult({
waveRows,
orderRows,
hitWaveIds: validWaveIds,
missingWaveIds,
filteredWaveIds,
});
}
/**
* 获取波次平台打印数据中间态。
*
* 输出以波次分组为主结构(waveGroups),并在波次内按平台分组,
* 便于上游按「波次 -> 平台 -> 订单」层级批量发起打印。
*
* @param {Object} params 请求参数。
* @param {Array<number|string>} params.waveIds 波次ID数组。
* @param {number|string} params.warehouseId 仓库ID。
* @return {Promise<Object>} 平台打印中间态结果。
*/
async getWavePlatformPrintData(params = {}) {
const requestParams = this.isPlainObject(params) ? params : {};
const {
waveIds,
warehouseId,
} = requestParams;
const normalizedWaveIds = this.normalizeWaveIds(waveIds);
if (normalizedWaveIds.length === 0) {
throw new Error('wave_ids 必填,且必须为非空数组');
}
const normalizedWarehouseId = this.resolveWarehouseId(warehouseId);
const waveRows = await this.queryWavesByIds(normalizedWarehouseId, normalizedWaveIds);
if (waveRows.length === 0) {
return {
summary: {
total_waves: 0,
total_orders: 0,
total_platforms: 0,
},
waveGroups: [],
wave_ids: [],
ext: {
missing_wave_ids: normalizedWaveIds,
filtered_wave_ids: [],
},
};
}
const hitWaveIdSet = new Set(waveRows.map(row => Number(row.wave_id)));
const missingWaveIds = normalizedWaveIds.filter(waveId => !hitWaveIdSet.has(waveId));
const hitWaveIds = normalizedWaveIds.filter(waveId => hitWaveIdSet.has(waveId));
const orderRows = await this.queryOrdersByWaveIds(hitWaveIds, normalizedWarehouseId);
const {
validWaveIds,
filteredWaveIds,
} = this.filterFullyAssignedExpressWaves(hitWaveIds, orderRows);
const validWaveIdSet = new Set(validWaveIds);
const validOrderRows = orderRows.filter(order => validWaveIdSet.has(Number(order && order.wave_id || 0)));
const validOrderWaveIds = Array.from(new Set(validOrderRows
.map(row => Number(row && row.wave_id || 0))
.filter(waveId => Number.isInteger(waveId) && waveId > 0)));
if (validOrderRows.length === 0) {
const waveGroups = this.groupOrderPrintItemsByWaveAndPlatform({
waveRows,
hitWaveIds: validWaveIds,
orderPrintList: [],
});
return {
summary: {
total_waves: waveGroups.length,
total_orders: 0,
total_platforms: 0,
},
waveGroups,
wave_ids: validWaveIds,
ext: {
missing_wave_ids: missingWaveIds,
filtered_wave_ids: filteredWaveIds,
},
};
}
const orderIds = validOrderRows
.map(row => Number(row && row.id || 0))
.filter(orderId => Number.isInteger(orderId) && orderId > 0);
const orderExpressRows = await this.queryOrderExpressByOrderIds(orderIds);
this.assertBusinessWaybillCompleteness(orderIds, orderExpressRows);
const orderExpressMap = this.buildOrderExpressMap(orderExpressRows);
const policyConfigMap = await this.getPolicyConfigMapByStore(validOrderRows, normalizedWarehouseId);
const pickingCandidateRows = validOrderRows.filter(orderRow => {
const storeId = Number(orderRow && orderRow.store_id || 0);
const policyConfig = policyConfigMap.get(storeId) || {};
return this.shouldLoadPickingDetails(policyConfig);
});
const printOrderRowMap = await this.buildPrintOrderRowMapWithPicking(pickingCandidateRows, normalizedWarehouseId);
const waveOrderIndexMap = await this.queryWaveOrderIndexMapByOrderIds(
orderIds,
normalizedWarehouseId,
validOrderWaveIds
);
const waveIdsForCount = validOrderWaveIds;
const waveTotalOrderCountMap = await this.queryWaveTotalOrderCountMap(waveIdsForCount, normalizedWarehouseId);
const templateSampleCache = new Map();
const orderPrintList = [];
for (const orderRow of validOrderRows) {
const orderId = Number(orderRow && orderRow.id || 0);
if (!Number.isInteger(orderId) || orderId <= 0) {
continue;
}
const orderExpress = orderExpressMap.get(orderId) || {};
const effectiveOrderRow = printOrderRowMap.get(orderId) || orderRow;
const waveOrderIndexInfo = waveOrderIndexMap.get(orderId) || {};
const waveIdForCount = Number(effectiveOrderRow.wave_id || orderRow.wave_id || waveOrderIndexInfo.wave_id || 0);
const waveTotalOrders = Number(waveTotalOrderCountMap.get(waveIdForCount) || 0);
const waveIndex = Number(waveOrderIndexInfo.wave_index || 0);
const platformsIndex = Number(waveOrderIndexInfo.platforms_index || 0);
const effectiveOrderRowWithWaveIndex = {
...effectiveOrderRow,
wave_total_orders: waveTotalOrders > 0 ? waveTotalOrders : 0,
wave_index: waveIndex > 0 ? waveIndex : 0,
platforms_index: platformsIndex > 0 ? platformsIndex : 0,
};
const storeId = Number(orderRow && orderRow.store_id || 0);
const policyConfig = policyConfigMap.get(storeId) || {};
const platformCode = this.resolvePrintPlatformCode(effectiveOrderRow, orderExpress);
const templateSample = this.loadTemplateSampleByPlatform(platformCode, templateSampleCache);
orderPrintList.push(this.buildOrderPlatformPrintItem({
orderRow: effectiveOrderRowWithWaveIndex,
orderExpress,
policyConfig,
platformCode,
templateSample,
}));
}
const waveGroups = this.groupOrderPrintItemsByWaveAndPlatform({
waveRows,
hitWaveIds: validWaveIds,
orderPrintList,
});
const totalPlatforms = waveGroups.reduce((sum, waveGroup) => {
return sum + Number(waveGroup && waveGroup.platforms && waveGroup.platforms.length || 0);
}, 0);
return {
summary: {
total_waves: waveGroups.length,
total_orders: orderPrintList.length,
total_platforms: totalPlatforms,
},
waveGroups,
wave_ids: validWaveIds,
ext: {
missing_wave_ids: missingWaveIds,
filtered_wave_ids: filteredWaveIds,
},
};
}
/**
* 规范化波次ID数组(去重与数字化)。
*
* @param {Array<number|string>} waveIds 原始波次ID数组。
* @return {Array<number>} 规范化后的波次ID数组。
*/
normalizeWaveIds(waveIds = []) {
if (!Array.isArray(waveIds)) {
return [];
}
const normalizedSet = new Set();
for (const rawId of waveIds) {
const normalizedId = Number(String(rawId ?? '').trim());
if (Number.isInteger(normalizedId) && normalizedId > 0) {
normalizedSet.add(normalizedId);
}
}
return Array.from(normalizedSet);
}
/**
* 解析并校验仓库ID。
*
* @param {number|string} warehouseId 入参仓库ID。
* @return {number} 规范化后的仓库ID。
*/
resolveWarehouseId(warehouseId) {
const contextWarehouseId = Number(this.getWarehouseId() || 0);
if (!Number.isInteger(contextWarehouseId) || contextWarehouseId <= 0) {
throw new Error('缺少当前用户仓库上下文 store_id');
}
const normalizedWarehouseId = Number(String(warehouseId ?? '').trim());
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
throw new Error('warehouse_id 必填且必须为正整数');
}
if (normalizedWarehouseId !== contextWarehouseId) {
throw new Error('warehouse_id 必须与当前用户上下文 store_id 保持一致');
}
return normalizedWarehouseId;
}
/**
* 按波次ID批量查询波次信息。
*
* @param {number} warehouseId 仓库ID。
* @param {Array<number>} waveIds 波次ID数组。
* @return {Promise<Array<Object>>} 波次基础信息。
*/
async queryWavesByIds(warehouseId, waveIds = []) {
if (!Array.isArray(waveIds) || waveIds.length === 0) {
return [];
}
const querySql = `
SELECT wave_id, wave_no
FROM wms_wave_batch
WHERE warehouse_id = :warehouseId
AND wave_id IN (:waveIds)
AND wave_status <> -1
`;
const rows = await this.ctx.model.query(querySql, {
replacements: {
warehouseId,
waveIds,
},
type: this.ctx.model.QueryTypes.SELECT,
});
return Array.isArray(rows) ? rows : [];
}
/**
* 按波次ID批量查询订单明细。
*
* @param {Array<number>} waveIds 波次ID数组。
* @param {number} warehouseId 仓库ID。
* @return {Promise<Array<Object>>} 订单明细列表。
*/
async queryOrdersByWaveIds(waveIds = [], warehouseId) {
if (!Array.isArray(waveIds) || waveIds.length === 0) {
return [];
}
const orderModel = await this.getOrderModel('order', warehouseId);
const rows = await orderModel.findAll({
attributes: [
'id',
'delivery_order_code',
'source_order_codes',
'warehouse_id',
'store_id',
'wave_id',
'wave_no',
'name',
'tel',
'mobile',
'province',
'city',
'area',
'town',
'detail_address',
'zip_code',
'items',
'source_platform_code',
'sys_platform_code',
'sys_platform_name',
'logistics_code',
'logistics_name',
'sys_logistics_code',
'sys_logistics_name',
'post_status',
'status',
'outbound_status',
'print_status',
'items_count',
'items_total',
'items_weight',
'freight',
'create_at',
'pay_time',
],
where: {
wave_id: {
[Op.in]: waveIds,
},
},
order: [[ 'wave_id', 'ASC' ], [ 'id', 'ASC' ]],
raw: true,
});
return Array.isArray(rows) ? rows : [];
}
/**
* 按订单ID批量查询快递单信息。
*
* @param {Array<number>} orderIds 订单ID数组。
* @return {Promise<Array<Object>>} 快递单信息列表。
*/
async queryOrderExpressByOrderIds(orderIds = []) {
if (!Array.isArray(orderIds) || orderIds.length === 0) {
return [];
}
const normalizedOrderIds = Array.from(new Set(orderIds
.map(id => Number(id))
.filter(id => Number.isInteger(id) && id > 0)));
if (normalizedOrderIds.length === 0) {
return [];
}
const rows = await this.ctx.model.OrderExpress.findAll({
attributes: [
'id',
'order_id',
'business_key',
'waybill_code',
'logistics_code',
'logistics_name',
'logistics_interface_name',
'platform_code',
'warehouse_id',
'printinfo',
'signature',
'encryptprintinfo',
],
where: {
order_id: {
[Op.in]: normalizedOrderIds,
},
business_key: 1,
},
order: [[ 'order_id', 'ASC' ], [ 'business_key', 'ASC' ], [ 'id', 'ASC' ]],
raw: true,
});
return Array.isArray(rows) ? rows : [];
}
/**
* 按订单ID批量查询波次顺序信息。
*
* 数据来源:wms_order_wave_index。
* 当 query 能力不可用、SQL 执行失败或无数据时,优雅降级返回空映射。
*
* @param {Array<number>} orderIds 订单ID数组。
* @param {number} warehouseId 仓库ID。
* @param {Array<number>} [waveIds] 可选波次ID数组,用于限制查询范围。
* @return {Promise<Map<number, {wave_id:number, wave_index:number, platforms_index:number}>>} 订单顺序映射。
*/
async queryWaveOrderIndexMapByOrderIds(orderIds = [], warehouseId, waveIds = []) {
const resultMap = new Map();
const normalizedOrderIds = Array.from(new Set((Array.isArray(orderIds) ? orderIds : [])
.map(id => Number(id))
.filter(id => Number.isInteger(id) && id > 0)));
const normalizedWaveIds = Array.from(new Set((Array.isArray(waveIds) ? waveIds : [])
.map(id => Number(id))
.filter(id => Number.isInteger(id) && id > 0)));
if (normalizedOrderIds.length === 0) {
return resultMap;
}
const queryMethod = this.ctx.model && this.ctx.model.query;
if (typeof queryMethod !== 'function') {
return resultMap;
}
const waveFilterSql = normalizedWaveIds.length > 0
? ' AND wave_id IN (:waveIds)\n'
: '';
const querySql = `
SELECT order_id, wave_id, wave_index, platforms_index
FROM wms_order_wave_index
WHERE warehouse_id = :warehouseId
AND order_id IN (:orderIds)
${waveFilterSql}
`;
try {
const rows = await queryMethod.call(this.ctx.model, querySql, {
replacements: {
warehouseId,
orderIds: normalizedOrderIds,
...(normalizedWaveIds.length > 0 ? { waveIds: normalizedWaveIds } : {}),
},
type: this.ctx.model.QueryTypes && this.ctx.model.QueryTypes.SELECT,
});
for (const row of Array.isArray(rows) ? rows : []) {
const orderId = Number(row && row.order_id || 0);
if (!Number.isInteger(orderId) || orderId <= 0) {
continue;
}
resultMap.set(orderId, {
wave_id: Number(row && row.wave_id || 0),
wave_index: Number(row && row.wave_index || 0),
platforms_index: Number(row && row.platforms_index || 0),
});
}
} catch (error) {
this.ctx.logger.warn(
`[orderPrint.queryWaveOrderIndexMapByOrderIds] 查询失败 warehouseId=${warehouseId} message=${error.message}`
);
}
return resultMap;
}
/**
* 按波次ID批量查询波次总订单数。
*
* 数据来源:wms_order_wave_index。
* 当 query 能力不可用、SQL 执行失败或无数据时,优雅降级返回空映射。
*
* @param {Array<number>} waveIds 波次ID数组。
* @param {number} warehouseId 仓库ID。
* @return {Promise<Map<number, number>>} 波次ID到总订单数映射。
*/
async queryWaveTotalOrderCountMap(waveIds = [], warehouseId) {
const resultMap = new Map();
const normalizedWaveIds = Array.from(new Set((Array.isArray(waveIds) ? waveIds : [])
.map(id => Number(id))
.filter(id => Number.isInteger(id) && id > 0)));
if (normalizedWaveIds.length === 0) {
return resultMap;
}
const queryMethod = this.ctx.model && this.ctx.model.query;
if (typeof queryMethod !== 'function') {
return resultMap;
}
const querySql = `
SELECT wave_id, COUNT(1) AS total_orders
FROM wms_order_wave_index
WHERE warehouse_id = :warehouseId
AND wave_id IN (:waveIds)
GROUP BY wave_id
`;
try {
const rows = await queryMethod.call(this.ctx.model, querySql, {
replacements: {
warehouseId,
waveIds: normalizedWaveIds,
},
type: this.ctx.model.QueryTypes && this.ctx.model.QueryTypes.SELECT,
});
for (const row of Array.isArray(rows) ? rows : []) {
const waveId = Number(row && row.wave_id || 0);
if (!Number.isInteger(waveId) || waveId <= 0) {
continue;
}
const totalOrders = Number(row && row.total_orders || 0);
resultMap.set(waveId, totalOrders > 0 ? totalOrders : 0);
}
} catch (error) {
this.ctx.logger.warn(
`[orderPrint.queryWaveTotalOrderCountMap] 查询失败 warehouseId=${warehouseId} message=${error.message}`
);
}
return resultMap;
}
/**
* 校验业务ID为1的运单号数据完整性。
*
* @param {Array<number>} orderIds 订单ID数组。
* @param {Array<Object>} orderExpressRows 快递单查询结果。
*/
assertBusinessWaybillCompleteness(orderIds = [], orderExpressRows = []) {
const normalizedOrderIds = Array.from(new Set((Array.isArray(orderIds) ? orderIds : [])
.map(id => Number(id))
.filter(id => Number.isInteger(id) && id > 0)));
if (normalizedOrderIds.length === 0) {
return;
}
const validOrderIdSet = new Set();
const rows = Array.isArray(orderExpressRows) ? orderExpressRows : [];
for (const row of rows) {
const orderId = Number(row && row.order_id || 0);
if (!Number.isInteger(orderId) || orderId <= 0) {
continue;
}
const waybillCode = String(row && row.waybill_code || '').trim();
if (!waybillCode) {
continue;
}
validOrderIdSet.add(orderId);
}
const missingOrderIds = normalizedOrderIds.filter(orderId => !validOrderIdSet.has(orderId));
if (missingOrderIds.length > 0) {
throw new Error(`业务id为1的运单号数据缺失,缺失 order_id: ${missingOrderIds.join(',')}`);
}
}
/**
* 按订单ID构建快递信息映射,优先保留带运单号的记录。
*
* @param {Array<Object>} rows 快递数据行。
* @return {Map<number, Object>} 订单到快递信息的映射。
*/
buildOrderExpressMap(rows = []) {
const expressMap = new Map();
for (const row of rows) {
const orderId = Number(row && row.order_id || 0);
if (!Number.isInteger(orderId) || orderId <= 0) {
continue;
}
const previousRow = expressMap.get(orderId);
if (!previousRow) {
expressMap.set(orderId, row);
continue;
}
const previousWaybillCode = String(previousRow.waybill_code || '').trim();
const currentWaybillCode = String(row && row.waybill_code || '').trim();
if (!previousWaybillCode && currentWaybillCode) {
expressMap.set(orderId, row);
}
}
return expressMap;
}
/**
* 获取波次订单对应货主的签约策略映射。
*
* @param {Array<Object>} orderRows 订单行。
* @param {number} warehouseId 仓库ID。
* @return {Promise<Map<number, Object>>} 货主策略映射。
*/
async getPolicyConfigMapByStore(orderRows = [], warehouseId) {
const storeIds = Array.from(new Set(orderRows
.map(row => Number(row && row.store_id || 0))
.filter(storeId => Number.isInteger(storeId) && storeId > 0)));
const policyMap = new Map();
if (storeIds.length === 0) {
return policyMap;
}
const storeWarehouseService = this.ctx.service
&& this.ctx.service.systems
&& this.ctx.service.systems.storeWarehouse;
if (!storeWarehouseService || typeof storeWarehouseService.getContractConfig !== 'function') {
return policyMap;
}
await Promise.all(storeIds.map(async storeId => {
try {
const contractConfig = await storeWarehouseService.getContractConfig(warehouseId, storeId);
const policyConfig = this.normalizeContractPolicyConfig(contractConfig && contractConfig.policy_config);
policyMap.set(storeId, policyConfig);
} catch (error) {
this.ctx.logger.warn(
`[orderPrint.getPolicyConfigMapByStore] 读取签约策略失败 warehouseId=${warehouseId} storeId=${storeId} message=${error.message}`
);
policyMap.set(storeId, {});
}
}));
return policyMap;
}
/**
* 解析订单平台编码,保留原始平台值(仅去首尾空白)。
*
* @param {Object} orderRow 订单行。
* @param {Object} orderExpress 快递行。
* @return {string} 打印平台编码。
*/
resolvePrintPlatformCode(orderRow = {}, orderExpress = {}) {
const candidates = [
orderRow && orderRow.sys_platform_code,
orderRow && orderRow.source_platform_code,
orderExpress && orderExpress.platform_code,
];
for (const candidate of candidates) {
const rawCandidate = String(candidate || '').trim();
if (!rawCandidate) {
continue;
}
return rawCandidate;
}
return '';
}
/**
* 按平台加载打印模板样例。
*
* @param {string} platformCode 平台编码。
* @param {Map<string, Object>} cache 模板缓存。
* @return {Object} 模板样例对象。
*/
loadTemplateSampleByPlatform(platformCode, cache) {
const normalized = PrinterDataBuilder.normalizePlatformAlias(platformCode);
const cacheKey = normalized.meta && normalized.meta.template_file
? normalized.meta.template_file
: `platform:${normalized.platform || 'unknown'}`;
if (cache.has(cacheKey)) {
return cache.get(cacheKey);
}
if (!normalized.meta || !normalized.meta.template_file) {
cache.set(cacheKey, {});
return {};
}
const templatePath = path.join(this.app.baseDir, 'printer_data_template', normalized.meta.template_file);
try {
const fileContent = fs.readFileSync(templatePath, 'utf8');
const parsedTemplate = JSON.parse(fileContent);
const templateSample = this.isPlainObject(parsedTemplate) ? parsedTemplate : {};
cache.set(cacheKey, templateSample);
return templateSample;
} catch (error) {
this.ctx.logger.warn(`[orderPrint.loadTemplateSampleByPlatform] 模板读取失败 template=${templatePath} message=${error.message}`);
cache.set(cacheKey, {});
return {};
}
}
/**
* 组装单订单平台打印中间态结果。
*
* @param {Object} payload 聚合入参。
* @param {Object} payload.orderRow 订单行。
* @param {Object} payload.orderExpress 快递行。
* @param {Object} payload.policyConfig 策略配置。
* @param {string} payload.platformCode 平台编码。
* @param {Object} payload.templateSample 模板样例。
* @return {Object} 逐单打印中间态。
*/
buildOrderPlatformPrintItem(payload = {}) {
const requestPayload = this.isPlainObject(payload) ? payload : {};
const orderRow = this.isPlainObject(requestPayload.orderRow) ? requestPayload.orderRow : {};
const orderExpress = this.isPlainObject(requestPayload.orderExpress) ? requestPayload.orderExpress : {};
const policyConfig = this.isPlainObject(requestPayload.policyConfig) ? requestPayload.policyConfig : {};
const templateSample = this.isPlainObject(requestPayload.templateSample) ? requestPayload.templateSample : {};
const platformCode = String(requestPayload.platformCode || '').trim();
const orderId = Number(orderRow.id || 0);
const waveId = Number(orderRow.wave_id || 0);
const requestId = `wave_${waveId}_order_${orderId}`;
const waybillCode = String(orderExpress.waybill_code || '').trim();
const orderSysLogisticsCode = String(orderRow.sys_logistics_code || '').trim();
const orderSysLogisticsName = String(orderRow.sys_logistics_name || '').trim();
const expressSysLogisticsCode = String(orderExpress.sys_logistics_code || '').trim();
const expressSysLogisticsName = String(orderExpress.sys_logistics_name || '').trim();
const documentId = waybillCode || `doc_${orderId}`;
const printPayload = PrinterDataBuilder.buildPlatformRequestSkeleton({
platform: platformCode,
order_express: orderExpress,
order_delivery: orderRow,
store_contract: {
policy_config: policyConfig,
},
policy_config: policyConfig,
template_sample: templateSample,
options: {
requestId,
taskId: requestId,
documentId,
},
});
const printData = this.extractSinglePlatformPrintData(printPayload);
return {
wave_id: waveId,
wave_no: String(orderRow.wave_no || '').trim(),
order_id: orderId,
order_no: String(orderRow.delivery_order_code || orderRow.source_order_codes || '').trim(),
store_id: Number(orderRow.store_id || 0),
warehouse_id: Number(orderRow.warehouse_id || 0),
platform: platformCode,
platform_name: printPayload.platform_meta && printPayload.platform_meta.name
? String(printPayload.platform_meta.name).trim()
: '',
sys_logistics_code: orderSysLogisticsCode || expressSysLogisticsCode,
sys_logistics_name: orderSysLogisticsName || expressSysLogisticsName,
waybill_code: String(orderExpress.waybill_code || '').trim(),
print_data: printData,
};
}
/**
* 提取单个打印文档对象。
*
* @param {Object} printPayload 打印载荷。
* @return {Object} 单个文档对象;未命中时返回空对象。
*/
extractSinglePlatformPrintData(printPayload = {}) {
const requestSkeleton = this.isPlainObject(printPayload)
? printPayload.request_skeleton
: null;
if (!this.isPlainObject(requestSkeleton)) {
return {};
}
const taskDocuments = requestSkeleton.task && Array.isArray(requestSkeleton.task.documents)
? requestSkeleton.task.documents
: [];
if (taskDocuments.length > 0 && this.isPlainObject(taskDocuments[0])) {
return taskDocuments[0];
}
if (Array.isArray(requestSkeleton.documents) && this.isPlainObject(requestSkeleton.documents[0])) {
return requestSkeleton.documents[0];
}
const taskListEntry = Array.isArray(requestSkeleton.taskList)
? requestSkeleton.taskList.find(item => Array.isArray(item && item.documents) && item.documents.length > 0)
: null;
if (taskListEntry && this.isPlainObject(taskListEntry.documents[0])) {
return taskListEntry.documents[0];
}
return {};
}
/**
* 将逐单打印中间态按平台分组。
*
* @param {Array<Object>} orderPrintList 逐单打印中间态列表。
* @return {Array<Object>} 平台分组列表。
*/
groupOrderPrintItemsByPlatform(orderPrintList = []) {
const groupedPlatformMap = new Map();
for (const item of orderPrintList) {
const platform = String(item && item.platform || '').trim() || 'unknown';
const group = groupedPlatformMap.get(platform) || {
platform,
platform_name: String(item && item.platform_name || '').trim(),
order_count: 0,
orders: [],
};
group.orders.push(this.isPlainObject(item && item.print_data) ? item.print_data : {});
group.order_count = group.orders.length;
groupedPlatformMap.set(platform, group);
}
const groups = Array.from(groupedPlatformMap.values());
groups.sort((a, b) => String(a.platform || '').localeCompare(String(b.platform || '')));
return groups;
}
/**
* 将逐单打印中间态按波次分组,并在波次内按平台+系统快递分组。
*
* @param {Object} payload 聚合输入。
* @param {Array<Object>} payload.waveRows 波次元数据列表。
* @param {Array<number>} payload.hitWaveIds 命中的波次ID数组(已过滤)。
* @param {Array<Object>} payload.orderPrintList 逐单打印中间态列表。
* @return {Array<Object>} 波次平台分组结果(platforms 为扁平平台+系统快递项)。
*/
groupOrderPrintItemsByWaveAndPlatform(payload = {}) {
const {
waveRows = [],
hitWaveIds = [],
orderPrintList = [],
} = this.isPlainObject(payload) ? payload : {};
const waveMetaMap = new Map();
for (const row of waveRows) {
const waveId = Number(row && row.wave_id || 0);
if (!Number.isInteger(waveId) || waveId <= 0) {
continue;
}
waveMetaMap.set(waveId, {
wave_id: waveId,
wave_no: String(row && row.wave_no || '').trim(),
});
}
const waveGroupMap = new Map();
const wavePlatformMap = new Map();
for (const waveId of hitWaveIds) {
const normalizedWaveId = Number(waveId);
if (!Number.isInteger(normalizedWaveId) || normalizedWaveId <= 0) {
continue;
}
const waveMeta = waveMetaMap.get(normalizedWaveId) || {
wave_id: normalizedWaveId,
wave_no: '',
};
waveGroupMap.set(normalizedWaveId, {
wave_id: waveMeta.wave_id,
wave_no: waveMeta.wave_no,
order_count: 0,
platforms: [],
});
wavePlatformMap.set(normalizedWaveId, new Map());
}
for (const item of orderPrintList) {
const waveId = Number(item && item.wave_id || 0);
const waveGroup = waveGroupMap.get(waveId);
if (!waveGroup) {
continue;
}
const platform = String(item && item.platform || '').trim() || 'unknown';
const normalizedSysLogisticsCode = String(item && item.sys_logistics_code || '').trim();
const normalizedSysLogisticsName = String(item && item.sys_logistics_name || '').trim();
const normalizedSysLogisticsIdentity = normalizedSysLogisticsCode || normalizedSysLogisticsName || 'unknown';
const platformSysKey = `${platform}@@${normalizedSysLogisticsIdentity}`;
const platformMap = wavePlatformMap.get(waveId) || new Map();
const platformGroup = platformMap.get(platformSysKey) || {
platform,
platform_name: String(item && item.platform_name || '').trim(),
sys_logistics_code: normalizedSysLogisticsCode || 'unknown',
sys_logistics_name: normalizedSysLogisticsName || 'unknown',
order_count: 0,
orders: [],
};
platformGroup.orders.push(this.isPlainObject(item && item.print_data) ? item.print_data : {});
platformGroup.order_count = platformGroup.orders.length;
platformMap.set(platformSysKey, platformGroup);
wavePlatformMap.set(waveId, platformMap);
}
const waveGroups = Array.from(waveGroupMap.values());
for (const waveGroup of waveGroups) {
const platformMap = wavePlatformMap.get(Number(waveGroup.wave_id)) || new Map();
const platforms = Array.from(platformMap.values());
platforms.sort((a, b) => {
const platformCompare = String(a.platform || '').localeCompare(String(b.platform || ''));
if (platformCompare !== 0) {
return platformCompare;
}
const sysCodeCompare = String(a.sys_logistics_code || '').localeCompare(String(b.sys_logistics_code || ''));
if (sysCodeCompare !== 0) {
return sysCodeCompare;
}
return String(a.sys_logistics_name || '').localeCompare(String(b.sys_logistics_name || ''));
});
waveGroup.platforms = platforms;
waveGroup.order_count = platforms.reduce((sum, platformGroup) => {
return sum + Number(platformGroup && platformGroup.order_count || 0);
}, 0);
}
waveGroups.sort((a, b) => {
const waveNoCompare = String(a.wave_no || '').localeCompare(String(b.wave_no || ''));
if (waveNoCompare !== 0) {
return waveNoCompare;
}
return Number(a.wave_id || 0) - Number(b.wave_id || 0);
});
return waveGroups;
}
/**
* 过滤快递未完全分配的波次。
*
* 规则:仅当波次下全部订单的 post_status 都为 fin 时,才视为快递已完全分配。
*
* @param {Array<number>} hitWaveIds 命中的波次ID数组。
* @param {Array<Object>} orderRows 波次订单列表。
* @return {{ validWaveIds: Array<number>, filteredWaveIds: Array<Object> }} 过滤结果。
*/
filterFullyAssignedExpressWaves(hitWaveIds = [], orderRows = []) {
const statsMap = new Map();
for (const waveId of hitWaveIds) {
statsMap.set(Number(waveId), {
total: 0,
fin: 0,
});
}
for (const row of orderRows) {
const waveId = Number(row && row.wave_id || 0);
const stats = statsMap.get(waveId);
if (!stats) {
continue;
}
const postStatus = String(row && row.post_status || '').trim();
stats.total += 1;
if (postStatus === 'fin') {
stats.fin += 1;
}
}
const validWaveIds = [];
const filteredWaveIds = [];
for (const waveId of hitWaveIds) {
const stats = statsMap.get(waveId) || { total: 0, fin: 0 };
const isFullyAssigned = stats.total > 0 && stats.fin === stats.total;
if (isFullyAssigned) {
validWaveIds.push(waveId);
} else {
filteredWaveIds.push({
wave_id: waveId,
reason: '快递未完全分配',
});
}
}
return {
validWaveIds,
filteredWaveIds,
};
}
/**
* 生成空结果结构。
*
* @param {Array<number>} normalizedWaveIds 规范化后的波次ID数组。
* @return {Object} 空结果。
*/
buildEmptyResult(normalizedWaveIds = []) {
return {
summary: {
total_waves: 0,
total_orders: 0,
},
wave_list: [],
ext: {
missing_wave_ids: normalizedWaveIds,
filtered_wave_ids: [],
},
};
}
/**
* 组装通用波次打印返回结构。
*
* @param {Object} payload 聚合输入。
* @param {Array<Object>} payload.waveRows 波次列表。
* @param {Array<Object>} payload.orderRows 订单列表。
* @param {Array<number>} payload.hitWaveIds 命中的波次ID数组。
* @param {Array<number>} payload.missingWaveIds 未命中的波次ID数组。
* @param {Array<Object>} payload.filteredWaveIds 被过滤的波次及原因。
* @return {Object} 波次打印返回结果。
*/
buildWavePrintResult(payload = {}) {
const {
waveRows = [],
orderRows = [],
hitWaveIds = [],
missingWaveIds = [],
filteredWaveIds = [],
} = this.isPlainObject(payload) ? payload : {};
const waveMetaMap = new Map();
for (const row of waveRows) {
const waveId = Number(row && row.wave_id || 0);
if (!Number.isInteger(waveId) || waveId <= 0) {
continue;
}
waveMetaMap.set(waveId, {
wave_id: waveId,
wave_no: String(row && row.wave_no || '').trim(),
});
}
const groupedWaveMap = new Map();
for (const waveId of hitWaveIds) {
const waveMeta = waveMetaMap.get(waveId);
if (!waveMeta) {
continue;
}
groupedWaveMap.set(waveId, {
wave_id: waveMeta.wave_id,
wave_no: waveMeta.wave_no,
order_count: 0,
orders: [],
});
}
for (const order of orderRows) {
const waveId = Number(order && order.wave_id || 0);
const groupedWave = groupedWaveMap.get(waveId);
if (!groupedWave) {
continue;
}
groupedWave.orders.push({
order_id: Number(order && order.id || 0),
order_no: String(order && (order.delivery_order_code || order.source_order_codes) || '').trim(),
wave_id: waveId,
wave_no: String(order && order.wave_no || '').trim() || groupedWave.wave_no,
receiver: {
name: String(order && order.name || '').trim(),
mobile: String(order && order.mobile || '').trim(),
tel: String(order && order.tel || '').trim(),
province: String(order && order.province || '').trim(),
city: String(order && order.city || '').trim(),
area: String(order && order.area || '').trim(),
town: String(order && order.town || '').trim(),
detail_address: String(order && order.detail_address || '').trim(),
},
channel: {
sys_platform_code: String(order && order.sys_platform_code || '').trim(),
sys_platform_name: String(order && order.sys_platform_name || '').trim(),
logistics_name: String(order && order.logistics_name || '').trim(),
},
status: {
order_status: String(order && order.status || '').trim(),
outbound_status: String(order && order.outbound_status || '').trim(),
print_status: String(order && order.print_status || '').trim(),
},
metrics: {
items_count: Number(order && order.items_count || 0),
items_total: Number(order && order.items_total || 0),
items_weight: Number(order && order.items_weight || 0),
},
times: {
create_at: order && order.create_at || null,
pay_time: order && order.pay_time || null,
},
});
}
const waveList = Array.from(groupedWaveMap.values());
waveList.sort((a, b) => String(a.wave_no || '').localeCompare(String(b.wave_no || '')));
let totalOrders = 0;
for (const wave of waveList) {
wave.order_count = wave.orders.length;
totalOrders += wave.order_count;
}
return {
summary: {
total_waves: waveList.length,
total_orders: totalOrders,
},
wave_list: waveList,
ext: {
missing_wave_ids: missingWaveIds,
filtered_wave_ids: filteredWaveIds,
},
};
}
}
module.exports = OrderPrintSystemService;