- 订单表新增 intercept_time 拦截时间字段(迁移覆盖基表与全部分表),全拦截链路写入拦截时间、解除拦截清空 - 新增自动库内拦截确定定时任务(1h 间隔,扫描 requested+未打印订单,超时自动库内拦截确定) - 复核链路自动移除波次内未打印拦截订单回池,拦截解除后可重新抓取发货 - 打印解绑车判定排除拦截订单,修复波次含拦截订单时车无法解锁 - 同步 methods 文档与变更记录;含 wave_scope 回填、workbench token 过期等前序迁移
968 lines
32 KiB
JavaScript
968 lines
32 KiB
JavaScript
'use strict';
|
||
|
||
const assert = require('node:assert/strict');
|
||
const StorageReportService = require('../../../../app/service/systems/storage/report');
|
||
const StockReportMethodService = require('../../../../app/service/systemMethods/stock/report');
|
||
|
||
/**
|
||
* 构建 storage.report service 测试桩。
|
||
* @param {Object} options 自定义参数
|
||
* @return {{service: StorageReportService, calls: Object}} service 与调用记录
|
||
*/
|
||
function createReportServiceHarness(options = {}) {
|
||
const calls = {
|
||
queries: [],
|
||
exports: [],
|
||
};
|
||
let queryIndex = 0;
|
||
const queryResults = Array.isArray(options.queryResults) ? options.queryResults : [];
|
||
|
||
const model = {
|
||
async query(sql, queryOptions = {}) {
|
||
calls.queries.push({
|
||
sql,
|
||
options: queryOptions,
|
||
});
|
||
const result = queryResults[queryIndex] || [];
|
||
queryIndex += 1;
|
||
return result;
|
||
},
|
||
StockWarehouse: {
|
||
async findAll() {
|
||
return options.stockRows || [];
|
||
},
|
||
},
|
||
StockBarcode: {
|
||
async findAll() {
|
||
return options.barcodeRows || [];
|
||
},
|
||
},
|
||
Store: {
|
||
async findAll() {
|
||
return options.storeRows || [];
|
||
},
|
||
},
|
||
StoreWarehouse: {
|
||
async findAll() {
|
||
return options.storeWarehouseRows || [];
|
||
},
|
||
},
|
||
LocationSpace: {
|
||
async findAll() {
|
||
return options.spaceRows || [];
|
||
},
|
||
},
|
||
};
|
||
|
||
const ctx = {
|
||
user: {
|
||
store_id: options.warehouseId || 100000,
|
||
},
|
||
model,
|
||
app: {
|
||
Sequelize: {
|
||
QueryTypes: {
|
||
SELECT: 'SELECT',
|
||
},
|
||
Op: {
|
||
in: 'IN',
|
||
},
|
||
},
|
||
},
|
||
logger: {
|
||
info() {},
|
||
warn() {},
|
||
error() {},
|
||
},
|
||
service: {
|
||
systems: {
|
||
stockWarehouse: {
|
||
async getStockDetails() {
|
||
const barcodeMap = new Map();
|
||
for (const bc of options.barcodeRows || []) {
|
||
if (!barcodeMap.has(bc.stock_id)) {
|
||
barcodeMap.set(bc.stock_id, []);
|
||
}
|
||
barcodeMap.get(bc.stock_id).push({ barcode: bc.barcode });
|
||
}
|
||
return (options.stockRows || []).map(row => ({
|
||
...row,
|
||
barcodes: barcodeMap.get(row.id) || [],
|
||
}));
|
||
},
|
||
},
|
||
excel: {
|
||
async generateAndUpload(exportOptions) {
|
||
calls.exports.push(exportOptions);
|
||
return {
|
||
filename: exportOptions.filename,
|
||
fileKey: `exports/mock/${exportOptions.filename}`,
|
||
url: `https://cdn.example.com/${exportOptions.filename}`,
|
||
};
|
||
},
|
||
},
|
||
},
|
||
},
|
||
};
|
||
|
||
return {
|
||
service: new StorageReportService(ctx),
|
||
calls,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 构建 storage.report method 测试桩。
|
||
* @param {Object} options 自定义参数
|
||
* @return {{methodService: StockReportMethodService, captured: Object, cacheStore: Map<string, Object>}} method 与调用记录
|
||
*/
|
||
function createReportMethodHarness(options = {}) {
|
||
const captured = {
|
||
exportCalls: [],
|
||
};
|
||
const cacheStore = new Map();
|
||
|
||
const ctx = {
|
||
app: {
|
||
Sequelize: {
|
||
Op: {},
|
||
},
|
||
async setCacheAsync(cacheKey, value) {
|
||
cacheStore.set(cacheKey, value);
|
||
},
|
||
async getCacheAsync(cacheKey) {
|
||
return cacheStore.get(cacheKey);
|
||
},
|
||
},
|
||
service: {
|
||
systems: {
|
||
storage: {
|
||
report: {
|
||
async export(startTime, endTime, bySpace, storeIds, sort) {
|
||
captured.exportCalls.push({
|
||
startTime,
|
||
endTime,
|
||
bySpace,
|
||
storeIds,
|
||
sort,
|
||
});
|
||
return options.exportResult || {
|
||
filename: '库存报表_20260501_20260502.xlsx',
|
||
fileKey: 'exports/mock/库存报表_20260501_20260502.xlsx',
|
||
url: 'https://cdn.example.com/库存报表_20260501_20260502.xlsx',
|
||
};
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
logger: {
|
||
info() {},
|
||
warn() {},
|
||
error() {},
|
||
},
|
||
user: {
|
||
store_id: options.warehouseId || 100000,
|
||
},
|
||
};
|
||
|
||
const methodService = new StockReportMethodService(ctx);
|
||
methodService.prepareWhereContext = function prepareWhereContext() {
|
||
return {
|
||
whereValue: {
|
||
start_time: '2026-05-01 00:00:00',
|
||
end_time: '2026-05-02 23:59:59',
|
||
by_space: false,
|
||
store_ids: [ 33, 44 ],
|
||
sort_field: 'inbound_total',
|
||
sort_order: 'ASC',
|
||
},
|
||
};
|
||
};
|
||
|
||
return {
|
||
methodService,
|
||
captured,
|
||
cacheStore,
|
||
};
|
||
}
|
||
|
||
describe('test/app/service/systems/storage.report.test.js', () => {
|
||
it('should use last pre-start after and last in-range after by stock+store when by_space is false', async () => {
|
||
const { service, calls } = createReportServiceHarness({
|
||
queryResults: [
|
||
[
|
||
{ stock_id: 101, store_id: 201, quantity: 99 },
|
||
{ stock_id: 102, store_id: 202, quantity: 88 },
|
||
],
|
||
[
|
||
{ stock_id: 101, space_id: 11, store_id: 201, inbound_total: 5, outbound_total: 2 },
|
||
{ stock_id: 101, space_id: 12, store_id: 201, inbound_total: 3, outbound_total: 1 },
|
||
{ stock_id: 102, space_id: 13, store_id: 202, inbound_total: 4, outbound_total: 0 },
|
||
],
|
||
[
|
||
{ id: 1, stock_id: 101, space_id: 11, storage_id: 9001, store_id: 201, before_quantity: 50, after_quantity: 55, created_at: '2026-05-01 09:00:00' },
|
||
{ id: 2, stock_id: 101, space_id: 12, storage_id: 9009, store_id: 201, before_quantity: 55, after_quantity: 60, created_at: '2026-05-01 10:00:00' },
|
||
{ id: 3, stock_id: 101, space_id: 11, storage_id: 9010, store_id: 201, before_quantity: 60, after_quantity: 66, created_at: '2026-05-02 12:00:00' },
|
||
{ id: 4, stock_id: 102, space_id: 13, storage_id: 9003, store_id: 202, before_quantity: 3, after_quantity: 4, created_at: '2026-05-02 14:00:00' },
|
||
],
|
||
[
|
||
{ id: 10, stock_id: 101, space_id: 11, store_id: 201, after_quantity: 47, created_at: '2026-04-30 09:00:00' },
|
||
{ id: 11, stock_id: 101, space_id: 12, store_id: 201, after_quantity: 48, created_at: '2026-04-30 23:00:00' },
|
||
{ id: 12, stock_id: 102, space_id: 13, store_id: 202, after_quantity: 2, created_at: '2026-04-30 20:00:00' },
|
||
],
|
||
],
|
||
stockRows: [
|
||
{ id: 101, item_name: '商品A', item_code: 'SKU-A' },
|
||
{ id: 102, item_name: '商品B', item_code: 'SKU-B' },
|
||
],
|
||
barcodeRows: [
|
||
{ stock_id: 101, barcode: 'BC-A-1' },
|
||
{ stock_id: 101, barcode: 'BC-A-2' },
|
||
{ stock_id: 102, barcode: 'BC-B-1' },
|
||
],
|
||
storeRows: [
|
||
{ id: 201, company_name: '货主甲' },
|
||
{ id: 202, company_name: '货主乙' },
|
||
],
|
||
});
|
||
|
||
const result = await service.search('2026-05-01 00:00:00', '2026-05-02 23:59:59', false, [ 201, 202 ]);
|
||
|
||
assert.equal(result.code, 200);
|
||
assert.equal(result.data.list.length, 2);
|
||
|
||
const stockA = result.data.list.find(item => item.stock_id === 101 && item.store_id === 201);
|
||
assert.ok(stockA);
|
||
assert.equal(stockA.begin_total, 48);
|
||
assert.equal(stockA.end_total, 66);
|
||
assert.equal(stockA.inbound_total, 8);
|
||
assert.equal(stockA.outbound_total, 3);
|
||
assert.notEqual(stockA.begin_total, 50);
|
||
assert.equal(stockA.space_id, undefined);
|
||
assert.match(stockA.barcode, /BC-A-1/);
|
||
assert.match(stockA.barcode, /BC-A-2/);
|
||
|
||
const stockB = result.data.list.find(item => item.stock_id === 102 && item.store_id === 202);
|
||
assert.ok(stockB);
|
||
assert.equal(stockB.begin_total, 2);
|
||
assert.equal(stockB.end_total, 4);
|
||
assert.equal(stockB.inbound_total, 4);
|
||
assert.equal(stockB.outbound_total, 0);
|
||
assert.match(calls.queries[1].sql, /FROM wms_stock_transaction t/);
|
||
assert.match(calls.queries[2].sql, /FROM wms_stock_transaction t/);
|
||
assert.match(calls.queries[2].sql, /before_quantity/);
|
||
assert.doesNotMatch(calls.queries[2].sql, /storage_id/);
|
||
// 回归断言:intervalEdge 两条标量子查询必须带 stock/store 维度关联,防止同秒跨 SKU 串行
|
||
assert.match(calls.queries[2].sql, /t2\.stock_id = g\.stock_id AND t2\.store_id = g\.store_id/);
|
||
assert.match(calls.queries[2].sql, /t3\.stock_id = g\.stock_id AND t3\.store_id = g\.store_id/);
|
||
assert.match(calls.queries[3].sql, /FROM wms_stock_transaction t/);
|
||
assert.match(calls.queries[3].sql, /created_at < :startTime/);
|
||
assert.match(calls.queries[3].sql, /after_quantity/);
|
||
// 回归断言:preStart 标量子查询同样必须带 stock/store 维度关联
|
||
assert.match(calls.queries[3].sql, /t3\.stock_id = g\.stock_id AND t3\.store_id = g\.store_id/);
|
||
});
|
||
|
||
it('should keep space dimension with pre-start-last-after for begin and in-range-last-after for end', async () => {
|
||
const { service, calls } = createReportServiceHarness({
|
||
queryResults: [
|
||
[
|
||
{ stock_id: 301, space_id: 501, store_id: 401, quantity: 7 },
|
||
{ stock_id: 301, space_id: 502, store_id: 401, quantity: 11 },
|
||
],
|
||
[
|
||
{ stock_id: 301, space_id: 501, store_id: 401, inbound_total: 2, outbound_total: 1 },
|
||
{ stock_id: 301, space_id: 502, store_id: 401, inbound_total: 3, outbound_total: 0 },
|
||
],
|
||
[
|
||
{ id: 1, stock_id: 301, space_id: 501, storage_id: 8801, store_id: 401, before_quantity: 7, after_quantity: 8, created_at: '2026-05-01 09:00:00' },
|
||
{ id: 2, stock_id: 301, space_id: 501, storage_id: 8802, store_id: 401, before_quantity: 8, after_quantity: 10, created_at: '2026-05-01 12:00:00' },
|
||
{ id: 3, stock_id: 301, space_id: 502, storage_id: 8803, store_id: 401, before_quantity: 11, after_quantity: 12, created_at: '2026-05-01 10:00:00' },
|
||
],
|
||
[
|
||
{ id: 10, stock_id: 301, space_id: 501, store_id: 401, after_quantity: 6, created_at: '2026-04-30 23:00:00' },
|
||
{ id: 11, stock_id: 301, space_id: 502, store_id: 401, after_quantity: 10, created_at: '2026-04-30 22:00:00' },
|
||
],
|
||
],
|
||
stockRows: [
|
||
{ id: 301, item_name: '商品C', item_code: 'SKU-C' },
|
||
],
|
||
barcodeRows: [
|
||
{ stock_id: 301, barcode: 'BC-C-1' },
|
||
],
|
||
storeRows: [
|
||
{ id: 401, company_name: '货主丙' },
|
||
],
|
||
spaceRows: [
|
||
{ id: 501, custom_name: '高位货架', space_code: 'A-01' },
|
||
{ id: 502, custom_name: '', space_code: 'B-02' },
|
||
],
|
||
});
|
||
|
||
const result = await service.search('2026-05-01 00:00:00', '2026-05-01 23:59:59', true, [ 401 ]);
|
||
|
||
assert.equal(result.code, 200);
|
||
assert.equal(result.data.list.length, 2);
|
||
|
||
const spaceA = result.data.list.find(item => item.space_id === 501);
|
||
const spaceB = result.data.list.find(item => item.space_id === 502);
|
||
assert.ok(spaceA);
|
||
assert.ok(spaceB);
|
||
assert.equal(spaceA.space_name, '高位货架');
|
||
assert.equal(spaceB.space_name, 'B-02');
|
||
assert.equal(spaceA.begin_total, 6);
|
||
assert.equal(spaceA.end_total, 10);
|
||
assert.equal(spaceB.begin_total, 10);
|
||
assert.equal(spaceB.end_total, 12);
|
||
assert.match(calls.queries[1].sql, /FROM wms_storage_transaction t/);
|
||
assert.match(calls.queries[1].sql, /GROUP BY t.stock_id, COALESCE\(t.space_id, 0\), t.store_id/);
|
||
assert.match(calls.queries[2].sql, /FROM wms_storage_transaction t/);
|
||
assert.match(calls.queries[3].sql, /FROM wms_storage_transaction t/);
|
||
// 回归断言:by_space 口径下 intervalEdge/preStart 子查询需同时带 space + stock/store 关联
|
||
assert.match(calls.queries[2].sql, /COALESCE\(t2.space_id, 0\) = g.space_id/);
|
||
assert.match(calls.queries[2].sql, /t2\.stock_id = g\.stock_id AND t2\.store_id = g\.store_id/);
|
||
assert.match(calls.queries[2].sql, /t3\.stock_id = g\.stock_id AND t3\.store_id = g\.store_id/);
|
||
assert.match(calls.queries[3].sql, /COALESCE\(t3.space_id, 0\) = g.space_id/);
|
||
assert.match(calls.queries[3].sql, /t3\.stock_id = g\.stock_id AND t3\.store_id = g\.store_id/);
|
||
});
|
||
|
||
it('should return base space keys with zero fallback when by_space is true and interval has no transactions', async () => {
|
||
const { service } = createReportServiceHarness({
|
||
queryResults: [
|
||
[
|
||
{ stock_id: 901, space_id: 301, store_id: 701, quantity: 15 },
|
||
{ stock_id: 902, space_id: 302, store_id: 701, quantity: 9 },
|
||
],
|
||
[],
|
||
[],
|
||
[],
|
||
],
|
||
stockRows: [
|
||
{ id: 901, item_name: '商品M', item_code: 'SKU-M' },
|
||
{ id: 902, item_name: '商品N', item_code: 'SKU-N' },
|
||
],
|
||
storeRows: [
|
||
{ id: 701, company_name: '货主M' },
|
||
],
|
||
spaceRows: [
|
||
{ id: 301, custom_name: '一号位', space_code: 'A-01' },
|
||
{ id: 302, custom_name: '', space_code: 'A-02' },
|
||
],
|
||
});
|
||
|
||
const result = await service.search(
|
||
'2026-05-10 00:00:00',
|
||
'2026-05-10 23:59:59',
|
||
true,
|
||
[],
|
||
{
|
||
sortField: 'begin_total',
|
||
sortOrder: 'DESC',
|
||
}
|
||
);
|
||
|
||
assert.equal(result.code, 200);
|
||
assert.equal(result.data.list.length, 2);
|
||
|
||
assert.deepEqual(result.data.list[0], {
|
||
start_time: '2026-05-10 00:00:00',
|
||
end_time: '2026-05-10 23:59:59',
|
||
stock_id: 901,
|
||
store_id: 701,
|
||
space_id: 301,
|
||
begin_total: 0,
|
||
end_total: 0,
|
||
inbound_total: 0,
|
||
outbound_total: 0,
|
||
store_name: '货主M',
|
||
warehouse_id: 0,
|
||
warehouse_name: '',
|
||
item_name: '商品M',
|
||
barcode: '',
|
||
item_code: 'SKU-M',
|
||
space_name: '一号位',
|
||
});
|
||
|
||
assert.deepEqual(result.data.list[1], {
|
||
start_time: '2026-05-10 00:00:00',
|
||
end_time: '2026-05-10 23:59:59',
|
||
stock_id: 902,
|
||
store_id: 701,
|
||
space_id: 302,
|
||
begin_total: 0,
|
||
end_total: 0,
|
||
inbound_total: 0,
|
||
outbound_total: 0,
|
||
store_name: '货主M',
|
||
warehouse_id: 0,
|
||
warehouse_name: '',
|
||
item_name: '商品N',
|
||
barcode: '',
|
||
item_code: 'SKU-N',
|
||
space_name: 'A-02',
|
||
});
|
||
});
|
||
|
||
it('should return base stocks with zero fallback when by_space is false and interval has no transactions', async () => {
|
||
const { service, calls } = createReportServiceHarness({
|
||
queryResults: [
|
||
[
|
||
{ stock_id: 701, store_id: 901, quantity: 37 },
|
||
],
|
||
[],
|
||
[],
|
||
[],
|
||
],
|
||
stockRows: [
|
||
{ id: 701, item_name: '商品X', item_code: 'SKU-X' },
|
||
],
|
||
storeRows: [
|
||
{ id: 901, company_name: '货主X' },
|
||
],
|
||
});
|
||
|
||
const result = await service.search('2026-05-10 00:00:00', '2026-05-10 23:59:59', false, [ 901 ]);
|
||
|
||
assert.equal(result.code, 200);
|
||
assert.equal(result.data.list.length, 1);
|
||
assert.deepEqual(result.data.list[0], {
|
||
start_time: '2026-05-10 00:00:00',
|
||
end_time: '2026-05-10 23:59:59',
|
||
stock_id: 701,
|
||
store_id: 901,
|
||
begin_total: 0,
|
||
end_total: 0,
|
||
inbound_total: 0,
|
||
outbound_total: 0,
|
||
store_name: '货主X',
|
||
warehouse_id: 0,
|
||
warehouse_name: '',
|
||
item_name: '商品X',
|
||
barcode: '',
|
||
item_code: 'SKU-X',
|
||
});
|
||
assert.equal(calls.queries.length, 4);
|
||
assert.match(calls.queries[1].sql, /created_at >= :startTime/);
|
||
assert.match(calls.queries[1].sql, /created_at <= :endTime/);
|
||
assert.deepEqual(calls.queries[1].options.replacements.storeIds, [ 901 ]);
|
||
assert.match(calls.queries[3].sql, /created_at < :startTime/);
|
||
});
|
||
|
||
it('should sort by end_total in DESC order when sort params are valid', async () => {
|
||
const { service } = createReportServiceHarness({
|
||
queryResults: [
|
||
[
|
||
{ stock_id: 801, store_id: 901, quantity: 10 },
|
||
{ stock_id: 802, store_id: 901, quantity: 20 },
|
||
],
|
||
[
|
||
{ stock_id: 801, space_id: 0, store_id: 901, inbound_total: 1, outbound_total: 0 },
|
||
{ stock_id: 802, space_id: 0, store_id: 901, inbound_total: 2, outbound_total: 0 },
|
||
],
|
||
[
|
||
{ id: 1, stock_id: 801, space_id: 0, storage_id: 9101, store_id: 901, before_quantity: 10, after_quantity: 11, created_at: '2026-05-01 12:00:00' },
|
||
{ id: 2, stock_id: 802, space_id: 0, storage_id: 9102, store_id: 901, before_quantity: 20, after_quantity: 22, created_at: '2026-05-01 12:00:00' },
|
||
],
|
||
[],
|
||
],
|
||
stockRows: [
|
||
{ id: 801, item_name: '商品Y', item_code: 'SKU-Y' },
|
||
{ id: 802, item_name: '商品Z', item_code: 'SKU-Z' },
|
||
],
|
||
storeRows: [
|
||
{ id: 901, company_name: '货主Y' },
|
||
],
|
||
});
|
||
|
||
const result = await service.search(
|
||
'2026-05-01 00:00:00',
|
||
'2026-05-01 23:59:59',
|
||
false,
|
||
[ 901 ],
|
||
{
|
||
sortField: 'end_total',
|
||
sortOrder: 'DESC',
|
||
}
|
||
);
|
||
|
||
assert.equal(result.code, 200);
|
||
assert.equal(result.data.list.length, 2);
|
||
assert.equal(result.data.list[0].stock_id, 802);
|
||
assert.equal(result.data.list[0].end_total, 22);
|
||
assert.equal(result.data.list[1].stock_id, 801);
|
||
assert.equal(result.data.list[1].end_total, 11);
|
||
});
|
||
|
||
it('should pass destructured where params from method layer to systems layer', async () => {
|
||
const captured = {
|
||
startTime: null,
|
||
endTime: null,
|
||
bySpace: null,
|
||
storeIds: null,
|
||
sort: null,
|
||
};
|
||
|
||
const ctx = {
|
||
app: {
|
||
Sequelize: {
|
||
Op: {},
|
||
},
|
||
},
|
||
service: {
|
||
systems: {
|
||
storage: {
|
||
report: {
|
||
async search(startTime, endTime, bySpace, storeIds, sort) {
|
||
captured.startTime = startTime;
|
||
captured.endTime = endTime;
|
||
captured.bySpace = bySpace;
|
||
captured.storeIds = storeIds;
|
||
captured.sort = sort;
|
||
return {
|
||
code: 200,
|
||
message: '查询成功',
|
||
data: { list: [] },
|
||
};
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
logger: {
|
||
info() {},
|
||
warn() {},
|
||
error() {},
|
||
},
|
||
user: {
|
||
store_id: 100000,
|
||
},
|
||
};
|
||
|
||
const methodService = new StockReportMethodService(ctx);
|
||
methodService.prepareWhereContext = function prepareWhereContext() {
|
||
return {
|
||
whereValue: {
|
||
start_time: '2026-05-01 00:00:00',
|
||
end_time: '2026-05-02 23:59:59',
|
||
by_space: true,
|
||
store_ids: [ 11, 22 ],
|
||
sort_field: 'begin_total',
|
||
sort_order: 'asc',
|
||
},
|
||
};
|
||
};
|
||
|
||
const result = await methodService.search({
|
||
sort: {
|
||
sort_field: 'end_total',
|
||
sort_order: 'desc',
|
||
},
|
||
where: {
|
||
start_time: 'ignored',
|
||
},
|
||
});
|
||
|
||
assert.equal(result.flag, 'success');
|
||
assert.equal(result.code, 200);
|
||
assert.equal(captured.startTime, '2026-05-01 00:00:00');
|
||
assert.equal(captured.endTime, '2026-05-02 23:59:59');
|
||
assert.equal(captured.bySpace, true);
|
||
assert.deepEqual(captured.storeIds, [ 11, 22 ]);
|
||
assert.deepEqual(captured.sort, {
|
||
sortField: 'end_total',
|
||
sortOrder: 'desc',
|
||
});
|
||
});
|
||
|
||
it('should submit export task and return task_id with submitted status', async () => {
|
||
const { methodService } = createReportMethodHarness();
|
||
|
||
const result = await methodService.export({
|
||
sort: {
|
||
sort_field: 'end_total',
|
||
sort_order: 'desc',
|
||
},
|
||
});
|
||
|
||
assert.equal(result.flag, 'success');
|
||
assert.equal(result.code, 1);
|
||
assert.ok(result.task_id);
|
||
assert.equal(result.status, 'submitted');
|
||
assert.equal(result.progress, 0);
|
||
});
|
||
|
||
it('should return success progress and download_url after setImmediate task execution', async () => {
|
||
const { methodService, captured } = createReportMethodHarness();
|
||
|
||
const submitResult = await methodService.export({
|
||
sort: {
|
||
sort_field: 'end_total',
|
||
sort_order: 'desc',
|
||
},
|
||
});
|
||
const taskId = submitResult.task_id;
|
||
assert.ok(taskId);
|
||
|
||
await new Promise(resolve => setImmediate(resolve));
|
||
await new Promise(resolve => setImmediate(resolve));
|
||
|
||
const progressResult = await methodService.exportTaskProgress({
|
||
task_id: taskId,
|
||
});
|
||
|
||
assert.equal(progressResult.flag, 'success');
|
||
assert.equal(progressResult.code, 1);
|
||
assert.equal(progressResult.task_id, taskId);
|
||
assert.equal(progressResult.status, 'success');
|
||
assert.equal(progressResult.progress, 100);
|
||
assert.equal(progressResult.download_url, 'https://cdn.example.com/库存报表_20260501_20260502.xlsx');
|
||
assert.equal(captured.exportCalls.length, 1);
|
||
assert.equal(captured.exportCalls[0].startTime, '2026-05-01 00:00:00');
|
||
assert.equal(captured.exportCalls[0].endTime, '2026-05-02 23:59:59');
|
||
assert.equal(captured.exportCalls[0].bySpace, false);
|
||
assert.deepEqual(captured.exportCalls[0].storeIds, [ 33, 44 ]);
|
||
assert.deepEqual(captured.exportCalls[0].sort, {
|
||
sortField: 'end_total',
|
||
sortOrder: 'desc',
|
||
});
|
||
});
|
||
|
||
it('should return not_found when task_id does not exist', async () => {
|
||
const { methodService } = createReportMethodHarness();
|
||
|
||
const result = await methodService.exportTaskProgress({
|
||
task_id: 'not_exists_task_id',
|
||
});
|
||
|
||
assert.equal(result.flag, 'success');
|
||
assert.equal(result.code, 1);
|
||
assert.equal(result.task_id, 'not_exists_task_id');
|
||
assert.equal(result.status, 'not_found');
|
||
assert.equal(result.progress, 0);
|
||
assert.equal(result.download_url, '');
|
||
});
|
||
|
||
it('should export summary and transaction sheets with readable detail fields', async () => {
|
||
const { service, calls } = createReportServiceHarness({
|
||
queryResults: [
|
||
[
|
||
{ stock_id: 701, store_id: 901, quantity: 37 },
|
||
],
|
||
[
|
||
{ stock_id: 701, space_id: 0, store_id: 901, inbound_total: 2, outbound_total: 1 },
|
||
],
|
||
[
|
||
{ id: 1, stock_id: 701, space_id: 0, storage_id: 5001, store_id: 901, before_quantity: 10, after_quantity: 11, created_at: '2026-05-01 12:00:00' },
|
||
],
|
||
[
|
||
{ id: 10, stock_id: 701, space_id: 0, store_id: 901, after_quantity: 9, created_at: '2026-04-30 23:00:00' },
|
||
],
|
||
[
|
||
{
|
||
id: 1001,
|
||
created_at: '2026-05-01 12:00:00',
|
||
transaction_type: ' inbound ',
|
||
store_id: 901,
|
||
stock_id: 701,
|
||
space_id: 301,
|
||
quantity: 2,
|
||
before_quantity: 10,
|
||
after_quantity: 12,
|
||
before_locked_quantity: 1,
|
||
after_locked_quantity: 1,
|
||
batch_no: 'BATCH-001',
|
||
inventory_type: 'ZP',
|
||
order_type: 'SCRK',
|
||
order_no: 'RK20260501001',
|
||
order_id: 6001,
|
||
receiving_id: 7001,
|
||
entry_order_id: 8001,
|
||
operator_name: '张三',
|
||
remark: '测试备注',
|
||
},
|
||
{
|
||
id: 1002,
|
||
created_at: '2026-05-01 12:30:00',
|
||
transaction_type: ' transfer_out ',
|
||
store_id: 901,
|
||
stock_id: 701,
|
||
space_id: 301,
|
||
quantity: 1,
|
||
before_quantity: 12,
|
||
after_quantity: 12,
|
||
before_locked_quantity: 0,
|
||
after_locked_quantity: 0,
|
||
batch_no: 'BATCH-001',
|
||
inventory_type: 'ZP',
|
||
order_type: null,
|
||
order_no: null,
|
||
order_id: null,
|
||
receiving_id: null,
|
||
entry_order_id: null,
|
||
operator_name: '张三',
|
||
remark: '移库出',
|
||
},
|
||
{
|
||
id: 1003,
|
||
created_at: '2026-05-01 12:31:00',
|
||
transaction_type: 'transfer_in',
|
||
store_id: 901,
|
||
stock_id: 701,
|
||
space_id: 301,
|
||
quantity: 1,
|
||
before_quantity: 15,
|
||
after_quantity: 15,
|
||
before_locked_quantity: 0,
|
||
after_locked_quantity: 0,
|
||
batch_no: 'BATCH-001',
|
||
inventory_type: 'ZP',
|
||
order_type: null,
|
||
order_no: null,
|
||
order_id: null,
|
||
receiving_id: null,
|
||
entry_order_id: null,
|
||
operator_name: '张三',
|
||
remark: '移库入',
|
||
},
|
||
{
|
||
id: 1004,
|
||
created_at: '2026-05-01 12:32:00',
|
||
transaction_type: ' custom_type ',
|
||
store_id: 901,
|
||
stock_id: 701,
|
||
space_id: 301,
|
||
quantity: 1,
|
||
before_quantity: 15,
|
||
after_quantity: 16,
|
||
before_locked_quantity: 0,
|
||
after_locked_quantity: 0,
|
||
batch_no: 'BATCH-001',
|
||
inventory_type: 'ZP',
|
||
order_type: null,
|
||
order_no: null,
|
||
order_id: null,
|
||
receiving_id: null,
|
||
entry_order_id: null,
|
||
operator_name: '张三',
|
||
remark: '未知类型',
|
||
},
|
||
],
|
||
],
|
||
stockRows: [
|
||
{ id: 701, item_name: '商品X', item_code: 'SKU-X' },
|
||
],
|
||
barcodeRows: [
|
||
{ stock_id: 701, barcode: 'BC-X-1' },
|
||
],
|
||
storeRows: [
|
||
{ id: 901, company_name: '货主X' },
|
||
],
|
||
spaceRows: [
|
||
{ id: 301, custom_name: 'A01位', space_code: 'A-01' },
|
||
],
|
||
});
|
||
|
||
const result = await service.export(
|
||
'2026-05-01 00:00:00',
|
||
'2026-05-01 23:59:59',
|
||
false,
|
||
[ 901 ],
|
||
{
|
||
sortField: 'end_total',
|
||
sortOrder: 'DESC',
|
||
}
|
||
);
|
||
|
||
assert.ok(result.filename.endsWith('.xlsx'));
|
||
assert.ok(result.fileKey);
|
||
assert.ok(result.url);
|
||
assert.equal(calls.exports.length, 1);
|
||
|
||
const exportPayload = calls.exports[0];
|
||
assert.equal(exportPayload.sheets.length, 2);
|
||
assert.equal(exportPayload.sheets[0].name, '汇总');
|
||
assert.equal(exportPayload.sheets[1].name, '变更记录');
|
||
|
||
assert.equal(exportPayload.sheets[0].rows.length, 1);
|
||
assert.equal(exportPayload.sheets[0].rows[0].stock_id, 701);
|
||
assert.equal(exportPayload.sheets[0].rows[0].store_name, '货主X');
|
||
|
||
assert.equal(exportPayload.sheets[1].rows.length, 4);
|
||
const detailRow = exportPayload.sheets[1].rows[0];
|
||
assert.equal(detailRow.transaction_type, '入库');
|
||
assert.equal(detailRow.store_name, '货主X');
|
||
assert.equal(detailRow.item_code, 'SKU-X');
|
||
assert.equal(detailRow.item_name, '商品X');
|
||
assert.equal(detailRow.barcode, 'BC-X-1');
|
||
// 变更记录明细列白名单(detailColumns)不含库位字段,space_name 不应出现在明细行中
|
||
assert.equal(detailRow.space_name, undefined);
|
||
assert.equal(detailRow.quantity, 2);
|
||
assert.equal(detailRow.before_locked_quantity, 1);
|
||
assert.equal(detailRow.after_locked_quantity, 1);
|
||
assert.equal(detailRow.order_no, 'RK20260501001');
|
||
assert.equal(detailRow.operator_name, '张三');
|
||
|
||
const transferOutRow = exportPayload.sheets[1].rows[1];
|
||
const transferInRow = exportPayload.sheets[1].rows[2];
|
||
const unknownTypeRow = exportPayload.sheets[1].rows[3];
|
||
assert.equal(transferOutRow.transaction_type, '移库出');
|
||
assert.equal(transferInRow.transaction_type, '移库入');
|
||
assert.equal(unknownTypeRow.transaction_type, 'custom_type');
|
||
});
|
||
|
||
it('should always exclude LOCK and UNLOCK on store mode export regardless of exportMode', async () => {
|
||
const { service, calls } = createReportServiceHarness({
|
||
warehouseId: 1000000, // store 模式下 ctx.user.store_id 即货主 ID
|
||
queryResults: [
|
||
[
|
||
{ stock_id: 701, store_id: 1000000, warehouse_id: 100000, quantity: 37, item_code: 'SKU-X', item_name: '商品X' },
|
||
],
|
||
[
|
||
{ stock_id: 701, store_id: 1000000, inbound_total: 2, outbound_total: 1 },
|
||
],
|
||
[
|
||
{ id: 1, stock_id: 701, space_id: 0, store_id: 1000000, before_quantity: 10, after_quantity: 11, created_at: '2026-05-01 12:00:00' },
|
||
],
|
||
[
|
||
{ id: 10, stock_id: 701, space_id: 0, store_id: 1000000, after_quantity: 9, created_at: '2026-04-30 23:00:00' },
|
||
],
|
||
[
|
||
{
|
||
id: 1001,
|
||
created_at: '2026-05-01 12:00:00',
|
||
transaction_type: 'LOCK',
|
||
store_id: 1000000,
|
||
stock_id: 701,
|
||
space_id: 0,
|
||
quantity: 1,
|
||
before_quantity: 10,
|
||
after_quantity: 10,
|
||
before_locked_quantity: 0,
|
||
after_locked_quantity: 1,
|
||
batch_no: '',
|
||
inventory_type: '',
|
||
order_type: null,
|
||
order_no: null,
|
||
order_id: null,
|
||
receiving_id: null,
|
||
entry_order_id: null,
|
||
operator_name: '',
|
||
remark: '',
|
||
},
|
||
],
|
||
],
|
||
stockRows: [
|
||
{ id: 701, item_name: '商品X', item_code: 'SKU-X' },
|
||
],
|
||
barcodeRows: [
|
||
{ stock_id: 701, barcode: 'BC-X-1' },
|
||
],
|
||
storeRows: [
|
||
{ id: 1000000, company_name: '货主X' },
|
||
],
|
||
});
|
||
|
||
// 货主侧即使传 exportMode='item',也必须无条件排除 LOCK/UNLOCK
|
||
const result = await service.export(
|
||
'2026-05-01 00:00:00',
|
||
'2026-05-01 23:59:59',
|
||
false,
|
||
[],
|
||
null,
|
||
'item',
|
||
'store'
|
||
);
|
||
|
||
assert.ok(result.filename.endsWith('.xlsx'));
|
||
const detailQuery = calls.queries[4];
|
||
assert.match(detailQuery.sql, /transaction_type NOT IN \(:excludeStoreTypes\)/);
|
||
assert.deepEqual(detailQuery.options.replacements.excludeStoreTypes, [ 'LOCK', 'UNLOCK' ]);
|
||
assert.doesNotMatch(detailQuery.sql, /excludeLockType/);
|
||
});
|
||
|
||
it('should keep warehouse mode lock filter behavior unchanged', async () => {
|
||
const baseQueryResults = [
|
||
[
|
||
{ stock_id: 701, store_id: 901, warehouse_id: 100000, quantity: 37, item_code: 'SKU-X', item_name: '商品X' },
|
||
],
|
||
[
|
||
{ stock_id: 701, store_id: 901, inbound_total: 2, outbound_total: 1 },
|
||
],
|
||
[
|
||
{ id: 1, stock_id: 701, space_id: 0, store_id: 901, before_quantity: 10, after_quantity: 11, created_at: '2026-05-01 12:00:00' },
|
||
],
|
||
[
|
||
{ id: 10, stock_id: 701, space_id: 0, store_id: 901, after_quantity: 9, created_at: '2026-04-30 23:00:00' },
|
||
],
|
||
[
|
||
{
|
||
id: 1001,
|
||
created_at: '2026-05-01 12:00:00',
|
||
transaction_type: 'LOCK',
|
||
store_id: 901,
|
||
stock_id: 701,
|
||
space_id: 0,
|
||
quantity: 1,
|
||
before_quantity: 10,
|
||
after_quantity: 10,
|
||
before_locked_quantity: 0,
|
||
after_locked_quantity: 1,
|
||
batch_no: '',
|
||
inventory_type: '',
|
||
order_type: null,
|
||
order_no: null,
|
||
order_id: null,
|
||
receiving_id: null,
|
||
entry_order_id: null,
|
||
operator_name: '',
|
||
remark: '',
|
||
},
|
||
],
|
||
];
|
||
|
||
const { service, calls } = createReportServiceHarness({
|
||
queryResults: [ ...baseQueryResults, ...baseQueryResults ],
|
||
stockRows: [
|
||
{ id: 701, item_name: '商品X', item_code: 'SKU-X' },
|
||
],
|
||
barcodeRows: [
|
||
{ stock_id: 701, barcode: 'BC-X-1' },
|
||
],
|
||
storeRows: [
|
||
{ id: 901, company_name: '货主X' },
|
||
],
|
||
});
|
||
|
||
// 仓库模式默认口径:排除 LOCK
|
||
await service.export(
|
||
'2026-05-01 00:00:00',
|
||
'2026-05-01 23:59:59',
|
||
false,
|
||
[ 901 ],
|
||
null,
|
||
'',
|
||
'warehouse'
|
||
);
|
||
|
||
const defaultDetail = calls.queries[4];
|
||
assert.match(defaultDetail.sql, /transaction_type != :excludeLockType/);
|
||
assert.equal(defaultDetail.options.replacements.excludeLockType, 'LOCK');
|
||
assert.doesNotMatch(defaultDetail.sql, /excludeStoreTypes/);
|
||
|
||
// 仓库模式 item 口径:保留 LOCK(行为与改动前一致)
|
||
await service.export(
|
||
'2026-05-01 00:00:00',
|
||
'2026-05-01 23:59:59',
|
||
false,
|
||
[ 901 ],
|
||
null,
|
||
'item',
|
||
'warehouse'
|
||
);
|
||
|
||
const itemDetail = calls.queries[9];
|
||
assert.doesNotMatch(itemDetail.sql, /excludeLockType/);
|
||
assert.doesNotMatch(itemDetail.sql, /excludeStoreTypes/);
|
||
});
|
||
});
|