WMS_MAIN/test/app/service/systems/order_print.getWavePlatformPrintData.test.js
liufumingren 763573ee41 feat(wms): 拦截订单门禁豁免、波次号原子取号、打印自定义区数量、拆包视频与商品复核字段
- pick: waveClaimScan 拦截订单整体跳过领料(不置 claim_status=fin,未打印不阻隔领料);query 领料前置校验仅统计非拦截未领料订单(拦截未领料不阻隔拣货);createWavePickTask 新增 excludeUnclaimed,普通波次(source=0)计算拣货数量(order_count/任务订单/筐)时剔除未领料订单
- wave: 波次号改为 wms_number_sequence 原子取号(upsert + LAST_INSERT_ID,seed 对齐当日历史最大序),wave_no 唯一索引 uniq_wave_no,并发撞号自动重取(最多 3 次)
- print: 面单自定义区首行「商品总数【n】」(items_total 优先),团购波次商品明细行尾「波次总单数×商品数量」
- returnUnpack: 列表新增 has_video/video_enable/videos 视频字段与筛选,补视频列表权限迁移
- stock: 商品新增 need_recheck(是否需要复核)字段,导入归一化与导出列支持,补迁移
- docs: 同步 methods/system.json 与 methods/changes/system.json 变更记录(恢复遗漏的已提交记录)
2026-08-23 14:31:49 +08:00

