WMS_MAIN/app/service/systems/order_export.js
liufumingren 99367e5043 1
2026-06-06 05:15:46 +08:00

480 lines
18 KiB
JavaScript

'use strict';
const crypto = require('node:crypto');
const fs = require('node:fs');
const fsp = require('node:fs/promises');
const os = require('node:os');
const path = require('node:path');
const ExcelJS = require('exceljs');
const OrderBaseService = require('../systemMethods/order/base');
const DEFAULT_EXPORT_PAGE_SIZE = 200;
const ORDER_EXPORT_WORKSHEET_NAME = '订单导出';
const ORDER_EXPORT_ALLOWED_TABLE_TYPES = new Set([ 'current', 'history', 'dispatch', 'outsourced' ]);
const ORDER_EXPORT_MODULE_MAP = Object.freeze({
order: 'order',
revieworder: 'reviewOrder',
pendingorder: 'pendingOrder',
outboundorder: 'outboundOrder',
expectionorder: 'expectionOrder',
archiveorder: 'archiveOrder',
entrustorder: 'entrustOrder',
deliveryorder: 'deliveryOrder',
deliveryexpectionorder: 'deliveryExpectionOrder',
});
const ORDER_EXPORT_COLUMNS = Object.freeze([
{ header: '订单ID', key: 'id', width: 12 },
{ header: '订单号', key: 'delivery_order_code', width: 24 },
{ header: '外部单号', key: 'external_order_code', width: 24 },
{ header: '订单状态', key: 'status', width: 16 },
{ header: '步骤', key: 'step', width: 10 },
{ header: '波次号', key: 'wave_no', width: 18 },
{ header: '仓库ID', key: 'warehouse_id', width: 12 },
{ header: '货主ID', key: 'store_id', width: 12 },
{ header: '平台', key: 'sys_platform_name', width: 16 },
{ header: '店铺昵称', key: 'shop_nick', width: 20 },
{ header: '卖家昵称', key: 'seller_nick', width: 20 },
{ header: '买家昵称', key: 'buyer_nick', width: 20 },
{ header: '物流公司', key: 'logistics_name', width: 18 },
{ header: '运单号', key: 'express_numbers', width: 28 },
{ header: '商品种数', key: 'items_count', width: 12 },
{ header: '商品件数', key: 'items_total', width: 12 },
{ header: '总重量', key: 'items_weight', width: 12 },
{ header: '订单金额', key: 'total_amount', width: 14 },
{ header: '实收金额', key: 'got_amount', width: 14 },
{ header: '创建时间', key: 'create_at', width: 20 },
{ header: '支付时间', key: 'pay_time', width: 20 },
{ header: '发货时间', key: 'delivery_time', width: 20 },
{ header: '出库状态', key: 'outbound_status', width: 14 },
{ header: '复核状态', key: 'inspection_status', width: 14 },
{ header: '复核完成状态', key: 'recheck_status', width: 16 },
{ header: '配货状态', key: 'post_status', width: 14 },
{ header: '打包状态', key: 'pack_status', width: 14 },
{ header: '归档时间', key: 'archive_time', width: 20 },
]);
/**
* 订单导出系统服务。
* 负责复用订单列表查询语义,按页拉取数据并流式写入本地 xlsx 后上传。
*/
class OrderExportService extends OrderBaseService {
/**
* 获取单页导出数量。
* @return {number} 单页导出数量。
*/
getExportPageSize() {
return DEFAULT_EXPORT_PAGE_SIZE;
}
/**
* 规范订单导出模块名。
* @param {string} moduleName 原始模块名。
* @return {string} 规范后的模块名;为空时返回空字符串。
*/
normalizeExportModuleName(moduleName = '') {
const normalizedModuleName = String(moduleName || '').trim();
if (!normalizedModuleName) {
return '';
}
const mappedModuleName = ORDER_EXPORT_MODULE_MAP[normalizedModuleName.toLowerCase()];
if (!mappedModuleName) {
throw new Error(`不支持的订单导出模块: ${normalizedModuleName}`);
}
return mappedModuleName;
}
/**
* 根据表类型推导默认排序所使用的模块名。
* @param {string} tableType 订单表类型。
* @return {string} 用于排序默认值的模块名。
*/
getSortModuleNameByTableType(tableType = 'current') {
switch (tableType) {
case 'history':
return 'archiveOrder';
case 'dispatch':
return 'deliveryOrder';
case 'outsourced':
return 'entrustOrder';
case 'current':
default:
return 'order';
}
}
/**
* 解析订单导出目标,兼容 module/module_name 与 table_type 两种写法。
* @param {Object} options 解析参数。
* @param {string} [options.moduleName] 模块名。
* @param {string} [options.tableType] 表类型。
* @return {{ tableType: string, defaultWhereModuleName: string, sortModuleName: string }} 导出目标。
*/
resolveExportTarget(options = {}) {
const safeOptions = this.isPlainObject(options) ? options : {};
const moduleName = this.normalizeExportModuleName(safeOptions.moduleName || '');
const rawTableType = String(safeOptions.tableType || '').trim();
const tableTypeToken = rawTableType.toLowerCase();
const moduleNameFromTableType = ORDER_EXPORT_ALLOWED_TABLE_TYPES.has(tableTypeToken)
? ''
: this.normalizeExportModuleName(rawTableType);
const resolvedTableType = rawTableType
? this.resolveOrderTableType({ tableType: rawTableType })
: (moduleName ? this.getModuleConfig(moduleName).modelType : 'current');
if (moduleName && moduleNameFromTableType && moduleName !== moduleNameFromTableType) {
throw new Error(`module 与 table_type 不匹配: ${moduleName} / ${rawTableType}`);
}
if (moduleName) {
const expectedTableType = this.getModuleConfig(moduleName).modelType;
if (expectedTableType !== resolvedTableType) {
throw new Error(`module ${moduleName} 仅支持 ${expectedTableType} 表,当前传入 ${resolvedTableType}`);
}
}
return {
tableType: resolvedTableType,
defaultWhereModuleName: moduleName || moduleNameFromTableType || '',
sortModuleName: moduleName || moduleNameFromTableType || this.getSortModuleNameByTableType(resolvedTableType),
};
}
/**
* 获取订单导出列配置。
* @return {Array<Object>} 导出列配置。
*/
getOrderExportColumns() {
return ORDER_EXPORT_COLUMNS.map(column => ({ ...column }));
}
/**
* 生成订单导出文件名。
* @param {Object} target 导出目标。
* @return {string} 文件名。
*/
buildOrderExportFilename(target = {}) {
const safeTarget = this.isPlainObject(target) ? target : {};
const timestamp = new Date();
const year = timestamp.getFullYear();
const month = String(timestamp.getMonth() + 1).padStart(2, '0');
const day = String(timestamp.getDate()).padStart(2, '0');
const hour = String(timestamp.getHours()).padStart(2, '0');
const minute = String(timestamp.getMinutes()).padStart(2, '0');
const second = String(timestamp.getSeconds()).padStart(2, '0');
const moduleTag = safeTarget.defaultWhereModuleName || safeTarget.tableType || 'current';
return `订单导出_${moduleTag}_${year}${month}${day}${hour}${minute}${second}.xlsx`;
}
/**
* 生成上传 key。
* @param {number|string} warehouseId 仓库ID。
* @param {string} tableType 表类型。
* @return {string} 上传 key。
*/
buildUploadKey(warehouseId, tableType) {
const safeWarehouseId = String(warehouseId || 'unknown').trim() || 'unknown';
const safeTableType = String(tableType || 'current').trim() || 'current';
const randomToken = crypto.randomBytes(6).toString('hex');
return `exports/order/${safeWarehouseId}/${safeTableType}/${Date.now()}_${randomToken}.xlsx`;
}
/**
* 将模型行转换为普通对象。
* @param {Object} row 模型行或普通对象。
* @return {Object} 普通对象。
*/
toPlainRow(row = {}) {
if (row && typeof row.get === 'function') {
return row.get({ plain: true });
}
return this.isPlainObject(row) ? { ...row } : {};
}
/**
* 规范导出单元格值。
* @param {*} value 原始值。
* @return {string|number} 规范后的值。
*/
normalizeExportCellValue(value) {
if (value === null || value === undefined) {
return '';
}
if (Array.isArray(value)) {
return value.map(item => this.normalizeExportCellValue(item)).filter(Boolean).join(',');
}
if (value instanceof Date) {
return value.toISOString();
}
if (typeof value === 'object') {
return JSON.stringify(value);
}
return value;
}
/**
* 映射单行订单导出数据。
* @param {Object} orderRow 订单行。
* @return {Object} 导出行。
*/
mapOrderExportRow(orderRow = {}) {
const safeOrderRow = this.isPlainObject(orderRow) ? orderRow : {};
const expressNumbers = Array.isArray(safeOrderRow.express_numbers)
? safeOrderRow.express_numbers
: Array.isArray(safeOrderRow.waybill_codes)
? safeOrderRow.waybill_codes
: [];
const externalOrderCode = safeOrderRow.pre_delivery_order_code || safeOrderRow.source_order_codes || '';
return {
id: this.normalizeExportCellValue(safeOrderRow.id),
delivery_order_code: this.normalizeExportCellValue(safeOrderRow.delivery_order_code),
external_order_code: this.normalizeExportCellValue(externalOrderCode),
status: this.normalizeExportCellValue(safeOrderRow.status),
step: this.normalizeExportCellValue(safeOrderRow.step),
wave_no: this.normalizeExportCellValue(safeOrderRow.wave_no),
warehouse_id: this.normalizeExportCellValue(safeOrderRow.warehouse_id),
store_id: this.normalizeExportCellValue(safeOrderRow.store_id),
sys_platform_name: this.normalizeExportCellValue(safeOrderRow.sys_platform_name),
shop_nick: this.normalizeExportCellValue(safeOrderRow.shop_nick),
seller_nick: this.normalizeExportCellValue(safeOrderRow.seller_nick),
buyer_nick: this.normalizeExportCellValue(safeOrderRow.buyer_nick),
logistics_name: this.normalizeExportCellValue(safeOrderRow.logistics_name),
express_numbers: this.normalizeExportCellValue(expressNumbers),
items_count: this.normalizeExportCellValue(safeOrderRow.items_count),
items_total: this.normalizeExportCellValue(safeOrderRow.items_total),
items_weight: this.normalizeExportCellValue(safeOrderRow.items_weight),
total_amount: this.normalizeExportCellValue(safeOrderRow.total_amount),
got_amount: this.normalizeExportCellValue(safeOrderRow.got_amount),
create_at: this.normalizeExportCellValue(safeOrderRow.create_at),
pay_time: this.normalizeExportCellValue(safeOrderRow.pay_time),
delivery_time: this.normalizeExportCellValue(safeOrderRow.delivery_time),
outbound_status: this.normalizeExportCellValue(safeOrderRow.outbound_status),
inspection_status: this.normalizeExportCellValue(safeOrderRow.inspection_status),
recheck_status: this.normalizeExportCellValue(safeOrderRow.recheck_status),
post_status: this.normalizeExportCellValue(safeOrderRow.post_status),
pack_status: this.normalizeExportCellValue(safeOrderRow.pack_status),
archive_time: this.normalizeExportCellValue(safeOrderRow.archive_time),
};
}
/**
* 上传本地导出文件并记录文件信息。
* @param {Object} options 上传参数。
* @param {string} options.filePath 本地文件路径。
* @param {string} options.filename 文件名。
* @param {number|string} options.warehouseId 仓库ID。
* @param {string} options.tableType 表类型。
* @return {Promise<Object>} 上传结果。
*/
async uploadOrderExportFile(options = {}) {
const safeOptions = this.isPlainObject(options) ? options : {};
const {
filePath,
filename,
warehouseId,
tableType,
} = safeOptions;
const uploadService = this.ctx?.service?.systems?.upload;
if (!uploadService || typeof uploadService.uploadFile !== 'function') {
throw new Error('上传服务不可用');
}
const stat = await fsp.stat(filePath);
const uploadKey = this.buildUploadKey(warehouseId, tableType);
const uploadStream = fs.createReadStream(filePath);
uploadStream.filename = filename;
uploadStream.mimeType = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
uploadStream.fileSize = stat.size;
const uploadResult = await uploadService.uploadFile(uploadStream, {
key: uploadKey,
category: 'document',
mimetype: 'xls,xlsx,csv',
});
let fileRecord = null;
if (typeof uploadService.uploadSuccessNotify === 'function') {
fileRecord = await uploadService.uploadSuccessNotify({
url: uploadResult.fileName,
fileKey: uploadResult.fileName,
fileName: filename,
fileType: 'document',
mimeType: uploadStream.mimeType,
fileSize: stat.size,
category: 'document',
businessType: 'orderExport',
businessId: `${warehouseId}:${tableType}`,
uploaderType: this.ctx?.user?.role || 'system_api',
uploaderDept: this.ctx?.user?.department || '',
});
}
return {
filename,
fileKey: uploadResult.fileName,
url: uploadResult.url || uploadResult.cdnUrl || uploadResult.cosUrl || '',
cdnUrl: uploadResult.cdnUrl || uploadResult.url || '',
cosUrl: uploadResult.cosUrl || '',
fileRecord: fileRecord?.data || fileRecord || null,
};
}
/**
* 导出订单列表。
* @param {Object} options 导出参数。
* @param {string} [options.tableType] 表类型。
* @param {string} [options.moduleName] 模块名。
* @param {Object} [options.where] 查询条件。
* @param {Object} [options.sort] 排序参数。
* @param {Function} [options.onProgress] 进度回调。
* @return {Promise<Object>} 上传结果与统计信息。
*/
async exportOrders(options = {}) {
const safeOptions = this.isPlainObject(options) ? options : {};
const target = this.resolveExportTarget({
tableType: safeOptions.tableType,
moduleName: safeOptions.moduleName,
});
const warehouseId = this.getWarehouseId();
const requestData = {
where: this.isPlainObject(safeOptions.where) ? { ...safeOptions.where } : {},
sort: this.isPlainObject(safeOptions.sort) ? { ...safeOptions.sort } : {},
};
const progressHandler = typeof safeOptions.onProgress === 'function'
? safeOptions.onProgress
: async () => {};
const { where } = this.prepareWhereContext(requestData, {
specialFieldMap: {
quickWhere: {
bucket: 'quick',
},
},
});
const { where: sanitizedWhere, expressNumbers } = this.extractOrderListExpressVirtualFilter(where);
const mergedWhere = this.mergeWhereObjects(
target.defaultWhereModuleName ? this.getDefaultWhere(target.defaultWhereModuleName) : {},
sanitizedWhere
);
let queryWhere = this.buildWhere(mergedWhere, warehouseId, {
specialFieldMap: {
quickWhere: {
bucket: 'quick',
},
},
});
if (expressNumbers.length > 0) {
const orderIds = await this.findOrderIdsByExpressNumbers(expressNumbers, warehouseId);
queryWhere = this.appendOrderIdsFilterToWhere(queryWhere, orderIds);
}
const orderModel = await this.getOrderModelByTableType(target.tableType, warehouseId);
const pageSize = this.getExportPageSize();
const order = this.buildListOrder(requestData.sort, target.sortModuleName);
const totalCount = await orderModel.count({ where: queryWhere });
const tempDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'wms-order-export-'));
const filename = this.buildOrderExportFilename(target);
const filePath = path.join(tempDir, filename);
const workbook = new ExcelJS.stream.xlsx.WorkbookWriter({
filename: filePath,
useStyles: false,
useSharedStrings: false,
});
const worksheet = workbook.addWorksheet(ORDER_EXPORT_WORKSHEET_NAME);
worksheet.columns = this.getOrderExportColumns();
let currentCount = 0;
let page = 1;
try {
await progressHandler({
status: 'running',
progress: totalCount > 0 ? 5 : 90,
currentCount,
totalCount,
message: totalCount > 0 ? `已命中 ${totalCount} 条订单,开始导出` : '未命中数据,开始生成空文件',
});
while (currentCount < totalCount) {
const rows = await orderModel.findAll({
where: queryWhere,
limit: pageSize,
offset: (page - 1) * pageSize,
order,
raw: true,
});
if (!Array.isArray(rows) || rows.length === 0) {
break;
}
const normalizedRows = await this.attachOrderExpressNumbers(
rows.map(row => this.normalizeOrderListItem(this.toPlainRow(row)))
);
for (const row of normalizedRows) {
worksheet.addRow(this.mapOrderExportRow(row)).commit();
}
currentCount += normalizedRows.length;
await progressHandler({
status: 'running',
progress: Math.min(99, Math.max(5, Math.round((currentCount / Math.max(totalCount, 1)) * 90))),
currentCount,
totalCount,
message: `正在导出第 ${page} 页,共 ${Math.ceil(totalCount / pageSize) || 1} 页`,
});
page += 1;
}
worksheet.commit();
await workbook.commit();
const uploadResult = await this.uploadOrderExportFile({
filePath,
filename,
warehouseId,
tableType: target.tableType,
});
await progressHandler({
status: 'success',
progress: 100,
currentCount,
totalCount,
message: '导出任务完成',
result: uploadResult,
});
return {
...uploadResult,
table_type: target.tableType,
module_name: target.defaultWhereModuleName || '',
current_count: currentCount,
total_count: totalCount,
};
} catch (error) {
const workbookStream = workbook.stream;
if (workbookStream && typeof workbookStream.destroy === 'function') {
workbookStream.destroy();
}
throw error;
} finally {
await fsp.rm(tempDir, { recursive: true, force: true });
}
}
}
module.exports = OrderExportService;