WMS_MAIN/app/service/systems/order_print.js
liufumingren 0c3518e65d 1
2026-05-13 03:18:39 +08:00

962 lines
30 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');
const SYS_PLATFORM_TO_PRINT_PLATFORM_MAP = Object.freeze({
tb: 'cainiao',
taobao: 'cainiao',
cainiao: 'cainiao',
cn: 'cainiao',
jd: 'jd',
jingdong: 'jd',
dy: 'douyin',
douyin: 'douyin',
ks: 'kuaishou',
kuaishou: 'kuaishou',
pdd: 'pdd',
pinduoduo: 'pdd',
sph: 'sph',
shipinhao: 'sph',
xhs: 'xhs',
xiaohongshu: 'xhs',
});
class OrderPrintSystemService extends OrderBaseService {
/**
* 获取波次打印数据。
*
* @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)));
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 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 storeId = Number(orderRow && orderRow.store_id || 0);
const policyConfig = policyConfigMap.get(storeId) || {};
const platformCode = this.resolvePrintPlatformCode(orderRow, orderExpress);
const templateSample = this.loadTemplateSampleByPlatform(platformCode, templateSampleCache);
orderPrintList.push(this.buildOrderPlatformPrintItem({
orderRow,
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',
'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',
'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为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.isPlainObject(contractConfig && contractConfig.policy_config)
? 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 normalizedCandidate = String(candidate || '').trim().toLowerCase();
if (!normalizedCandidate) {
continue;
}
const mappedPlatform = SYS_PLATFORM_TO_PRINT_PLATFORM_MAP[normalizedCandidate] || normalizedCandidate;
const normalizedPlatform = PrinterDataBuilder.normalizePlatformAlias(mappedPlatform);
if (normalizedPlatform.platform) {
return normalizedPlatform.platform;
}
}
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 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: String(printPayload.platform || '').trim(),
platform_name: printPayload.platform_meta && printPayload.platform_meta.name
? String(printPayload.platform_meta.name).trim()
: '',
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>} 波次平台分组结果。
*/
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 platformMap = wavePlatformMap.get(waveId) || new Map();
const platformGroup = platformMap.get(platform) || {
platform,
platform_name: String(item && item.platform_name || '').trim(),
order_count: 0,
orders: [],
};
platformGroup.orders.push(this.isPlainObject(item && item.print_data) ? item.print_data : {});
platformGroup.order_count = platformGroup.orders.length;
platformMap.set(platform, 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) => String(a.platform || '').localeCompare(String(b.platform || '')));
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;