962 lines
30 KiB
JavaScript
962 lines
30 KiB
JavaScript
'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;
|