2111 lines
64 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 assert = require('node:assert/strict');
const OrderPrintSystemService = require('../../../../app/service/systems/order_print');
function createOrderPrintServiceHarness() {
const ctx = {
app: {
baseDir: 'd:/wms',
},
user: {
store_id: 100000,
},
logger: {
info() {},
warn() {},
error() {},
},
model: {
Express: {
async findAll() {
return [];
},
},
QueryTypes: {
SELECT: 'SELECT',
},
},
service: {
systems: {
express: {
pickWaybillExpressInterface() {
return null;
},
},
setting: {
expressInterface: {
async listByWarehousePlatformCode() {
return {
code: 200,
data: [],
};
},
},
},
storeWarehouse: {
async getContractConfig() {
return {
policy_config: {},
};
},
},
},
},
};
return new OrderPrintSystemService(ctx);
}
describe('test/app/service/systems/order_print.getWavePlatformPrintData.test.js', () => {
it('should map kuaishou encryptedData/signature/key from order_express fields', () => {
const service = createOrderPrintServiceHarness();
const result = service.buildOrderPlatformPrintItem({
orderRow: {
id: 101,
wave_id: 10,
wave_no: 'W010',
delivery_order_code: 'DO101',
store_id: 1,
warehouse_id: 100000,
items: JSON.stringify([
{
item_name: '化妆品',
pick_location: 'E2区02-04-02',
barcode: '6973348850399',
quantity: 2,
},
]),
},
orderExpress: {
waybill_code: 'WB101',
printinfo: 'ENC_FROM_DB',
signature: 'SIG_FROM_DB',
encryptprintinfo: 'KEY_FROM_DB',
logistics_name: '顺丰',
logistics_interface_name: '申通快递',
},
policyConfig: {
province_name: '浙江省',
city_name: '杭州市',
district_name: '滨江区',
address: '网商路 699 号',
sender_name: '张三',
sender_tel: '13800000000',
waybill_custom_display_type: '5',
},
platformCode: 'kuaishou',
templateSample: {
cmd: 'print',
requestID: 'sample-request',
version: '1.0',
taskID: 'sample-task',
task: {
documents: [
{
documentID: 'sample-doc',
contents: [
{
encryptedData: 'SAMPLE_ENCRYPTED_DATA',
signature: 'SAMPLE_SIGNATURE',
key: 'SAMPLE_KEY',
templateURL: 'https://example.com/kuaishou.xml',
data: {
productInfo: '#0 sample product info',
},
},
{
templateURL: 'http://www.ye4s.com/mb/kuaishou.xml',
customData: {
productInfo: '#1 sample custom product info',
},
},
],
},
],
},
},
});
assert.equal(result.print_data.documentID, 'WB101');
assert.equal(result.print_data.waybillCode, 'WB101');
assert.ok(Array.isArray(result.print_data.contents));
const mappedContent = result.print_data.contents[0];
assert.equal(mappedContent.encryptedData, 'ENC_FROM_DB');
assert.equal(mappedContent.signature, 'SIG_FROM_DB');
assert.equal(mappedContent.key, 'KEY_FROM_DB');
assert.equal(mappedContent.templateURL, 'https://example.com/kuaishou.xml');
assert.equal(mappedContent.data.productInfo, '__SAMPLE__');
assert.equal(mappedContent.addData.senderInfo.address.countryCode, 'CHN');
assert.equal(mappedContent.addData.senderInfo.address.detailAddress, '网商路 699 号');
assert.equal(mappedContent.addData.senderInfo.contact.name, '张三');
assert.equal(mappedContent.addData.senderInfo.contact.mobile, '13800000000');
const customDataContent = result.print_data.contents.find(content => content && content.customData);
assert.ok(customDataContent);
assert.equal(customDataContent.templateURL, 'http://www.ye4s.com/mb/kuaishou.xml');
assert.ok(customDataContent.customData.productInfo.includes('W010 申通快递'));
assert.ok(customDataContent.customData.productInfo.includes('E2区02-04-02 化妆品 6973348850399 【2】'));
});
it('should map pdd encryptedData/signature and sender fields from order_express and policy_config', () => {
const service = createOrderPrintServiceHarness();
const result = service.buildOrderPlatformPrintItem({
orderRow: {
id: 201,
wave_id: 20,
wave_no: 'W020',
delivery_order_code: 'DO201',
store_id: 1,
warehouse_id: 100000,
items: JSON.stringify([
{
pick_location: 'A1-01-01',
barcode: '1234567890123',
quantity: 1,
},
]),
},
orderExpress: {
waybill_code: ' WB201 ',
printinfo: ' ENC_FROM_DB_PDD ',
encryptprintinfo: ' ENC_FROM_DB_PDD ',
signature: ' SIG_FROM_DB_PDD ',
ver: ' 12 ',
logistics_name: '中通',
logistics_interface_name: '顺丰空运',
},
policyConfig: {
province_name: '广东省',
city_name: '深圳市',
district_name: '南山区',
address: '科技园南区 1 号',
sender_name: '李四',
sender_tel: '13900000000',
waybill_custom_display_type: '4',
},
platformCode: 'pdd',
templateSample: {
cmd: 'print',
requestID: 'sample-request',
version: '1.0',
taskID: 'sample-task',
task: {
documents: [
{
documentID: 'sample-doc',
contents: [
{
addData: {
sender: {
address: {
province: '',
city: '',
district: '',
detail: '',
},
mobile: '',
name: '',
},
},
encryptedData: 'SAMPLE_ENCRYPTED_DATA',
signature: 'SAMPLE_SIGNATURE',
templateURL: 'https://example.com/pdd.xml',
data: {
productInfo: '#0 sample product info',
},
},
],
},
],
},
},
});
assert.equal(result.print_data.documentID, 'WB201');
assert.equal(result.print_data.contents[0].encryptedData, 'ENC_FROM_DB_PDD');
assert.equal(result.print_data.contents[0].signature, 'SIG_FROM_DB_PDD');
assert.equal(result.print_data.contents[0].ver, '12');
assert.equal(result.print_data.contents[0].addData.sender.address.province, '广东省');
assert.equal(result.print_data.contents[0].addData.sender.address.city, '深圳市');
assert.equal(result.print_data.contents[0].addData.sender.address.district, '南山区');
assert.equal(result.print_data.contents[0].addData.sender.address.detail, '科技园南区 1 号');
assert.equal(result.print_data.contents[0].addData.sender.mobile, '13900000000');
assert.equal(result.print_data.contents[0].addData.sender.name, '李四');
const customContent = result.print_data.contents.find(content => {
return content && content.data && Array.isArray(content.data.list);
});
assert.ok(customContent);
assert.equal(customContent.templateURL, 'http://www.ye4s.com/mb/pdd.xml');
assert.ok(customContent.data.list[0].text.includes('\r'));
assert.ok(customContent.data.list[0].text.includes('W020 顺丰空运'));
assert.ok(customContent.data.list[0].text.includes('A1-01-01 90123 【1】'));
});
it('should build custom text when order items is wrapped object string', () => {
const service = createOrderPrintServiceHarness();
const result = service.buildOrderPlatformPrintItem({
orderRow: {
id: 202,
wave_id: 21,
wave_no: 'W021',
delivery_order_code: 'DO202',
store_id: 1,
warehouse_id: 100000,
items: JSON.stringify({
items: [
{
pick_location: 'C1-01-01',
barcode: '9988776655443',
quantity: 3,
},
],
}),
},
orderExpress: {
waybill_code: 'WB202',
printinfo: 'ENC_202',
signature: 'SIG_202',
logistics_name: '圆通',
},
policyConfig: {
waybill_custom_display_type: '3',
sender_name: '张三',
sender_tel: '13800000000',
province_name: '浙江省',
city_name: '杭州市',
district_name: '西湖区',
address: '文三路 1 号',
},
platformCode: 'pdd',
templateSample: {
cmd: 'print',
requestID: 'REQ-202',
version: '11',
task: {
documents: [
{
contents: [
{
addData: {
sender: {
address: {
city: '',
detail: '',
district: '',
province: '',
},
mobile: '',
name: '',
},
},
encryptedData: '',
signature: '',
templateUrl: 'https://file-link.pinduoduo.com/sto_one',
userid: '',
ver: '11',
},
{
data: {
height: 240,
list: [
{
fontSize: 28,
left: 2.08,
text: '',
top: 2.08,
width: 550,
},
],
waterdata: {
text: '',
},
width: 560,
},
templateURL: 'http://www.ye4s.com/mb/pdd.xml',
},
],
documentID: 'DOC-202',
},
],
},
},
});
const customContent = result.print_data.contents.find(content => content && content.data && Array.isArray(content.data.list));
assert.ok(customContent);
assert.ok(customContent.data.list[0].text.includes('W021 圆通'));
assert.ok(customContent.data.list[0].text.includes('C1-01-01 9988776655443 【3】'));
});
it('should use cainiao pure main content from printinfo directly and keep custom control content', () => {
const service = createOrderPrintServiceHarness();
const result = service.buildOrderPlatformPrintItem({
orderRow: {
id: 207,
wave_id: 26,
wave_no: 'W026',
delivery_order_code: 'DO207',
store_id: 1,
warehouse_id: 100000,
items: JSON.stringify([
{
item_name: '运动短袖',
pick_location: 'E1区01-19-01',
barcode: '988948487',
quantity: 2,
},
]),
},
orderExpress: {
waybill_code: 'WB207',
printinfo: JSON.stringify({
encryptedData: 'ENC-001',
signature: 'SIG-001',
templateURL: 'https://upstream.example.com/cainiao/main-template.xml',
ver: '1.0',
}),
cainiao_cp_code: 'STO_CAINIAO',
cainiao_template_url: 'https://example.com/cainiao/main-template.xml',
logistics_name: '申通快递',
},
policyConfig: {
waybill_custom_display_type: '5',
},
platformCode: 'cainiao',
templateSample: {
cmd: 'print',
requestID: 'REQ-207',
version: '1.0',
task: {
documents: [
{
documentID: 'DOC-207',
contents: [
{
templateURL: 'http://cloudprint.cainiao.com/cloudprint/template/getStandardTemplate.json?template_id=288948',
data: {
cpCode: '__SAMPLE__',
recipient: '__SAMPLE__',
waybillCode: '__SAMPLE__',
},
},
{
templateURL: 'http://cloudprint.cainiao.com/cloudprint/customArea/queryCustomAreaList4Top.json?custom_area_id=6474956',
data: {
CustomControl: '__SAMPLE__',
},
},
],
},
],
},
},
});
assert.equal(result.print_data.documentID, 'WB207');
assert.ok(Array.isArray(result.print_data.contents));
assert.equal(result.print_data.contents.length, 2);
const mainContent = result.print_data.contents[0];
assert.ok(mainContent);
assert.equal(mainContent.templateURL, 'https://example.com/cainiao/main-template.xml');
assert.equal(mainContent.encryptedData, 'ENC-001');
assert.equal(mainContent.signature, 'SIG-001');
assert.equal(mainContent.ver, '1.0');
assert.equal(mainContent.data, undefined);
const customContent = result.print_data.contents[1];
assert.ok(customContent);
assert.equal(customContent.templateURL, 'http://cloudprint.cainiao.com/cloudprint/customArea/queryCustomAreaList4Top.json?custom_area_id=6474956');
assert.ok(customContent.data.CustomControl.includes('W026 申通快递'));
assert.ok(customContent.data.CustomControl.includes('E1区01-19-01 运动短袖 988948487 【2】'));
});
it('should unwrap cainiao main content from wrapped contents printinfo without falling back order fields', () => {
const service = createOrderPrintServiceHarness();
const result = service.buildOrderPlatformPrintItem({
orderRow: {
id: 209,
wave_id: 27,
wave_no: 'W027',
delivery_order_code: 'DO209',
store_id: 1,
warehouse_id: 100000,
name: '订单收件人',
mobile: '13999990000',
province: '浙江省',
city: '杭州市',
area: '西湖区',
detail_address: '订单回填地址 1 号',
items: JSON.stringify([
{
item_name: 'fallback 运动短袖',
pick_location: 'A1-01-01',
barcode: '111111111',
quantity: 1,
},
]),
},
orderExpress: {
waybill_code: 'WB209',
printinfo: JSON.stringify({
contents: [
{
templateURL: 'https://upstream.example.com/cainiao/main-content.xml',
signature: 'SIG-CONTENT-209',
data: {
cpCode: 'STO_UPSTREAM',
recipient: {
name: '接口收件人',
mobile: '13888880000',
},
sender: {
name: '接口发件人',
},
packageInfo: {
goodsDescription: '接口商品描述',
items: [
{
count: 9,
name: '接口商品',
},
],
},
routingInfo: {
routeCode: 'CN-HZ-001',
},
waybillCode: 'WB209',
},
},
],
}),
cainiao_cp_code: 'STO_CAINIAO',
cainiao_template_url: 'https://example.com/cainiao/wrapped-template.xml',
logistics_name: '申通快递',
},
policyConfig: {
sender_name: '策略发件人',
sender_tel: '13777770000',
province_name: '上海市',
city_name: '上海市',
district_name: '闵行区',
address: '策略发件地址 2 号',
waybill_custom_display_type: '5',
},
platformCode: 'cainiao',
templateSample: {
cmd: 'print',
requestID: 'REQ-209',
version: '1.0',
task: {
documents: [
{
documentID: 'DOC-209',
contents: [
{
templateURL: 'http://cloudprint.cainiao.com/cloudprint/template/getStandardTemplate.json?template_id=288948',
data: {
cpCode: '__SAMPLE__',
recipient: {
name: '__SAMPLE__',
},
sender: {
name: '__SAMPLE__',
},
packageInfo: {
goodsDescription: '__SAMPLE__',
},
routingInfo: {
routeCode: '__SAMPLE__',
},
waybillCode: '__SAMPLE__',
},
},
{
templateURL: 'http://cloudprint.cainiao.com/cloudprint/customArea/queryCustomAreaList4Top.json?custom_area_id=6474956',
data: {
CustomControl: '__SAMPLE__',
},
},
],
},
],
},
},
});
const mainContent = result.print_data.contents[0];
assert.equal(mainContent.templateURL, 'https://example.com/cainiao/wrapped-template.xml');
assert.equal(mainContent.signature, 'SIG-CONTENT-209');
assert.equal(mainContent.data._dataFrom, 'printinfo');
assert.equal(mainContent.data.cpCode, 'STO_CAINIAO');
assert.equal(mainContent.data.realCpCode, 'STO_CAINIAO');
assert.equal(mainContent.data.recipient.name, '接口收件人');
assert.equal(mainContent.data.recipient.mobile, '13888880000');
assert.equal(mainContent.data.sender.name, '接口发件人');
assert.equal(mainContent.data.packageInfo.goodsDescription, '接口商品描述');
assert.deepEqual(mainContent.data.packageInfo.items, [
{
count: 9,
name: '接口商品',
},
]);
assert.equal(mainContent.data.routingInfo.routeCode, 'CN-HZ-001');
assert.notEqual(mainContent.data.recipient.name, '订单收件人');
assert.notEqual(mainContent.data.sender.name, '策略发件人');
const customContent = result.print_data.contents[1];
assert.ok(customContent);
assert.ok(customContent.data.CustomControl.includes('W027 申通快递'));
assert.ok(customContent.data.CustomControl.includes('A1-01-01 fallback 运动短袖 111111111 【1】'));
});
it('should fallback cainiao main content to template skeleton when printinfo is invalid', () => {
const service = createOrderPrintServiceHarness();
const result = service.buildOrderPlatformPrintItem({
orderRow: {
id: 208,
wave_id: 26,
wave_no: 'W026',
delivery_order_code: 'DO208',
store_id: 1,
warehouse_id: 100000,
logistics_code: 'YTO',
sys_logistics_code: 'YTO_SYS',
name: '李四',
mobile: '13911112222',
tel: '020-12345678',
province: '广东省',
city: '广州市',
area: '白云区',
detail_address: '鹤龙一路 88 号',
items: JSON.stringify([
{
item_name: '运动短袖',
quantity: 2,
},
{
item_name: '纯棉长裤',
quantity: 1,
},
]),
},
orderExpress: {
waybill_code: 'WB208',
printinfo: '{invalid-json',
cainiao_cp_code: 'YTO_CAINIAO',
cainiao_template_url: 'https://example.com/cainiao/fallback-template.xml',
logistics_code: '',
logistics_name: '圆通速递',
},
policyConfig: {
sender_name: '仓库发货人',
sender_tel: '13812345678',
province_name: '浙江省',
city_name: '杭州市',
district_name: '余杭区',
address: '良睦路 999 号',
},
platformCode: 'cainiao',
templateSample: {
cmd: 'print',
requestID: 'REQ-208',
version: '1.0',
task: {
documents: [
{
documentID: 'DOC-208',
contents: [
{
templateURL: 'http://cloudprint.cainiao.com/cloudprint/template/getStandardTemplate.json?template_id=288948',
data: {
cpCode: '__SAMPLE__',
realCpCode: '__SAMPLE__',
recipient: {
name: '__SAMPLE__',
mobile: '__SAMPLE__',
tel: '__SAMPLE__',
address: {
province: '__SAMPLE__',
city: '__SAMPLE__',
district: '__SAMPLE__',
detail: '__SAMPLE__',
},
},
sender: {
name: '__SAMPLE__',
mobile: '__SAMPLE__',
address: {
province: '__SAMPLE__',
city: '__SAMPLE__',
district: '__SAMPLE__',
detail: '__SAMPLE__',
},
},
packageInfo: {
goodsDescription: '__SAMPLE__',
items: [
{
count: '__SAMPLE__',
name: '__SAMPLE__',
},
],
},
waybillCode: '__SAMPLE__',
},
},
],
},
],
},
},
});
const mainData = result.print_data.contents[0].data;
assert.equal(result.print_data.contents[0].templateURL, 'https://example.com/cainiao/fallback-template.xml');
assert.equal(mainData.waybillCode, '');
assert.equal(mainData._dataFrom, 'template');
assert.equal(mainData.cpCode, 'YTO_CAINIAO');
assert.equal(mainData.realCpCode, 'YTO_CAINIAO');
assert.equal(mainData.recipient.name, '');
assert.equal(mainData.recipient.mobile, '');
assert.equal(mainData.recipient.tel, '');
assert.equal(mainData.recipient.address.province, '');
assert.equal(mainData.recipient.address.city, '');
assert.equal(mainData.recipient.address.district, '');
assert.equal(mainData.recipient.address.detail, '');
assert.equal(mainData.sender.name, '');
assert.equal(mainData.sender.mobile, '');
assert.equal(mainData.sender.address.province, '');
assert.equal(mainData.sender.address.city, '');
assert.equal(mainData.sender.address.district, '');
assert.equal(mainData.sender.address.detail, '');
assert.equal(mainData.packageInfo.goodsDescription, '');
assert.deepEqual(mainData.packageInfo.items, [
{
count: '',
name: '',
},
]);
assert.equal(mainData.routingInfo, undefined);
});
it('should parse string policy_config in getPolicyConfigMapByStore', async () => {
const service = createOrderPrintServiceHarness();
service.ctx.service.systems.storeWarehouse.getContractConfig = async () => ({
policy_config: JSON.stringify({
waybill_custom_display_type: '3',
sender_name: '赵六',
}),
});
const policyMap = await service.getPolicyConfigMapByStore([
{ store_id: 9 },
], 100000);
const storePolicy = policyMap.get(9) || {};
assert.equal(storePolicy.waybill_custom_display_type, '3');
assert.equal(storePolicy.sender_name, '赵六');
});
it('should default to literal compose when waybill display type is missing', () => {
const service = createOrderPrintServiceHarness();
const result = service.buildOrderPlatformPrintItem({
orderRow: {
id: 203,
wave_id: 22,
wave_no: 'W022',
delivery_order_code: 'DO203',
store_id: 1,
warehouse_id: 100000,
items: JSON.stringify([
{
item_name: '皮带黑色',
pick_location: 'E2区08-05-02',
barcode: '665835404213',
quantity: 1,
},
]),
},
orderExpress: {
waybill_code: 'WB203',
printinfo: 'ENC_203',
signature: 'SIG_203',
logistics_name: '韵达',
},
policyConfig: {
province_name: '广东省',
city_name: '广州市',
district_name: '白云区',
address: '良沙二路32号',
sender_name: '刘付明仁',
sender_tel: '18022440198',
},
platformCode: 'pdd',
templateSample: {
cmd: 'print',
requestID: 'REQ-203',
version: '11',
task: {
documents: [
{
contents: [
{
addData: {
sender: {
address: {
city: '',
detail: '',
district: '',
province: '',
},
mobile: '',
name: '',
},
},
encryptedData: '',
signature: '',
templateUrl: 'https://file-link.pinduoduo.com/sto_one',
userid: '',
ver: '11',
},
{
data: {
height: 240,
list: [
{
fontSize: 28,
left: 2.08,
text: '',
top: 2.08,
width: 550,
},
],
waterdata: {
text: '',
},
width: 560,
},
templateURL: 'http://www.ye4s.com/mb/pdd.xml',
},
],
documentID: 'DOC-203',
},
],
},
},
});
const customContent = result.print_data.contents.find(content => content && content.data && Array.isArray(content.data.list));
assert.ok(customContent);
assert.ok(customContent.data.list[0].text.includes('W022 韵达'));
assert.ok(customContent.data.list[0].text.includes('E2区08-05-02 皮带黑色 665835404213 【1】'));
});
it('should keep header line when item details are unavailable', () => {
const service = createOrderPrintServiceHarness();
const result = service.buildOrderPlatformPrintItem({
orderRow: {
id: 204,
wave_id: 23,
wave_no: 'W023',
delivery_order_code: 'DO204',
store_id: 1,
warehouse_id: 100000,
items: '',
items_count: 2,
},
orderExpress: {
waybill_code: 'WB204',
printinfo: 'ENC_204',
signature: 'SIG_204',
logistics_name: '中通',
},
policyConfig: {
waybill_custom_display_type: '5',
province_name: '广东省',
city_name: '广州市',
district_name: '白云区',
address: '良沙二路32号',
sender_name: '刘付明仁',
sender_tel: '18022440198',
},
platformCode: 'pdd',
templateSample: {
cmd: 'print',
requestID: 'REQ-204',
version: '11',
task: {
documents: [
{
contents: [
{
addData: {
sender: {
address: {
city: '',
detail: '',
district: '',
province: '',
},
mobile: '',
name: '',
},
},
encryptedData: '',
signature: '',
templateUrl: 'https://file-link.pinduoduo.com/sto_one',
userid: '',
ver: '11',
},
{
data: {
height: 240,
list: [
{
fontSize: 28,
left: 2.08,
text: '',
top: 2.08,
width: 550,
},
],
waterdata: {
text: '',
},
width: 560,
},
templateURL: 'http://www.ye4s.com/mb/pdd.xml',
},
],
documentID: 'DOC-204',
},
],
},
},
});
const customContent = result.print_data.contents.find(content => content && content.data && Array.isArray(content.data.list));
assert.ok(customContent);
// 头部行:波次号 + 快递渠道名 + 商品总数【n】(无商品明细时回退 items_total/items_count)
assert.equal(customContent.data.list[0].text, 'W023 中通 商品总数【2】\r');
});
it('should render detail lines from non-json string items', () => {
const service = createOrderPrintServiceHarness();
const result = service.buildOrderPlatformPrintItem({
orderRow: {
id: 205,
wave_id: 24,
wave_no: 'W024',
delivery_order_code: 'DO205',
store_id: 1,
warehouse_id: 100000,
items: '皮带黑色*1|皮带金色*2',
items_count: 2,
},
orderExpress: {
waybill_code: 'WB205',
printinfo: 'ENC_205',
signature: 'SIG_205',
logistics_name: '申通快递',
},
policyConfig: {
waybill_custom_display_type: '2',
province_name: '广东省',
city_name: '广州市',
district_name: '白云区',
address: '良沙二路32号',
sender_name: '刘付明仁',
sender_tel: '18022440198',
},
platformCode: 'kuaishou',
templateSample: {
cmd: 'print',
requestID: 'REQ-205',
version: '1.0',
task: {
documents: [
{
contents: [
{
encryptedData: '',
signature: '',
key: '',
templateURL: 'https://example.com/kuaishou.xml',
},
{
templateURL: 'http://www.ye4s.com/mb/kuaishou.xml',
customData: {
productInfo: '',
},
},
],
},
],
},
},
});
const customDataContent = result.print_data.contents.find(content => content && content.customData);
assert.ok(customDataContent);
assert.ok(customDataContent.customData.productInfo.includes('W024 申通快递'));
assert.ok(customDataContent.customData.productInfo.includes('皮带黑色 【1】'));
assert.ok(customDataContent.customData.productInfo.includes('皮带金色 【2】'));
});
it('should render display type 4 as pick location + last 5 barcode + qty per line', () => {
const service = createOrderPrintServiceHarness();
const result = service.buildOrderPlatformPrintItem({
orderRow: {
id: 206,
wave_id: 25,
wave_no: 'W025',
delivery_order_code: 'DO206',
store_id: 1,
warehouse_id: 100000,
items: 'E2区08-05-02 皮带黑色;665835404213 【1】 0|E2区08-04-02 皮带金色;600507 【1】 0',
items_count: 2,
},
orderExpress: {
waybill_code: 'WB206',
printinfo: 'ENC_206',
signature: 'SIG_206',
logistics_name: '顺丰空运',
},
policyConfig: {
waybill_custom_display_type: '4',
province_name: '广东省',
city_name: '广州市',
district_name: '白云区',
address: '良沙二路32号',
sender_name: '刘付明仁',
sender_tel: '18022440198',
},
platformCode: 'pdd',
templateSample: {
cmd: 'print',
requestID: 'REQ-206',
version: '11',
task: {
documents: [
{
contents: [
{
addData: {
sender: {
address: {
city: '',
detail: '',
district: '',
province: '',
},
mobile: '',
name: '',
},
},
encryptedData: '',
signature: '',
templateUrl: 'https://file-link.pinduoduo.com/sto_one',
userid: '',
ver: '11',
},
{
data: {
height: 240,
list: [
{
fontSize: 28,
left: 2.08,
text: '',
top: 2.08,
width: 550,
},
],
waterdata: {
text: '',
},
width: 560,
},
templateURL: 'http://www.ye4s.com/mb/pdd.xml',
},
],
documentID: 'DOC-206',
},
],
},
},
});
const customContent = result.print_data.contents.find(content => content && content.data && Array.isArray(content.data.list));
assert.ok(customContent);
const text = customContent.data.list[0].text;
assert.ok(text.includes('W025 顺丰空运'));
assert.ok(text.includes('E2区08-05-02 04213 【1】'));
assert.ok(text.includes('E2区08-04-02 00507 【1】'));
assert.ok(!text.includes('\r【1】\r'));
});
it('should query order_express with kuaishou encrypted payload columns', async () => {
const service = createOrderPrintServiceHarness();
let capturedAttributes = [];
let capturedWhere = {};
service.ctx.model.OrderExpress = {
async findAll(options) {
capturedAttributes = Array.isArray(options && options.attributes) ? options.attributes : [];
capturedWhere = options && options.where || {};
return [];
},
};
await service.queryOrderExpressByOrderIds([ 101 ]);
assert.ok(capturedAttributes.includes('printinfo'));
assert.ok(capturedAttributes.includes('signature'));
assert.ok(capturedAttributes.includes('encryptprintinfo'));
assert.ok(capturedAttributes.includes('ver'));
assert.ok(capturedAttributes.includes('logistics_interface_name'));
assert.equal(capturedWhere.business_key, 1);
});
it('should keep original platform value in resolvePrintPlatformCode without alias mapping', () => {
const service = createOrderPrintServiceHarness();
const platformCode = service.resolvePrintPlatformCode(
{
sys_platform_code: ' Taobao ',
source_platform_code: ' tb ',
},
{
platform_code: ' cainiao ',
}
);
assert.equal(platformCode, 'Taobao');
});
it('should keep original platform field in buildOrderPlatformPrintItem result', () => {
const service = createOrderPrintServiceHarness();
const result = service.buildOrderPlatformPrintItem({
orderRow: {
id: 301,
wave_id: 31,
wave_no: 'W031',
delivery_order_code: 'DO301',
store_id: 1,
warehouse_id: 100000,
},
orderExpress: {
waybill_code: 'WB301',
},
policyConfig: {},
platformCode: ' Taobao ',
templateSample: {},
});
assert.equal(result.platform, 'Taobao');
});
it('should throw when business_key=1 waybill data is missing', async () => {
const service = createOrderPrintServiceHarness();
service.queryWavesByIds = async () => ([
{ wave_id: 1, wave_no: 'W001' },
]);
service.queryOrdersByWaveIds = async () => ([
{
id: 101,
wave_id: 1,
wave_no: 'W001',
warehouse_id: 100000,
store_id: 1,
delivery_order_code: 'O101',
post_status: 'fin',
sys_platform_code: 'kuaishou',
},
{
id: 102,
wave_id: 1,
wave_no: 'W001',
warehouse_id: 100000,
store_id: 1,
delivery_order_code: 'O102',
post_status: 'fin',
sys_platform_code: 'kuaishou',
},
]);
service.filterFullyAssignedExpressWaves = () => ({
validWaveIds: [ 1 ],
filteredWaveIds: [],
});
service.queryOrderExpressByOrderIds = async () => ([
{
order_id: 101,
business_key: 1,
waybill_code: 'WB101',
},
{
order_id: 102,
business_key: 1,
waybill_code: '',
},
]);
await assert.rejects(
async () => service.getWavePlatformPrintData({
waveIds: [ 1 ],
warehouseId: 100000,
}),
error => {
assert.ok(error instanceof Error);
assert.ok(error.message.includes('业务id为1的运单号数据缺失'));
return true;
}
);
});
it('should return waveGroups grouped by wave then platform+sys_logistics and keep summary counters correct', async () => {
const service = createOrderPrintServiceHarness();
service.queryWavesByIds = async () => ([
{ wave_id: 2, wave_no: 'W002' },
{ wave_id: 1, wave_no: 'W001' },
]);
service.queryOrdersByWaveIds = async () => ([
{
id: 11,
wave_id: 1,
wave_no: 'W001',
warehouse_id: 100000,
store_id: 1,
delivery_order_code: 'O11',
post_status: 'fin',
sys_platform_code: 'jd',
},
{
id: 12,
wave_id: 1,
wave_no: 'W001',
warehouse_id: 100000,
store_id: 1,
delivery_order_code: 'O12',
post_status: 'fin',
sys_platform_code: 'cainiao',
},
{
id: 21,
wave_id: 2,
wave_no: 'W002',
warehouse_id: 100000,
store_id: 2,
delivery_order_code: 'O21',
post_status: 'fin',
sys_platform_code: 'jd',
},
]);
service.filterFullyAssignedExpressWaves = () => ({
validWaveIds: [ 2, 1 ],
filteredWaveIds: [],
});
service.queryOrderExpressByOrderIds = async () => ([
{
order_id: 11,
business_key: 1,
waybill_code: 'WB11',
},
{
order_id: 12,
business_key: 1,
waybill_code: 'WB12',
},
{
order_id: 21,
business_key: 1,
waybill_code: 'WB21',
},
]);
service.buildOrderExpressMap = () => new Map();
service.getPolicyConfigMapByStore = async () => new Map([
[ 1, {}],
[ 2, {}],
]);
service.resolvePrintPlatformCode = orderRow => String(orderRow && orderRow.sys_platform_code || '').trim();
service.loadTemplateSampleByPlatform = () => ({});
service.buildOrderPlatformPrintItem = ({ orderRow, platformCode }) => ({
wave_id: Number(orderRow.wave_id),
wave_no: String(orderRow.wave_no),
order_id: Number(orderRow.id),
order_no: String(orderRow.delivery_order_code),
platform: String(platformCode),
platform_name: platformCode === 'jd' ? '京东' : '菜鸟',
print_data: {
platform: String(platformCode),
order_id: Number(orderRow.id),
},
});
const result = await service.getWavePlatformPrintData({
waveIds: [ 2, 1 ],
warehouseId: 100000,
});
assert.deepEqual(result.summary, {
total_waves: 2,
total_orders: 3,
total_platforms: 3,
locked_count: 0,
total_locked_orders: 0,
});
assert.equal(result.waveGroups.length, 2);
assert.deepEqual(result.waveGroups.map(item => item.wave_no), [ 'W001', 'W002' ]);
assert.deepEqual(result.waveGroups[0], {
wave_id: 1,
wave_no: 'W001',
order_count: 2,
platforms: [
{
platform: 'cainiao',
platform_name: '菜鸟',
sys_logistics_code: 'unknown',
sys_logistics_name: 'unknown',
order_count: 1,
order_ids: [ 12 ],
orders: [
{
platform: 'cainiao',
order_id: 12,
},
],
},
{
platform: 'jd',
platform_name: '京东',
sys_logistics_code: 'unknown',
sys_logistics_name: 'unknown',
order_count: 1,
order_ids: [ 11 ],
orders: [
{
platform: 'jd',
order_id: 11,
},
],
},
],
});
assert.deepEqual(result.waveGroups[1], {
wave_id: 2,
wave_no: 'W002',
order_count: 1,
platforms: [
{
platform: 'jd',
platform_name: '京东',
sys_logistics_code: 'unknown',
sys_logistics_name: 'unknown',
order_count: 1,
order_ids: [ 21 ],
orders: [
{
platform: 'jd',
order_id: 21,
},
],
},
],
});
assert.deepEqual(result.ext, {
missing_wave_ids: [],
filtered_wave_ids: [],
});
});
it('should group platform orders by platform+sys_logistics as flattened platform items', () => {
const service = createOrderPrintServiceHarness();
const waveGroups = service.groupOrderPrintItemsByWaveAndPlatform({
waveRows: [
{ wave_id: 1, wave_no: 'W001' },
],
hitWaveIds: [ 1 ],
orderPrintList: [
{
wave_id: 1,
order_id: 11,
platform: 'jd',
platform_name: '京东',
sys_logistics_code: 'ZTO',
sys_logistics_name: '中通快递',
print_data: { order_id: 11 },
},
{
wave_id: 1,
order_id: 12,
platform: 'jd',
platform_name: '京东',
sys_logistics_code: 'YTO',
sys_logistics_name: '圆通速递',
print_data: { order_id: 12 },
},
{
wave_id: 1,
order_id: 13,
platform: 'jd',
platform_name: '京东',
sys_logistics_code: 'ZTO',
sys_logistics_name: '中通快递',
print_data: { order_id: 13 },
},
{
wave_id: 1,
order_id: 14,
platform: 'jd',
platform_name: '京东',
sys_logistics_code: '',
sys_logistics_name: '',
print_data: { order_id: 14 },
},
],
});
assert.equal(waveGroups.length, 1);
assert.equal(waveGroups[0].platforms.length, 3);
assert.equal(waveGroups[0].order_count, 4);
const ztoGroup = waveGroups[0].platforms.find(item => item && item.sys_logistics_code === 'ZTO');
assert.ok(ztoGroup);
assert.deepEqual(ztoGroup, {
platform: 'jd',
platform_name: '京东',
sys_logistics_code: 'ZTO',
sys_logistics_name: '中通快递',
order_count: 2,
order_ids: [ 11, 13 ],
orders: [
{ order_id: 11 },
{ order_id: 13 },
],
});
const ytoGroup = waveGroups[0].platforms.find(item => item && item.sys_logistics_code === 'YTO');
assert.ok(ytoGroup);
assert.deepEqual(ytoGroup, {
platform: 'jd',
platform_name: '京东',
sys_logistics_code: 'YTO',
sys_logistics_name: '圆通速递',
order_count: 1,
order_ids: [ 12 ],
orders: [
{ order_id: 12 },
],
});
const unknownGroup = waveGroups[0].platforms.find(item => item && item.sys_logistics_code === 'unknown');
assert.ok(unknownGroup);
assert.deepEqual(unknownGroup, {
platform: 'jd',
platform_name: '京东',
sys_logistics_code: 'unknown',
sys_logistics_name: 'unknown',
order_count: 1,
order_ids: [ 14 ],
orders: [
{ order_id: 14 },
],
});
});
it('should batch load picking locations from wms_picking for print items', async () => {
const service = createOrderPrintServiceHarness();
const currentOrderItemsModel = {
async findAll() {
return [
{
id: 5001,
order_id: 301,
item_code: 'SKU-301',
item_name: '商品301',
plan_qty: 1,
item_snapshot: {
barcode: '9988776655443',
},
},
];
},
};
service.ctx.model.Picking = {
async findAll() {
return [
{
id: 1,
order_id: 301,
order_item_id: 5001,
quantity: 1,
space_id: 9001,
space_name: 'E2区08-05-02',
status: 'pending',
},
];
},
};
service.ctx.model.OrderItemsFactory = {
async getCurrentModel() {
return currentOrderItemsModel;
},
};
service.ctx.model.LocationSpace = {
async findAll() {
throw new Error('space_name 已存在时不应查询库位表');
},
};
service.queryWavesByIds = async () => ([
{ wave_id: 30, wave_no: 'W030' },
]);
service.queryOrdersByWaveIds = async () => ([
{
id: 301,
wave_id: 30,
wave_no: 'W030',
warehouse_id: 100000,
store_id: 1,
delivery_order_code: 'O301',
post_status: 'fin',
sys_platform_code: 'pdd',
items: '',
},
]);
service.filterFullyAssignedExpressWaves = () => ({
validWaveIds: [ 30 ],
filteredWaveIds: [],
});
service.queryOrderExpressByOrderIds = async () => ([
{
order_id: 301,
business_key: 1,
waybill_code: 'WB301',
logistics_name: '顺丰空运',
},
]);
service.queryWaveOrderIndexMapByOrderIds = async () => new Map([
[ 301, {
wave_id: 30,
wave_index: 12,
platforms_index: 3,
}],
]);
service.queryWaveTotalOrderCountMap = async () => new Map([
[ 30, 66 ],
]);
service.getPolicyConfigMapByStore = async () => new Map([
[ 1, {
waybill_custom_display_type: '4',
}],
]);
service.loadTemplateSampleByPlatform = () => ({
cmd: 'print',
requestID: 'REQ-301',
version: '11',
task: {
documents: [
{
contents: [
{
addData: {
sender: {
address: {},
},
},
encryptedData: '',
signature: '',
templateUrl: 'https://file-link.pinduoduo.com/sto_one',
userid: '',
ver: '11',
},
{
templateURL: 'http://www.ye4s.com/mb/pdd.xml',
data: {
height: 240,
list: [
{
fontSize: 28,
left: 2.08,
text: '',
top: 2.08,
width: 550,
},
],
waterdata: {
text: '',
},
width: 560,
},
},
],
documentID: 'DOC-301',
},
],
},
});
const result = await service.getWavePlatformPrintData({
waveIds: [ 30 ],
warehouseId: 100000,
});
const printText = result.waveGroups[0].platforms[0].orders[0].contents[1].data.list[0].text;
assert.ok(printText.includes('【66】W030_12_3'));
assert.ok(printText.includes('E2区08-05-02 55443 【1】'));
});
it('should use real order wave_id for wave total count when wave index has dirty wave_id', async () => {
const service = createOrderPrintServiceHarness();
let capturedWaveIdsForIndexQuery = [];
let capturedWaveIdsForCountQuery = [];
service.queryWavesByIds = async () => ([
{ wave_id: 40, wave_no: 'W040' },
]);
service.queryOrdersByWaveIds = async () => ([
{
id: 401,
wave_id: 40,
wave_no: 'W040',
warehouse_id: 100000,
store_id: 1,
delivery_order_code: 'O401',
post_status: 'fin',
sys_platform_code: 'pdd',
},
]);
service.filterFullyAssignedExpressWaves = () => ({
validWaveIds: [ 40 ],
filteredWaveIds: [],
});
service.queryOrderExpressByOrderIds = async () => ([
{
order_id: 401,
business_key: 1,
waybill_code: 'WB401',
},
]);
service.getPolicyConfigMapByStore = async () => new Map([
[ 1, {}],
]);
service.queryWaveOrderIndexMapByOrderIds = async (orderIds, warehouseId, waveIds) => {
capturedWaveIdsForIndexQuery = Array.isArray(waveIds) ? waveIds : [];
assert.deepEqual(orderIds, [ 401 ]);
assert.equal(warehouseId, 100000);
return new Map([
[ 401, {
wave_id: 999,
wave_index: 7,
platforms_index: 2,
}],
]);
};
service.queryWaveTotalOrderCountMap = async waveIds => {
capturedWaveIdsForCountQuery = Array.isArray(waveIds) ? waveIds : [];
return new Map([
[ 40, 66 ],
[ 999, 1 ],
]);
};
service.loadTemplateSampleByPlatform = () => ({});
service.buildOrderPlatformPrintItem = ({ orderRow, platformCode }) => ({
wave_id: Number(orderRow.wave_id || 0),
platform: String(platformCode || ''),
platform_name: '拼多多',
print_data: {
order_id: Number(orderRow.id || 0),
wave_total_orders: Number(orderRow.wave_total_orders || 0),
},
});
const result = await service.getWavePlatformPrintData({
waveIds: [ 40 ],
warehouseId: 100000,
});
assert.deepEqual(capturedWaveIdsForIndexQuery, [ 40 ]);
assert.deepEqual(capturedWaveIdsForCountQuery, [ 40 ]);
assert.ok(!capturedWaveIdsForCountQuery.includes(999));
assert.equal(result.waveGroups[0].platforms[0].orders[0].wave_total_orders, 66);
});
it('should prefer snapshot item_name for display type 2 in getWavePlatformPrintData', async () => {
const service = createOrderPrintServiceHarness();
const currentOrderItemsModel = {
async findAll() {
return [
{
id: 6001,
order_id: 302,
item_code: 'SKU-302',
item_name: '旧商品名-不应展示',
plan_qty: 1,
item_snapshot: {
item_name: '快照商品名-应展示',
},
},
];
},
};
service.ctx.model.Picking = {
async findAll() {
return [
{
id: 2,
order_id: 302,
order_item_id: 6001,
quantity: 1,
space_id: 9101,
space_name: 'A1区01-01-01',
status: 'pending',
},
];
},
};
service.ctx.model.OrderItemsFactory = {
async getCurrentModel() {
return currentOrderItemsModel;
},
};
service.ctx.model.LocationSpace = {
async findAll() {
throw new Error('space_name 已存在时不应查询库位表');
},
};
service.queryWavesByIds = async () => ([
{ wave_id: 31, wave_no: 'W031' },
]);
service.queryOrdersByWaveIds = async () => ([
{
id: 302,
wave_id: 31,
wave_no: 'W031',
warehouse_id: 100000,
store_id: 1,
delivery_order_code: 'O302',
post_status: 'fin',
sys_platform_code: 'pdd',
items: '',
},
]);
service.filterFullyAssignedExpressWaves = () => ({
validWaveIds: [ 31 ],
filteredWaveIds: [],
});
service.queryOrderExpressByOrderIds = async () => ([
{
order_id: 302,
business_key: 1,
waybill_code: 'WB302',
logistics_name: '圆通',
},
]);
service.queryWaveOrderIndexMapByOrderIds = async () => new Map([
[ 302, {
wave_id: 31,
wave_index: 1,
platforms_index: 1,
}],
]);
service.queryWaveTotalOrderCountMap = async () => new Map([
[ 31, 10 ],
]);
service.getPolicyConfigMapByStore = async () => new Map([
[ 1, {
waybill_custom_display_type: '2',
}],
]);
service.loadTemplateSampleByPlatform = () => ({
cmd: 'print',
requestID: 'REQ-302',
version: '11',
task: {
documents: [
{
contents: [
{
addData: {
sender: {
address: {},
},
},
encryptedData: '',
signature: '',
templateUrl: 'https://file-link.pinduoduo.com/sto_one',
userid: '',
ver: '11',
},
{
templateURL: 'http://www.ye4s.com/mb/pdd.xml',
data: {
height: 240,
list: [
{
fontSize: 28,
left: 2.08,
text: '',
top: 2.08,
width: 550,
},
],
waterdata: {
text: '',
},
width: 560,
},
},
],
documentID: 'DOC-302',
},
],
},
});
const result = await service.getWavePlatformPrintData({
waveIds: [ 31 ],
warehouseId: 100000,
});
const printText = result.waveGroups[0].platforms[0].orders[0].contents[1].data.list[0].text;
assert.ok(printText.includes('快照商品名-应展示'));
assert.ok(!printText.includes('旧商品名-不应展示'));
});
it('should return locked_wave_groups when all orders are locked', async () => {
const service = createOrderPrintServiceHarness();
service.queryWavesByIds = async () => ([
{ wave_id: 50, wave_no: 'W050' },
]);
service.queryOrdersByWaveIds = async () => ([
{
id: 501,
wave_id: 50,
wave_no: 'W050',
warehouse_id: 100000,
store_id: 1,
delivery_order_code: 'O501',
source_order_codes: 'SO501',
post_status: 'fin',
print_lock_status: 'warehouse',
},
]);
service.filterFullyAssignedExpressWaves = () => ({
validWaveIds: [ 50 ],
filteredWaveIds: [],
});
const result = await service.getWavePlatformPrintData({
waveIds: [ 50 ],
warehouseId: 100000,
});
assert.equal(result.summary.total_orders, 0);
assert.equal(result.summary.total_locked_orders, 1);
assert.equal(result.summary.locked_count, 1);
assert.equal(result.locked_count, 1);
assert.deepEqual(result.waveGroups, []);
assert.equal(result.locked_wave_groups.length, 1);
assert.equal(result.locked_wave_groups[0].wave_id, 50);
assert.equal(result.locked_wave_groups[0].order_count, 1);
assert.equal(result.locked_wave_groups[0].platforms.length, 1);
assert.equal(result.locked_wave_groups[0].platforms[0].order_count, 1);
assert.equal(result.locked_wave_groups[0].platforms[0].orders[0].status, 'locked');
assert.equal(result.locked_wave_groups[0].platforms[0].orders[0].status_text, '已锁定');
assert.equal(result.locked_orders[0].order_id, 501);
assert.equal(result.locked_orders[0].print_lock_status, 'warehouse');
assert.equal(result.locked_orders[0].status, 'locked');
assert.equal(result.locked_orders[0].status_text, '已锁定');
});
it('should separate locked and unlocked orders into waveGroups and locked_wave_groups', async () => {
const service = createOrderPrintServiceHarness();
service.queryWavesByIds = async () => ([
{ wave_id: 60, wave_no: 'W060' },
]);
service.queryOrdersByWaveIds = async () => ([
{
id: 601,
wave_id: 60,
wave_no: 'W060',
warehouse_id: 100000,
store_id: 1,
delivery_order_code: 'O601',
post_status: 'fin',
print_lock_status: 'warehouse',
sys_platform_code: 'jd',
},
{
id: 602,
wave_id: 60,
wave_no: 'W060',
warehouse_id: 100000,
store_id: 1,
delivery_order_code: 'O602',
post_status: 'fin',
print_lock_status: 'none',
sys_platform_code: 'jd',
},
]);
service.filterFullyAssignedExpressWaves = () => ({
validWaveIds: [ 60 ],
filteredWaveIds: [],
});
service.queryOrderExpressByOrderIds = async orderIds => {
assert.deepEqual(orderIds, [ 602 ]);
return [
{
order_id: 602,
business_key: 1,
waybill_code: 'WB602',
},
];
};
service.getPolicyConfigMapByStore = async () => new Map([
[ 1, {}],
]);
service.queryWaveOrderIndexMapByOrderIds = async () => new Map();
service.queryWaveTotalOrderCountMap = async () => new Map();
service.buildOrderExpressMap = rows => new Map((Array.isArray(rows) ? rows : []).map(row => [ row.order_id, row ]));
service.resolvePrintPlatformCode = orderRow => String(orderRow && orderRow.sys_platform_code || '').trim();
service.loadTemplateSampleByPlatform = () => ({});
service.buildOrderPlatformPrintItem = ({ orderRow, platformCode }) => ({
wave_id: Number(orderRow.wave_id),
wave_no: String(orderRow.wave_no),
order_id: Number(orderRow.id),
order_no: String(orderRow.delivery_order_code),
platform: String(platformCode),
platform_name: '京东',
print_data: {
order_id: Number(orderRow.id),
status: 'ready',
},
});
const result = await service.getWavePlatformPrintData({
waveIds: [ 60 ],
warehouseId: 100000,
});
assert.equal(result.waveGroups.length, 1);
assert.deepEqual(result.waveGroups[0].platforms[0].order_ids, [ 602 ]);
assert.equal(result.waveGroups[0].platforms[0].orders[0].status, 'ready');
assert.equal(result.locked_wave_groups.length, 1);
assert.deepEqual(result.locked_wave_groups[0].platforms[0].order_ids, [ 601 ]);
assert.equal(result.locked_wave_groups[0].platforms[0].orders[0].status, 'locked');
assert.equal(result.locked_wave_groups[0].platforms[0].orders[0].status_text, '已锁定');
assert.equal(result.locked_count, 1);
assert.equal(result.locked_orders.length, 1);
assert.equal(result.locked_orders[0].order_id, 601);
assert.equal(result.summary.total_orders, 1);
assert.equal(result.summary.locked_count, 1);
assert.equal(result.summary.total_locked_orders, 1);
});
it('should prefer order_express platform_code for wave platform print data', async () => {
const service = createOrderPrintServiceHarness();
service.queryWavesByIds = async () => ([
{ wave_id: 70, wave_no: 'W070' },
]);
service.queryOrdersByWaveIds = async () => ([
{
id: 701,
wave_id: 70,
wave_no: 'W070',
warehouse_id: 100000,
store_id: 1,
delivery_order_code: 'O701',
post_status: 'fin',
print_lock_status: 'none',
sys_platform_code: 'TB',
},
]);
service.filterFullyAssignedExpressWaves = () => ({
validWaveIds: [ 70 ],
filteredWaveIds: [],
});
service.queryOrderExpressByOrderIds = async () => ([
{
order_id: 701,
business_key: 1,
waybill_code: 'WB701',
platform_code: 'CAINIAO',
},
]);
service.getPolicyConfigMapByStore = async () => new Map([
[ 1, {}],
]);
service.queryWaveOrderIndexMapByOrderIds = async () => new Map();
service.queryWaveTotalOrderCountMap = async () => new Map();
service.buildOrderExpressMap = rows => new Map((Array.isArray(rows) ? rows : []).map(row => [ row.order_id, row ]));
service.loadTemplateSampleByPlatform = () => ({});
service.buildOrderPlatformPrintItem = ({ orderRow, platformCode }) => ({
wave_id: Number(orderRow.wave_id),
wave_no: String(orderRow.wave_no),
order_id: Number(orderRow.id),
order_no: String(orderRow.delivery_order_code),
platform: String(platformCode),
platform_name: platformCode === 'CAINIAO' ? '菜鸟' : '淘宝',
print_data: {
order_id: Number(orderRow.id),
platform: String(platformCode),
},
});
const result = await service.getWavePlatformPrintData({
waveIds: [ 70 ],
warehouseId: 100000,
});
assert.equal(result.waveGroups[0].platforms[0].platform, 'CAINIAO');
assert.equal(result.waveGroups[0].platforms[0].platform_name, '菜鸟');
});
it('should enrich cainiao cpCode and main template url before building print data', async () => {
const service = createOrderPrintServiceHarness();
const captured = {
expressCodes: null,
interfacePayload: null,
pickArgs: null,
orderExpress: null,
};
service.queryWavesByIds = async () => ([
{ wave_id: 80, wave_no: 'W080' },
]);
service.queryOrdersByWaveIds = async () => ([
{
id: 801,
wave_id: 80,
wave_no: 'W080',
warehouse_id: 100000,
store_id: 1,
delivery_order_code: 'O801',
post_status: 'fin',
sys_platform_code: 'cainiao',
sys_logistics_code: 'YTO_SYS',
logistics_code: 'YTO',
},
]);
service.filterFullyAssignedExpressWaves = () => ({
validWaveIds: [ 80 ],
filteredWaveIds: [],
});
service.queryOrderExpressByOrderIds = async () => ([
{
order_id: 801,
business_key: 1,
waybill_code: 'WB801',
logistics_code: 'YTO',
platform_code: 'CAINIAO',
},
]);
service.getPolicyConfigMapByStore = async () => new Map([
[ 1, {}],
]);
service.queryWaveOrderIndexMapByOrderIds = async () => new Map();
service.queryWaveTotalOrderCountMap = async () => new Map();
service.loadTemplateSampleByPlatform = () => ({});
service.ctx.model.Express.findAll = async options => {
captured.expressCodes = options && options.where && options.where.code && options.where.code[Symbol.for('sequelize.operator.in')];
return [
{
code: 'YTO_SYS',
CAINIAO: 'YTO_CAINIAO',
},
];
};
service.ctx.service.systems.setting.expressInterface.listByWarehousePlatformCode = async payload => {
captured.interfacePayload = payload;
return {
code: 200,
data: [
{
id: 1,
sys_express_code: 'YTO_SYS',
express_code: 'YTO',
template_url: 'https://example.com/cainiao/order-main.xml',
express: {
CAINIAO: 'YTO_CAINIAO',
},
},
],
};
};
service.ctx.service.systems.express.pickWaybillExpressInterface = (interfaceList, groupedOrder, matchedPlatform) => {
captured.pickArgs = {
interfaceList,
groupedOrder,
matchedPlatform,
};
return interfaceList[0];
};
service.buildOrderPlatformPrintItem = ({ orderExpress }) => {
captured.orderExpress = orderExpress;
return {
wave_id: 80,
wave_no: 'W080',
order_id: 801,
order_no: 'O801',
platform: 'CAINIAO',
platform_name: '菜鸟',
sys_logistics_code: 'YTO_SYS',
sys_logistics_name: '圆通',
waybill_code: 'WB801',
print_data: {
order_id: 801,
},
};
};
const result = await service.getWavePlatformPrintData({
waveIds: [ 80 ],
warehouseId: 100000,
});
assert.equal(result.waveGroups.length, 1);
assert.deepEqual(captured.interfacePayload, {
warehouseId: 100000,
platformCode: 'CAINIAO',
});
assert.equal(captured.pickArgs.groupedOrder.options.logistics_code, 'YTO');
assert.equal(captured.pickArgs.matchedPlatform.code, 'CAINIAO');
assert.equal(captured.orderExpress.cainiao_cp_code, 'YTO_CAINIAO');
assert.equal(captured.orderExpress.cainiao_template_url, 'https://example.com/cainiao/order-main.xml');
});
});