fix(print): callback sync order print_status by order_ids

This commit is contained in:
liufumingren 2026-05-20 04:55:16 +08:00
parent 9fca81e7b5
commit b629b59d4b
2 changed files with 1963 additions and 56 deletions

File diff suppressed because it is too large Load Diff

View File

@ -15,12 +15,50 @@ function createContext(options = {}) {
const calls = {
printRecordCreatePayloads: [],
printRecordUpdatePayloads: [],
printRecordStaticUpdatePayloads: [],
printRecordFindOnePayloads: [],
printRecordFindAllPayloads: [],
printTaskMapCreatePayloads: [],
printTaskMapFindOnePayloads: [],
printTaskMapUpdatePayloads: [],
sendToComputerPayloads: [],
sendOrderMarks: [],
redisGetKeys: [],
platformFindAllWheres: [],
orderDeliveryLockUpdates: [],
};
const state = {
nextPrintRecordId: 9001,
printRecordsById: {
9001: {
id: 9001,
print_task_code: String(requestOptions.initialPrintTaskCode || ''),
status: 'pending',
},
},
printTaskMapByTaskCode: {},
};
if (Array.isArray(requestOptions.initialPrintRecords)) {
for (const record of requestOptions.initialPrintRecords) {
const recordId = Number(record && record.id ? record.id : 0);
if (!recordId) {
continue;
}
state.printRecordsById[recordId] = {
...(state.printRecordsById[recordId] || {}),
...record,
id: recordId,
};
if (recordId >= state.nextPrintRecordId) {
state.nextPrintRecordId = recordId + 1;
}
}
}
let duplicateTaskCodeTimes = Number(requestOptions.duplicateTaskCodeTimes || 0);
const platformComponents = requestOptions.platformComponents || {
cainiao: '菜鸟',
pdd: '拼多多',
@ -76,6 +114,16 @@ function createContext(options = {}) {
baseDir: process.cwd(),
config: {
jwt: {},
printTaskCodeRetry: {
maxRetries: 5,
baseDelayMs: 0,
jitterMs: 0,
},
printTaskCodeWritebackRetry: {
maxRetries: 3,
baseDelayMs: 0,
jitterMs: 0,
},
},
Sequelize: {},
redis: {
@ -103,13 +151,122 @@ function createContext(options = {}) {
PrintRecord: {
async create(payload) {
calls.printRecordCreatePayloads.push(payload);
const currentId = state.nextPrintRecordId;
state.nextPrintRecordId += 1;
state.printRecordsById[currentId] = {
id: currentId,
print_task_code: '',
...payload,
};
return {
id: 9001,
id: currentId,
async update(updatePayload) {
calls.printRecordUpdatePayloads.push(updatePayload);
calls.printRecordUpdatePayloads.push({ id: currentId, payload: updatePayload });
state.printRecordsById[currentId] = {
...(state.printRecordsById[currentId] || { id: currentId }),
...updatePayload,
};
},
};
},
async findOne(query) {
calls.printRecordFindOnePayloads.push(query || {});
const where = query && query.where ? query.where : {};
const printRecordId = Number(where.id || 0);
if (!printRecordId || !state.printRecordsById[printRecordId]) {
return null;
}
return {
...state.printRecordsById[printRecordId],
};
},
async findAll(query) {
calls.printRecordFindAllPayloads.push(query || {});
const where = query && query.where ? query.where : {};
const idList = Array.isArray(where.id)
? where.id.map(item => Number(item)).filter(item => Number.isInteger(item) && item > 0)
: [];
const warehouseId = where.warehouse_id;
const records = Object.values(state.printRecordsById).filter(item => {
const currentId = Number(item && item.id ? item.id : 0);
if (idList.length > 0 && !idList.includes(currentId)) {
return false;
}
if (warehouseId !== undefined && warehouseId !== null && item.warehouse_id !== warehouseId) {
return false;
}
return true;
});
return records.map(item => ({ ...item }));
},
async update(payload, query) {
calls.printRecordStaticUpdatePayloads.push({ payload, query });
const where = query && query.where ? query.where : {};
const printRecordId = Number(where.id || 0);
if (!printRecordId || !state.printRecordsById[printRecordId]) {
return [ 0 ];
}
state.printRecordsById[printRecordId] = {
...state.printRecordsById[printRecordId],
...payload,
};
return [ 1 ];
},
},
PrintTaskMap: {
async create(payload) {
calls.printTaskMapCreatePayloads.push(payload);
if (duplicateTaskCodeTimes > 0) {
duplicateTaskCodeTimes -= 1;
const duplicateError = new Error('Duplicate entry');
duplicateError.name = 'SequelizeUniqueConstraintError';
duplicateError.parent = { code: 'ER_DUP_ENTRY', errno: 1062 };
throw duplicateError;
}
const taskCode = String(payload && payload.task_code ? payload.task_code : '').trim();
if (taskCode && state.printTaskMapByTaskCode[taskCode]) {
const duplicateError = new Error('Duplicate entry');
duplicateError.name = 'SequelizeUniqueConstraintError';
duplicateError.parent = { code: 'ER_DUP_ENTRY', errno: 1062 };
throw duplicateError;
}
state.printTaskMapByTaskCode[taskCode] = {
task_code: taskCode,
print_record_id: null,
provider: null,
};
return {
id: calls.printTaskMapCreatePayloads.length,
};
},
async findOne(query) {
calls.printTaskMapFindOnePayloads.push(query || {});
const where = query && query.where ? query.where : {};
const taskCode = String(where.task_code || '').trim();
if (!taskCode || !state.printTaskMapByTaskCode[taskCode]) {
return null;
}
return {
...state.printTaskMapByTaskCode[taskCode],
};
},
async update(payload, query) {
calls.printTaskMapUpdatePayloads.push({ payload, query });
const taskCode = String(query && query.where && query.where.task_code ? query.where.task_code : '').trim();
if (!taskCode) {
return [ 0 ];
}
const current = state.printTaskMapByTaskCode[taskCode] || {
task_code: taskCode,
print_record_id: null,
provider: null,
};
state.printTaskMapByTaskCode[taskCode] = {
...current,
...payload,
};
return [ 1 ];
},
},
PrintStations: {
async findOne() {
@ -130,6 +287,19 @@ function createContext(options = {}) {
}));
},
},
OrderDeliveryFactory: {
async getCurrentModel() {
return {
async update(payload, query) {
calls.orderDeliveryLockUpdates.push({ payload, query });
const whereIds = Array.isArray(query && query.where && query.where.id)
? query.where.id
: [];
return [ whereIds.length ];
},
};
},
},
},
service: {
systems: {
@ -142,7 +312,7 @@ function createContext(options = {}) {
},
};
return { ctx, calls };
return { ctx, calls, state };
}
/**
@ -294,16 +464,34 @@ describe('test/app/service/systemMethods/print.send.test.js', () => {
assert.equal(result.flag, 'success');
assert.equal(result.code, 200);
assert.equal(calls.printRecordCreatePayloads.length, 1);
assert.equal(result.printId, 9001);
assert.deepEqual(result.printIds, [ 9001, 9002, 9003 ]);
assert.equal(calls.printRecordCreatePayloads.length, 3);
assert.equal(calls.printRecordCreatePayloads[0].computer_id, 'PC-STATION-001');
assert.equal(calls.printRecordCreatePayloads[0].printer, 'PRN-DEFAULT');
assert.equal(calls.printRecordCreatePayloads[0].printer, 'PRN-STO');
assert.equal(calls.printRecordCreatePayloads[0].send_status, 'pending');
assert.equal(calls.printRecordCreatePayloads[0].print_status, 'unknown');
assert.equal(calls.sendToComputerPayloads.length, 3);
assert.equal(calls.printRecordCreatePayloads.length, calls.sendToComputerPayloads.length);
for (let index = 0; index < calls.printRecordCreatePayloads.length; index++) {
const recordPayload = calls.printRecordCreatePayloads[index] || {};
const sendPayload = calls.sendToComputerPayloads[index] || {};
const sendData = sendPayload && sendPayload.data && typeof sendPayload.data === 'object'
? sendPayload.data
: {};
assert.equal(recordPayload.printer, sendData.printer);
const sendDataWithoutPrintId = { ...sendData };
delete sendDataWithoutPrintId.printId;
assert.deepEqual(recordPayload.data, sendDataWithoutPrintId);
}
assert.deepEqual(calls.sendOrderMarks, [ 'W1-P1', 'W1-P2', 'W2-P1' ]);
assert.equal(calls.printRecordUpdatePayloads.length, 1);
assert.equal(calls.printRecordUpdatePayloads[0].status, 'sent');
assert.equal(calls.printRecordUpdatePayloads.length, 0);
assert.equal(calls.printRecordStaticUpdatePayloads[0].payload.send_status, 'sent');
assert.equal(calls.printRecordStaticUpdatePayloads[0].payload.print_status, 'unknown');
assert.ok(calls.printRecordStaticUpdatePayloads[0].payload.sent_time instanceof Date);
});
it('type=express 默认打印机为空时创建记录应写入稳定占位值', async () => {
it('type=express 默认打印机为空时创建记录应写入实际发送打印机', async () => {
const { ctx, calls } = createContext({
printStation: {
id: 101,
@ -337,9 +525,18 @@ describe('test/app/service/systemMethods/print.send.test.js', () => {
});
assert.equal(result.flag, 'success');
assert.equal(calls.printRecordCreatePayloads.length, 1);
assert.equal(calls.printRecordCreatePayloads.length, 3);
assert.equal(calls.printRecordCreatePayloads[0].computer_id, 'PC-STATION-001');
assert.equal(calls.printRecordCreatePayloads[0].printer, 'EXPRESS_DYNAMIC_PRINTER');
const printers = calls.printRecordCreatePayloads.map(item => item.printer);
assert.deepEqual(printers, [ 'PRN-STO', 'PRN-YTO', 'PRN-STO' ]);
for (let index = 0; index < calls.printRecordCreatePayloads.length; index++) {
const recordPayload = calls.printRecordCreatePayloads[index] || {};
const sendPayload = calls.sendToComputerPayloads[index] || {};
const sendData = sendPayload && sendPayload.data && typeof sendPayload.data === 'object'
? sendPayload.data
: {};
assert.equal(recordPayload.printer, sendData.printer);
}
});
it('type=express 应按快递匹配打印机并在未命中时回退默认打印机', async () => {
@ -357,6 +554,7 @@ describe('test/app/service/systemMethods/print.send.test.js', () => {
assert.equal(result.flag, 'success');
assert.equal(calls.sendToComputerPayloads.length, 3);
assert.equal(calls.printRecordCreatePayloads.length, 3);
const printerNames = calls.sendToComputerPayloads.map(item => item.data.printer);
assert.deepEqual(printerNames, [ 'PRN-STO', 'PRN-DEFAULT', 'PRN-STO' ]);
});
@ -377,6 +575,7 @@ describe('test/app/service/systemMethods/print.send.test.js', () => {
assert.equal(result.flag, 'success');
const components = calls.sendToComputerPayloads.map(item => item.data.component);
assert.deepEqual(components, [ '菜鸟', '拼多多', '抖音' ]);
assert.equal(calls.printRecordCreatePayloads.length, calls.sendToComputerPayloads.length);
});
it('type=express 任意组件离线时应整批失败且不发送任务', async () => {
@ -451,6 +650,7 @@ describe('test/app/service/systemMethods/print.send.test.js', () => {
assert.equal(result.flag, 'success');
assert.equal(calls.sendToComputerPayloads.length, 1);
assert.equal(calls.printRecordCreatePayloads.length, 1);
assert.deepEqual(calls.sendOrderMarks, [ 'ONLY-CAINIAO' ]);
assert.equal(calls.platformFindAllWheres.length, 1);
assert.deepEqual(calls.platformFindAllWheres[0].code, [ 'cainiao' ]);
@ -505,6 +705,7 @@ describe('test/app/service/systemMethods/print.send.test.js', () => {
assert.equal(result.flag, 'success');
assert.equal(calls.sendToComputerPayloads.length, 3);
assert.equal(calls.printRecordCreatePayloads.length, 3);
const requestPayloads = calls.sendToComputerPayloads.map(item => item.data.data);
const firstDocumentNumbers = requestPayloads.map(item => item.task.firstDocumentNumber);
@ -550,6 +751,232 @@ describe('test/app/service/systemMethods/print.send.test.js', () => {
assert.equal(documentIdSet.size, 4);
});
it('type=express 正常生成 task_id 并写入映射表', async () => {
const { ctx, calls } = createContext();
const service = new PrintService(ctx);
const result = await service.send({
type: 'express',
printStationId: 101,
requestCode: 'REQ-TASK-CODE-001',
data: {
waveGroups: createExpressWaveGroups(),
},
});
assert.equal(result.flag, 'success');
assert.equal(calls.printRecordCreatePayloads.length, 3);
assert.equal(calls.sendToComputerPayloads.length, 3);
assert.equal(calls.printTaskMapCreatePayloads.length, 3);
assert.equal(calls.printTaskMapUpdatePayloads.length, 3);
for (const item of calls.printTaskMapCreatePayloads) {
assert.match(String(item.task_code || ''), /^PRT\d{14}[0-9a-f]{4}[0-9a-f]{8}$/i);
}
assert.equal(calls.printRecordStaticUpdatePayloads.length, 3);
for (const updateItem of calls.printRecordStaticUpdatePayloads) {
assert.equal(typeof updateItem.payload.print_task_code, 'string');
assert.ok(updateItem.payload.print_task_code.length > 0);
assert.equal(updateItem.payload.print_task_code.includes(','), false);
assert.equal(updateItem.payload.status, 'sent');
}
});
it('type=express 生成冲突时应重试并最终成功', async () => {
const { ctx, calls } = createContext({
duplicateTaskCodeTimes: 1,
});
const service = new PrintService(ctx);
const result = await service.send({
type: 'express',
printStationId: 101,
requestCode: 'REQ-TASK-CODE-RETRY-001',
data: {
waveGroups: [ createExpressWaveGroups()[0] ],
},
});
assert.equal(result.flag, 'success');
assert.ok(calls.printTaskMapCreatePayloads.length >= 3);
assert.equal(calls.printTaskMapUpdatePayloads.length, 2);
});
it('type=express 发送成功后应锁定订单 print_lock_status=warehouse', async () => {
const { ctx, calls } = createContext();
const service = new PrintService(ctx);
const result = await service.send({
type: 'express',
requestCode: 'REQ-LOCK-ORDER',
printStationId: 101,
data: {
waveGroups: [
{
wave_id: 1,
wave_no: 'WAVE-1',
platforms: [
{
platform: 'cainiao',
sys_logistics_code: 'STO',
order_ids: [ 101, 102, 101 ],
orders: [
{
order_id: 101,
print_data: {
documentID: 'DOC-LOCK-1',
contents: [
{
marker: 'LOCK-1',
},
],
},
},
],
},
],
},
],
},
});
assert.equal(result.flag, 'success');
assert.equal(calls.orderDeliveryLockUpdates.length, 1);
assert.equal(calls.orderDeliveryLockUpdates[0].payload.print_lock_status, 'warehouse');
assert.deepEqual(calls.orderDeliveryLockUpdates[0].query.where.id, [ 101, 102 ]);
assert.equal(calls.orderDeliveryLockUpdates[0].query.where.print_lock_status, 'none');
});
it('type=express provider 成功后应回写 print_record 与 print_task_map,且回写可重入', async () => {
const { ctx, calls, state } = createContext();
const service = new PrintService(ctx);
const taskCode = 'PRT2026051923595900aa11bb22cc';
state.printTaskMapByTaskCode[taskCode] = {
task_code: taskCode,
print_record_id: null,
provider: null,
};
await service.bindTaskCodeToPrintRecord({
printRecordId: 9001,
taskCode,
provider: 'provider-task-1',
});
await service.bindTaskCodeToPrintRecord({
printRecordId: 9001,
taskCode,
provider: 'provider-task-1',
});
assert.equal(state.printTaskMapByTaskCode[taskCode].print_record_id, 9001);
assert.equal(state.printTaskMapByTaskCode[taskCode].provider, 'provider-task-1');
assert.equal(state.printRecordsById[9001].print_task_code, taskCode);
assert.equal(state.printRecordsById[9001].status, 'sent');
assert.equal(state.printRecordsById[9001].send_status, 'sent');
assert.equal(state.printRecordsById[9001].print_status, 'unknown');
assert.equal(calls.printRecordStaticUpdatePayloads.length, 1);
assert.equal(calls.printRecordStaticUpdatePayloads[0].payload.print_task_code, taskCode);
});
it('type=express 发送失败后应写入 send_failed 与 unknown', async () => {
const { ctx, calls } = createContext({
sendToComputer: async payload => {
calls.sendToComputerPayloads.push(payload);
return {
status: 'failure',
error: '打印服务不可用',
};
},
});
const service = new PrintService(ctx);
const result = await service.send({
type: 'express',
printStationId: 101,
requestCode: 'REQ-EXPRESS-SEND-FAILED-001',
data: {
waveGroups: [ createExpressWaveGroups()[0] ],
},
});
assert.equal(result.flag, 'failure');
assert.equal(result.code, 504);
assert.equal(calls.printRecordCreatePayloads.length, 1);
assert.equal(calls.printRecordUpdatePayloads.length, 1);
assert.equal(calls.printRecordUpdatePayloads[0].payload.status, 'failed');
assert.equal(calls.printRecordUpdatePayloads[0].payload.send_status, 'send_failed');
assert.equal(calls.printRecordUpdatePayloads[0].payload.print_status, 'unknown');
assert.equal(calls.printRecordUpdatePayloads[0].payload.fail_code, 'SEND_FAILED');
});
it('type=customize 发送成功后应写入 sent 与 unknown', async () => {
const { ctx, calls } = createContext();
const service = new PrintService(ctx);
const result = await service.send({
computerId: 'PC-03',
printer: 'Printer-A',
type: 'customize',
template: {
page_width: 100,
page_height: 60,
template_content: [],
},
data: {
order_no: 'SO10001',
},
timestamp: '1710000000',
count: 1,
});
assert.equal(result.flag, 'success');
assert.equal(calls.printRecordCreatePayloads.length, 1);
assert.equal(calls.printRecordCreatePayloads[0].send_status, 'pending');
assert.equal(calls.printRecordCreatePayloads[0].print_status, 'unknown');
assert.equal(calls.printRecordUpdatePayloads.length, 1);
assert.equal(calls.printRecordUpdatePayloads[0].payload.status, 'sent');
assert.equal(calls.printRecordUpdatePayloads[0].payload.send_status, 'sent');
assert.equal(calls.printRecordUpdatePayloads[0].payload.print_status, 'unknown');
assert.ok(calls.printRecordUpdatePayloads[0].payload.sent_time instanceof Date);
});
it('type=customize 发送失败后应写入 send_failed 与 unknown', async () => {
const { ctx, calls } = createContext({
sendToComputer: async payload => {
calls.sendToComputerPayloads.push(payload);
return {
status: 'failure',
error: '打印组件未连接',
};
},
});
const service = new PrintService(ctx);
const result = await service.send({
computerId: 'PC-04',
printer: 'Printer-B',
type: 'customize',
template: {
page_width: 80,
page_height: 50,
template_content: [],
},
data: {
order_no: 'SO10004',
},
timestamp: '1710000003',
count: 1,
});
assert.equal(result.flag, 'failure');
assert.equal(calls.printRecordCreatePayloads.length, 1);
assert.equal(calls.printRecordUpdatePayloads.length, 1);
assert.equal(calls.printRecordUpdatePayloads[0].payload.status, 'failed');
assert.equal(calls.printRecordUpdatePayloads[0].payload.send_status, 'send_failed');
assert.equal(calls.printRecordUpdatePayloads[0].payload.print_status, 'unknown');
assert.equal(calls.printRecordUpdatePayloads[0].payload.fail_code, 'SEND_FAILED');
});
it('type=customize 不传 printer 时应返回失败且提示 printer', async () => {
const { ctx, calls } = createContext();
const service = new PrintService(ctx);
@ -595,4 +1022,365 @@ describe('test/app/service/systemMethods/print.send.test.js', () => {
assert.match(result.message, /template/);
assert.equal(calls.sendToComputerPayloads.length, 0);
});
it('retryFailed 应补打 failed 记录并创建新记录', async () => {
const sourceRecordId = 12001;
const { ctx, calls, state } = createContext({
initialPrintRecords: [
{
id: sourceRecordId,
warehouse_id: 100000,
computer_id: 'PC-STATION-001',
printer: 'PRN-STO',
type: 'express',
status: 'failed',
send_status: 'send_failed',
print_status: 'unknown',
data: {
printer: 'PRN-STO',
component: '菜鸟',
type: 'express',
data: {
task: {
taskID: 'OLD_TASK_ID',
documents: [],
},
},
},
request_code: 'REQ-RETRY-001',
wave_id: 11,
wave_no: 'WAVE-11',
platform_code: 'cainiao',
platform_name: '菜鸟平台',
sys_logistics_code: 'STO',
sys_logistics_name: '申通',
},
],
sendToComputer: async payload => {
calls.sendToComputerPayloads.push(payload);
return { status: 'success' };
},
});
const service = new PrintService(ctx);
const result = await service.retryFailed({
print_ids: [ sourceRecordId ],
});
assert.equal(result.flag, 'success');
assert.equal(result.success_count, 1);
assert.equal(result.failed_count, 0);
assert.equal(result.skipped_count, 0);
assert.equal(result.retried.length, 1);
assert.equal(result.retried[0].source_print_id, sourceRecordId);
assert.equal(result.retried[0].status, 'sent');
assert.equal(calls.printRecordCreatePayloads.length, 1);
assert.equal(calls.sendToComputerPayloads.length, 1);
assert.equal(calls.printRecordCreatePayloads[0].retry_of_print_id, sourceRecordId);
const newRecordId = result.retried[0].new_print_id;
const newRecord = state.printRecordsById[newRecordId];
assert.ok(newRecord);
assert.equal(newRecord.retry_of_print_id, sourceRecordId);
assert.equal(newRecord.status, 'sent');
assert.equal(newRecord.send_status, 'sent');
assert.equal(newRecord.print_status, 'unknown');
assert.notEqual(newRecord.data.data.task.taskID, 'OLD_TASK_ID');
assert.equal(newRecord.data.data.task.taskID, result.retried[0].task_code);
assert.equal(state.printRecordsById[sourceRecordId].status, 'failed');
});
it('retryFailed 应跳过 sent/printed 记录', async () => {
const sourceRecordId = 12002;
const { ctx, calls } = createContext({
initialPrintRecords: [
{
id: sourceRecordId,
warehouse_id: 100000,
computer_id: 'PC-STATION-001',
printer: 'PRN-STO',
type: 'express',
status: 'sent',
send_status: 'sent',
print_status: 'printed',
data: {
printer: 'PRN-STO',
component: '菜鸟',
type: 'express',
data: {
task: {
taskID: 'TASK-SENT-001',
documents: [],
},
},
},
},
],
});
const service = new PrintService(ctx);
const result = await service.retryFailed({
print_ids: [ sourceRecordId ],
});
assert.equal(result.flag, 'success');
assert.equal(result.success_count, 0);
assert.equal(result.failed_count, 0);
assert.equal(result.skipped_count, 1);
assert.equal(result.skipped[0].print_id, sourceRecordId);
assert.match(result.skipped[0].reason, /跳过|不允许补打/);
assert.equal(calls.printRecordCreatePayloads.length, 0);
assert.equal(calls.sendToComputerPayloads.length, 0);
});
it('retryFailed 部分成功时应返回正确统计', async () => {
const sourceSuccessId = 12003;
const sourceFailId = 12004;
const sourceSkipId = 12005;
const { ctx, calls, state } = createContext({
initialPrintRecords: [
{
id: sourceSuccessId,
warehouse_id: 100000,
computer_id: 'PC-STATION-001',
printer: 'PRN-STO',
type: 'express',
status: 'failed',
send_status: 'send_failed',
print_status: 'unknown',
data: {
printer: 'PRN-STO',
component: '菜鸟',
type: 'express',
data: { task: { taskID: 'TASK-OLD-SUCCESS', documents: [] } },
},
},
{
id: sourceFailId,
warehouse_id: 100000,
computer_id: 'PC-STATION-001',
printer: 'PRN-YTO',
type: 'express',
status: 'failed',
send_status: 'send_failed',
print_status: 'unknown',
data: {
printer: 'PRN-YTO',
component: '拼多多',
type: 'express',
data: { task: { taskID: 'TASK-OLD-FAIL', documents: [] } },
},
},
{
id: sourceSkipId,
warehouse_id: 100000,
computer_id: 'PC-STATION-001',
printer: 'PRN-STO',
type: 'express',
status: 'sent',
send_status: 'sent',
print_status: 'unknown',
data: {
printer: 'PRN-STO',
component: '菜鸟',
type: 'express',
data: { task: { taskID: 'TASK-SKIP', documents: [] } },
},
},
],
sendToComputer: async payload => {
calls.sendToComputerPayloads.push(payload);
if (calls.sendToComputerPayloads.length === 2) {
return {
status: 'failure',
error: '发送失败-模拟',
};
}
return { status: 'success' };
},
});
const service = new PrintService(ctx);
const result = await service.retryFailed({
print_ids: [ sourceSuccessId, sourceFailId, sourceSkipId ],
});
assert.equal(result.flag, 'success');
assert.equal(result.success_count, 1);
assert.equal(result.failed_count, 1);
assert.equal(result.skipped_count, 1);
assert.equal(result.retried.length, 2);
assert.equal(calls.printRecordCreatePayloads.length, 2);
assert.equal(calls.sendToComputerPayloads.length, 2);
assert.equal(state.printRecordsById[sourceSuccessId].status, 'failed');
assert.equal(state.printRecordsById[sourceFailId].status, 'failed');
assert.equal(state.printRecordsById[sourceSkipId].status, 'sent');
const failedRetryItem = result.retried.find(item => item.source_print_id === sourceFailId);
assert.ok(failedRetryItem);
assert.equal(failedRetryItem.status, 'failed');
});
it('handlePrintCallback success 回调应更新为 printed', async () => {
const { ctx, state, calls } = createContext();
const service = new PrintService(ctx);
state.printTaskMapByTaskCode.PRT_CALLBACK_001 = {
task_code: 'PRT_CALLBACK_001',
print_record_id: 9001,
provider: null,
};
state.printRecordsById[9001] = {
id: 9001,
warehouse_id: 100000,
status: 'sent',
send_status: 'sent',
print_status: 'unknown',
print_time: null,
error_message: 'old-error',
fail_code: 'OLD_FAIL',
data: {
order_ids: [ 201, 202, 201 ],
},
};
const result = await service.handlePrintCallback({
print_task_code: 'PRT_CALLBACK_001',
result: 'success',
callback_time: '2026-05-19 12:00:00',
});
assert.equal(result.flag, 'success');
assert.equal(result.result, 'updated');
assert.equal(state.printRecordsById[9001].status, 'sent');
assert.equal(state.printRecordsById[9001].print_status, 'printed');
assert.equal(state.printRecordsById[9001].error_message, null);
assert.equal(state.printRecordsById[9001].fail_code, null);
assert.ok(state.printRecordsById[9001].print_time instanceof Date);
assert.equal(calls.orderDeliveryLockUpdates.length, 1);
assert.equal(calls.orderDeliveryLockUpdates[0].payload.print_status, 'fin');
assert.deepEqual(calls.orderDeliveryLockUpdates[0].query.where.id, [ 201, 202 ]);
assert.equal(calls.orderDeliveryLockUpdates[0].query.where.print_status, undefined);
});
it('handlePrintCallback failed 回调应更新为 print_failed 并写入 fail_code', async () => {
const { ctx, state, calls } = createContext();
const service = new PrintService(ctx);
state.printTaskMapByTaskCode.PRT_CALLBACK_002 = {
task_code: 'PRT_CALLBACK_002',
print_record_id: 9001,
provider: null,
};
state.printRecordsById[9001] = {
id: 9001,
warehouse_id: 100000,
status: 'sent',
send_status: 'sent',
print_status: 'unknown',
data: JSON.stringify({
order_ids: [ 301, 302, 301 ],
}),
};
const result = await service.handlePrintCallback({
print_task_code: 'PRT_CALLBACK_002',
result: 'failed',
error_message: '打印机离线',
});
assert.equal(result.flag, 'success');
assert.equal(result.result, 'updated');
assert.equal(state.printRecordsById[9001].print_status, 'print_failed');
assert.equal(state.printRecordsById[9001].error_message, '打印机离线');
assert.equal(state.printRecordsById[9001].fail_code, 'PRINT_CALLBACK_FAILED');
assert.ok(state.printRecordsById[9001].print_time instanceof Date);
assert.equal(calls.orderDeliveryLockUpdates.length, 1);
assert.equal(calls.orderDeliveryLockUpdates[0].payload.print_status, 'error');
assert.deepEqual(calls.orderDeliveryLockUpdates[0].query.where.id, [ 301, 302 ]);
assert.equal(calls.orderDeliveryLockUpdates[0].query.where.print_status, 'none');
});
it('handlePrintCallback 重复 success 回调应幂等', async () => {
const { ctx, state } = createContext();
const service = new PrintService(ctx);
state.printTaskMapByTaskCode.PRT_CALLBACK_003 = {
task_code: 'PRT_CALLBACK_003',
print_record_id: 9001,
provider: null,
};
state.printRecordsById[9001] = {
id: 9001,
status: 'sent',
send_status: 'sent',
print_status: 'unknown',
};
const firstResult = await service.handlePrintCallback({
print_task_code: 'PRT_CALLBACK_003',
result: 'success',
});
const firstPrintTime = state.printRecordsById[9001].print_time;
const secondResult = await service.handlePrintCallback({
print_task_code: 'PRT_CALLBACK_003',
result: 'success',
callback_time: '2026-06-01 00:00:00',
});
assert.equal(firstResult.flag, 'success');
assert.equal(secondResult.flag, 'success');
assert.equal(secondResult.result, 'idempotent');
assert.equal(state.printRecordsById[9001].print_status, 'printed');
assert.equal(state.printRecordsById[9001].print_time, firstPrintTime);
});
it('handlePrintCallback 已 printed 后收到 failed 应忽略', async () => {
const { ctx, state } = createContext();
const service = new PrintService(ctx);
state.printTaskMapByTaskCode.PRT_CALLBACK_004 = {
task_code: 'PRT_CALLBACK_004',
print_record_id: 9001,
provider: null,
};
const existedPrintTime = new Date('2026-05-19T12:30:00.000Z');
state.printRecordsById[9001] = {
id: 9001,
status: 'sent',
send_status: 'sent',
print_status: 'printed',
print_time: existedPrintTime,
error_message: null,
fail_code: null,
};
const result = await service.handlePrintCallback({
print_task_code: 'PRT_CALLBACK_004',
result: 'failed',
error_message: '晚到失败回执',
fail_code: 'LATE_FAILED',
});
assert.equal(result.flag, 'success');
assert.equal(result.result, 'ignored');
assert.equal(state.printRecordsById[9001].print_status, 'printed');
assert.equal(state.printRecordsById[9001].print_time, existedPrintTime);
assert.equal(state.printRecordsById[9001].error_message, null);
assert.equal(state.printRecordsById[9001].fail_code, null);
});
it('handlePrintCallback task_code 不存在时应返回失败结果', async () => {
const { ctx } = createContext();
const service = new PrintService(ctx);
const result = await service.handlePrintCallback({
print_task_code: 'PRT_NOT_FOUND_001',
result: 'success',
});
assert.equal(result.flag, 'failure');
assert.equal(result.code, 404);
assert.equal(result.result, 'not_found');
});
});