793 lines
28 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 MainService = require('../../main');
const ENTRY_EXPORT_TASK_CACHE_KEY_PREFIX = 'entry_export_task_';
const ENTRY_EXPORT_TASK_CACHE_TTL_SECONDS = 1800;
/**
* 系统方法层:storage.entry(入库单相关接口包装层)。
* 主要职责:统一包装系统方法接口,处理权限、日志等公共逻辑,调用底层 service 实现业务功能。
* 注意:当前实现仅为包装层,实际业务逻辑完全依赖底层 service 的方法实现。
*/
class entryService extends MainService {
constructor(ctx) {
super(ctx);
const _noNeedLogin = '';
const _noNeedRight = 'list,listStore,get,getStore,cancel,getPrintData,getDirectInboundItems,addItem,commit,removeItem,quickInbound,receivingCompare,queryEntryLogs,getReceivingDetailsForBind,reviewEntry,containerList,export,exportTaskProgress,storeExport,storeExportTaskProgress';
const _noNeedLog = 'list,listStore,get,getStore,getPrintData,reviewEntry,export,exportTaskProgress,storeExport,storeExportTaskProgress';
const _noNeedAuth = 'list,listStore,get,getStore,cancel,getPrintData,getDirectInboundItems,addItem,commit,removeItem,bindReceiving,quickInbound,receivingCompare,unbindReceiving,queryEntryLogs,getReceivingDetailsForBind,reviewEntry,containerList,export,exportTaskProgress,storeExport,storeExportTaskProgress';
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
}
/**
* 入库单列表查询。
* @param {Object} data 请求体
* @param {Object} [data.pagination] 分页参数
* @param {Object} [data.where] 动态筛选条件
* @param {Object} [data.sort] 排序参数
* @return {Promise<Object>} 统一 success 包装
*/
async list(data = {}) {
const { service } = this;
const { pagination, sort } = data;
const { where } = this.prepareWhereContext(data, {
specialFieldMap: {
quickWhere: {
bucket: 'quick',
},
},
});
const result = await service.systems.storage.entry.list(where, pagination, sort);
return this.success('ok', result);
}
/**
* 货主侧入库单列表查询。
* 与 list 共享底层逻辑,但以货主维度(store_id)过滤,不使用仓库维度(warehouse_id)。
* 货主登录后仅能看到自己货主下的入库单。
* @param {Object} data 请求体
* @param {Object} [data.pagination] 分页参数
* @param {Object} [data.where] 动态筛选条件
* @param {Object} [data.sort] 排序参数
* @return {Promise<Object>} 统一 success 包装
*/
async listStore(data = {}) {
const { service } = this;
const { pagination, sort } = data;
const { where } = this.prepareWhereContext(data, {
specialFieldMap: {
quickWhere: {
bucket: 'quick',
},
},
});
const result = await service.systems.storage.entry.list(where, pagination, sort, 'store');
// 裁剪货主侧冗余字段:货主自己的 store_name/store 关联、奇门编码
if (result && result.data && Array.isArray(result.data.list)) {
result.data.list.forEach(item => {
delete item.store_name;
delete item.store;
delete item.qimen_owner_code;
delete item.qimen_warehouse_code;
});
}
return this.success('ok', result);
}
/**
* 查询入库单详情(与原 storage.directInbound.getItems 输出格式一致)。
* 返回入库单基本信息(id、entry_order_code、order_status、store_remask)、
* 商品明细列表(含计划数量、已完成入库数量、商品信息、收货单绑定明细),
* 以及收货单绑定关系列表。
* @param {Object} data 请求体
* @param {number} data.id 入库单ID(必填)
* @return {Promise<Object>} 统一 success 包装
*/
async get(data = {}) {
const { service } = this;
const { id } = data || {};
const result = await service.systems.storage.entry.get({ id });
return this.success('ok', result);
}
/**
* 货主侧查询入库单详情。与 get 共享底层逻辑,
* 但以货主维度(store_id)校验权限(不使用 warehouse_id),
* 货主登录后仅能查看自己货主下的入库单明细。
* 返回结构与 get 一致。
* @param {Object} data 请求体
* @param {number} data.id 入库单ID(必填)
* @return {Promise<Object>} 统一 success 包装
*/
async getStore(data = {}) {
const { service } = this;
const { id } = data || {};
const result = await service.systems.storage.entry.get({ id }, 'store');
return this.success('ok', result);
}
/**
* 作废入库单。
* 支持传入单个 id 或批量 ids,保持透传给业务层处理。
* @param {Object} data 请求体
* @param {number} [data.id] 单个入库单ID
* @param {number[]} [data.ids] 批量入库单ID数组
* @return {Promise<Object>} 统一 success 包装
*/
async cancel(data = {}) {
const { service } = this;
const result = await service.systems.storage.entry.cancel(data);
return this.success('ok', result);
}
/**
* 按商品增量添加导入/PDA 直接入库记录(从 storage.entry 模块暴露)。
* @param {Object} data 请求体
* @param {number} data.entry_order_id 入库单ID
* @param {number} [data.stock_id] 商品SKU ID(单条模式)
* @param {number} [data.quantity] 本次入库数量(单条模式)
* @param {string} [data.inbound_type] 入库方式(单条模式)
* @param {Array} [data.items] 商品列表(批量模式)
* @param {string} [data.remark] 备注(单条模式)
* @param {number} [data.space_id] 库位ID(单条模式)
* @param {number} [data.receiving_detail_id] 收货单明细ID(单条模式,可选)
* @param {number} [data.allocated_quantity] 预分配数量(单条模式,可选)
* @return {Promise<Object>} 统一 success 包装
*/
async addItem(data = {}) {
const { service } = this;
const {
entry_order_id,
stock_id,
quantity,
inbound_type,
items,
remark,
space_id,
receiving_detail_id,
allocated_quantity,
} = data || {};
const result = await service.systems.inboundDirectLog.addItem({
entry_order_id,
stock_id,
quantity,
inbound_type,
items,
remark,
space_id,
receiving_detail_id,
allocated_quantity,
});
return this.success('ok', result);
}
/**
* 提交确认完成导入/PDA 直接入库(从 storage.entry 模块暴露)。
* @param {Object} data 请求体
* @param {number} data.entry_order_id 入库单 ID
* @return {Promise<Object>} 统一 success 包装
*/
async commit(data = {}) {
const { service } = this;
const { entry_order_id } = data || {};
const result = await service.systems.inboundDirectLog.commit(entry_order_id);
return this.success('ok', result);
}
/**
* 移除一条导入/PDA 直接入库记录(从 storage.entry 模块暴露)。
* @param {Object} data 请求体
* @param {number} data.id 入库记录ID
* @return {Promise<Object>} 统一 success 包装
*/
async removeItem(data = {}) {
const { service } = this;
const result = await service.systems.inboundDirectLog.removeItem(data);
return this.success('ok', result);
}
/**
* 绑定入库单与收货单的主表关系(仅主表绑定,不做明细分配)。
* @param {Object} data 请求体
* @param {number} data.entry_order_id 入库单 ID
* @param {number[]} data.receiving_ids 收货单 ID 列表
* @return {Promise<Object>} 统一 success 包装
*/
async bindReceiving(data = {}) {
const { ctx } = this;
console.log('[DEBUG] systems keys:', Object.keys(ctx.service.systems));
console.log('[DEBUG] receiving_entry_match:', typeof ctx.service.systems.receivingEntryMatch);
const { entry_order_id, receiving_ids } = data || {};
const creator_id = ctx.user ? ctx.user.id || ctx.user.user_id : undefined;
const result = await ctx.service.systems.receivingEntryMatch.bindEntryOrderReceiving({
entry_order_id,
receiving_ids,
creator_id,
});
return this.success('绑定完成', result);
}
/**
* 解除入库单与收货单的绑定关系。
* @param {Object} data 请求体
* @param {number} data.entry_order_id 入库单 ID
* @param {number[]} data.receiving_ids 要解除绑定的收货单 ID 列表
* @return {Promise<Object>} 统一 success 包装
*/
async unbindReceiving(data = {}) {
const { ctx } = this;
const { entry_order_id, receiving_ids } = data || {};
const result = await ctx.service.systems.receivingEntryMatch.unbindEntryOrderReceiving({
entry_order_id,
receiving_ids,
});
return this.success('解绑完成', result);
}
/**
* 快捷直入/虚拟入库(system method 包装层)。
* @param {Object} data 请求体
* @param {number} data.id 入库单ID
* @return {Promise<Object>} 统一 success 包装
*/
async quickInbound(data = {}) {
const { service } = this;
const { id } = data;
const result = await service.systems.storage.entry.quickInbound({ id });
if (result && result.code === 200) {
return this.success(result.message || 'ok', result);
}
return this.fail(result?.message || '快捷入库失败', result);
}
/**
* 获取入库单打印数据,按 RECEIPT 模板 field_code 映射返回。
* @param {Object} data 请求体
* @param {number} data.id 入库单ID
* @param {number} [data.warehouse_id] 仓库ID,不传则取当前用户仓库
* @return {Promise<Object>} 打印数据(扁平键值 + items 明细数组)
*/
async getPrintData(data = {}) {
const { ctx } = this;
const id = Number(data && data.id || 0);
if (!id) {
return this.fail('id 参数不能为空', { code: 400 });
}
try {
// 直接查询入库单完整信息(含 items、warehouse、store 等关联),供打印模板使用
const entryOrder = await ctx.model.EntryOrder.findByPk(id, {
include: [
{
model: ctx.model.Store,
as: 'warehouse',
attributes: [ 'id', 'company_name' ],
required: false,
},
{
model: ctx.model.Store,
as: 'store',
attributes: [ 'id', 'company_name' ],
required: false,
},
{
model: ctx.model.EntryItems,
as: 'items',
required: false,
},
],
});
if (!entryOrder || entryOrder.warehouse_id !== ctx.user.store_id || !entryOrder.is_enabled) {
return this.fail('入库单不存在', { code: 404 });
}
const entryOrderJSON = entryOrder.toJSON();
const items = Array.isArray(entryOrderJSON.items) ? entryOrderJSON.items : [];
// 查询商品条码和图片(复用 getStockDetails 缓存)
const barcodeMap = new Map();
const imageMap = new Map();
try {
const stockIds = items
.map(item => Number(item.stock_id || 0))
.filter(sid => sid > 0);
if (stockIds.length > 0) {
const stockDetails = await ctx.service.systems.stockWarehouse.getStockDetails(
stockIds,
{}
);
for (const detail of stockDetails) {
const sid = Number(detail.id);
// 提取条码
if (Array.isArray(detail.barcodes) && detail.barcodes.length > 0) {
barcodeMap.set(
sid,
detail.barcodes.map(bc => String(bc.barcode || '').trim()).filter(Boolean)
);
}
// 提取图片(有图片标记但实际 URL 需要额外查询)
if (detail.is_images === 'Y') {
imageMap.set(sid, '');
}
}
}
} catch (err) {
ctx.logger.warn('[entry.getPrintData] 查询商品详情失败: %s', err.message);
}
const printData = {
entry_order_code: entryOrderJSON.entry_order_code || '',
order_type: entryOrderJSON.order_type || '',
order_status: entryOrderJSON.order_status || '',
purchase_order_code: entryOrderJSON.purchase_order_code || '',
supplier_name: entryOrderJSON.supplier_name || '',
warehouse_name: entryOrderJSON.warehouse_name || '',
store_name: entryOrderJSON.store_name || '',
logistics_name: entryOrderJSON.logistics_name || '',
express_code: entryOrderJSON.express_code || '',
order_create_time: entryOrderJSON.order_create_time || '',
expect_start_time: entryOrderJSON.expect_start_time || '',
remark: entryOrderJSON.remark || '',
total_order_lines: entryOrderJSON.total_order_lines || 0,
items: items.map(item => ({
items_col1: item.item_code || '',
items_col2: '',
items_col3: (barcodeMap.get(Number(item.stock_id)) || []).join(';') || '',
items_col4: item.count || 0,
items_col5: item.received_quantity || 0,
items_col6: item.inventory_type || '',
items_col7: imageMap.get(Number(item.stock_id)) || '',
})),
};
return this.success('ok', { data: printData, code: 200 });
} catch (error) {
ctx.logger.error('[entry.getPrintData] 获取入库单打印数据失败:', error);
return this.fail(error.message || '获取打印数据失败', { code: 500 });
}
}
/**
* 入库单商品与收货单商品对照视图(system method 包装层)。
* 支持传入多个收货单ID:多个收货单明细先合并为一个整体,再与入库单做一次对照,
* 每个入库明细仅输出一行(含合并收货数量与各收货单来源明细)。
* @param {Object} data 请求体
* @param {number} data.entry_order_id 入库单ID
* @param {number[]} [data.receiving_ids] 收货单ID列表(优先使用)
* @param {number} [data.receiving_id] 单个收货单ID(向后兼容)
* @return {Promise<Object>} 统一 success 包装
*/
async receivingCompare(data = {}) {
const { service } = this;
const { entry_order_id, receiving_id, receiving_ids } = data || {};
const result = await service.systems.storage.entry.receivingCompare({ entry_order_id, receiving_id, receiving_ids });
return this.success('ok', result);
}
/**
* 查询入库单操作日志。warehouseId 由服务端从当前上下文自动注入,前端无需传递。
* @param {Object} data 请求体
* @param {number} data.id 入库单ID
* @param {number} [data.page=1] 页码
* @param {number} [data.pageSize=20] 每页数量
* @return {Promise<Object>} 统一 success 包装
*/
async queryEntryLogs(data = {}) {
const { ctx, service } = this;
const warehouseId = ctx.user?.store_id;
const result = await service.systems.operationLog.queryEntryOrderLogs({
id: data.id,
warehouseId,
page: data.page,
pageSize: data.pageSize,
});
return this.success('ok', result);
}
/**
* 查询入库单已绑定收货单中匹配指定商品的可绑定收货明细列表。
* @param {Object} data 请求体
* @param {number} data.entry_order_id 入库单ID
* @param {number} data.stock_id 商品stock_id
* @return {Promise<Object>} 统一 success 包装
*/
async getReceivingDetailsForBind(data = {}) {
const { service } = this;
const result = await service.systems.storage.entry.getReceivingDetailsForBind(data);
if (result && result.code === 200) {
return this.success('ok', result.data);
}
return this.fail(result?.message || '查询失败', result);
}
/**
* 拉取入库单绑定的收货单中,指定商品的可用容器列表(收货明细)。
* 用于 PDA 上架时选择容器。
* @param {Object} data 请求体
* @param {number} data.entry_order_id 入库单ID
* @param {number} data.stock_id 商品stock_id
* @return {Promise<Object>} 统一 success 包装,data 包含 { list, total }
*/
async containerList(data = {}) {
const { service } = this;
const { entry_order_id, stock_id } = data || {};
const result = await service.systems.storage.entry.containerList({ entry_order_id, stock_id });
if (result && result.code === 200) {
return this.success('ok', result.data);
}
return this.fail(result?.message || '查询失败', result);
}
/**
* 审核入库单(CREATED → PENDING)。
* @param {Object} data 请求体
* @param {number} data.id 入库单ID
* @return {Promise<Object>} 统一 success/fail 包装
*/
async reviewEntry(data = {}) {
const { service } = this;
const result = await service.systems.entryOrder.reviewEntry(data);
if (result && result.success) {
return this.success(result.message, result.data, 200);
}
return this.fail(result?.message || '审核失败', result, 400);
}
/**
* 提交入库单导出任务(复用 list 的筛选语义与排序规则)。
* 导出分为两个 sheet:Sheet1=入库单列表,Sheet2=入库单明细(按入库单分页拉取写入流)。
* @param {Object} data 请求体
* @param {Object} [data.where] 筛选条件(与 list 一致)
* @param {Object} [data.sort] 排序参数
* @return {Promise<Object>} 统一成功包装响应,data 为导出任务信息
*/
async export(data = {}) {
const { service } = this;
const { where, sort } = data || {};
const taskId = this.generateExportTaskId();
const taskPayload = {
task_id: taskId,
status: 'submitted',
progress: 0,
message: '导出任务已提交',
result: null,
error: '',
};
await this.setExportTaskProgress(taskId, taskPayload);
setImmediate(async () => {
try {
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: 'running',
progress: 5,
message: '导出任务执行中',
result: null,
error: '',
});
const result = await service.systems.storage.entry.exportEntryOrders({
where: this.isPlainObject(where) ? { ...where } : {},
sort: this.isPlainObject(sort) ? { ...sort } : {},
onProgress: async progress => {
const safeProgress = this.isPlainObject(progress) ? progress : {};
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: safeProgress.status || 'running',
progress: safeProgress.progress,
message: safeProgress.message || '导出任务执行中',
result: safeProgress.result || null,
error: '',
});
},
});
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: 'success',
progress: 100,
message: '导出任务完成',
result,
error: '',
});
} catch (error) {
const errorMessage = error && error.message ? error.message : `${error}`;
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: 'failed',
progress: 100,
message: '导出任务失败',
result: null,
error: errorMessage,
});
}
});
return this.success('ok', {
...taskPayload,
update_time: Date.now(),
});
}
/**
* 查询入库单导出任务进度。
* @param {Object} data 请求体
* @param {string} [data.task_id] 任务ID(下划线写法)
* @param {string} [data.taskId] 任务ID(驼峰写法)
* @return {Promise<Object>} 统一成功包装响应
*/
async exportTaskProgress(data = {}) {
const taskId = this.normalizeExportTaskId(data);
if (!taskId) {
return this.success('ok', {
task_id: '',
status: 'not_found',
progress: 0,
message: '任务不存在',
result: null,
error: '',
download_url: '',
update_time: Date.now(),
});
}
const cachedTask = await this.getExportTaskProgress(taskId);
if (!cachedTask) {
return this.success('ok', {
task_id: taskId,
status: 'not_found',
progress: 0,
message: '任务不存在',
result: null,
error: '',
download_url: '',
update_time: Date.now(),
});
}
const safeResult = this.isPlainObject(cachedTask.result) ? cachedTask.result : {};
const downloadUrl = String(
safeResult.url
|| safeResult.cdnUrl
|| safeResult.cosUrl
|| safeResult.fileKey
|| ''
);
return this.success('ok', {
task_id: taskId,
...cachedTask,
download_url: downloadUrl,
});
}
/**
* 生成入库单导出任务ID。
* @param {string} [prefix=''] 任务类型前缀(如 'store')
* @return {string} 导出任务ID
*/
generateExportTaskId(prefix = '') {
const storeId = this.ctx?.user?.store_id || 'unknown';
const timestamp = Date.now();
const randomToken = Math.random().toString(36).slice(2, 10);
const typePrefix = prefix ? `${prefix}_` : '';
return `entry_${typePrefix}export_${storeId}_${timestamp}_${randomToken}`;
}
/**
* 归一化入库单导出任务ID。
* @param {Object} data 请求体
* @param {string} [data.task_id] 任务ID(下划线写法)
* @param {string} [data.taskId] 任务ID(驼峰写法)
* @return {string} 归一化后的任务ID
*/
normalizeExportTaskId(data = {}) {
const normalizedData = this.isPlainObject(data) ? data : {};
return String(normalizedData.task_id || normalizedData.taskId || '').trim();
}
/**
* 获取入库单导出任务缓存键。
* @param {string} taskId 任务ID
* @return {string} 缓存键
*/
getExportTaskCacheKey(taskId = '') {
const normalizedTaskId = String(taskId || '').trim();
if (!normalizedTaskId) {
return '';
}
return `${ENTRY_EXPORT_TASK_CACHE_KEY_PREFIX}${normalizedTaskId}`;
}
/**
* 写入入库单导出任务进度缓存。
* @param {string} taskId 任务ID
* @param {Object} payload 任务状态载荷
* @return {Promise<void>} 无返回值
*/
async setExportTaskProgress(taskId = '', payload = {}) {
const cacheKey = this.getExportTaskCacheKey(taskId);
if (!cacheKey || typeof this.app.setCacheAsync !== 'function') {
return;
}
const safePayload = this.isPlainObject(payload) ? payload : {};
const progressPayload = {
task_id: String(taskId || '').trim(),
status: String(safePayload.status || 'submitted').trim() || 'submitted',
progress: Number.isFinite(Number(safePayload.progress)) ? Math.min(100, Math.max(0, Math.round(Number(safePayload.progress)))) : 0,
message: String(safePayload.message || ''),
result: safePayload.result ?? null,
error: String(safePayload.error || ''),
update_time: Date.now(),
};
try {
await this.app.setCacheAsync(cacheKey, progressPayload, ENTRY_EXPORT_TASK_CACHE_TTL_SECONDS);
} catch (error) {
const errorMessage = error && error.message ? error.message : `${error}`;
this.ctx.logger.warn(`[storage.entry.export] 写入导出任务缓存失败: ${errorMessage}`);
}
}
/**
* 读取入库单导出任务进度缓存。
* @param {string} taskId 任务ID
* @return {Promise<Object|null>} 任务缓存
*/
async getExportTaskProgress(taskId = '') {
const cacheKey = this.getExportTaskCacheKey(taskId);
if (!cacheKey || typeof this.app.getCacheAsync !== 'function') {
return null;
}
try {
const cached = await this.app.getCacheAsync(cacheKey);
if (!this.isPlainObject(cached)) {
return null;
}
return cached;
} catch (error) {
const errorMessage = error && error.message ? error.message : `${error}`;
this.ctx.logger.warn(`[storage.entry.export] 读取导出任务缓存失败: ${errorMessage}`);
return null;
}
}
/**
* 提交货主侧入库单导出任务(复用 listStore 的筛选语义与排序规则)。
* 导出分为两个 sheet:Sheet1=入库单列表,Sheet2=入库单明细(按入库单分页拉取写入流)。
* @param {Object} data 请求体
* @param {Object} [data.where] 筛选条件(与 listStore 一致)
* @param {Object} [data.sort] 排序参数
* @return {Promise<Object>} 统一成功包装响应,data 为导出任务信息
*/
async storeExport(data = {}) {
const { service } = this;
const { where, sort } = data || {};
const taskId = this.generateExportTaskId('store');
const taskPayload = {
task_id: taskId,
status: 'submitted',
progress: 0,
message: '货主侧入库单导出任务已提交',
result: null,
error: '',
};
await this.setExportTaskProgress(taskId, taskPayload);
setImmediate(async () => {
try {
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: 'running',
progress: 5,
message: '货主侧入库单导出任务执行中',
result: null,
error: '',
});
const result = await service.systems.storage.entry.exportStoreEntryOrders({
where: this.isPlainObject(where) ? { ...where } : {},
sort: this.isPlainObject(sort) ? { ...sort } : {},
onProgress: async progress => {
const safeProgress = this.isPlainObject(progress) ? progress : {};
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: safeProgress.status || 'running',
progress: safeProgress.progress,
message: safeProgress.message || '货主侧入库单导出任务执行中',
result: safeProgress.result || null,
error: '',
});
},
});
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: 'success',
progress: 100,
message: '货主侧入库单导出任务完成',
result,
error: '',
});
} catch (error) {
const errorMessage = error && error.message ? error.message : `${error}`;
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: 'failed',
progress: 100,
message: '货主侧入库单导出任务失败',
result: null,
error: errorMessage,
});
}
});
return this.success('ok', {
...taskPayload,
update_time: Date.now(),
});
}
/**
* 查询货主侧入库单导出任务进度。
* 复用 exportTaskProgress 的缓存查询逻辑,任务 ID 前缀不同。
* @param {Object} data 请求体
* @param {string} [data.task_id] 任务ID(下划线写法)
* @param {string} [data.taskId] 任务ID(驼峰写法)
* @return {Promise<Object>} 统一成功包装响应
*/
async storeExportTaskProgress(data = {}) {
const taskId = this.normalizeExportTaskId(data);
if (!taskId) {
return this.success('ok', {
task_id: '',
status: 'not_found',
progress: 0,
message: '任务不存在',
result: null,
error: '',
download_url: '',
update_time: Date.now(),
});
}
const cachedTask = await this.getExportTaskProgress(taskId);
if (!cachedTask) {
return this.success('ok', {
task_id: taskId,
status: 'not_found',
progress: 0,
message: '任务不存在',
result: null,
error: '',
download_url: '',
update_time: Date.now(),
});
}
const safeResult = this.isPlainObject(cachedTask.result) ? cachedTask.result : {};
const downloadUrl = String(
safeResult.url
|| safeResult.cdnUrl
|| safeResult.cosUrl
|| safeResult.fileKey
|| ''
);
return this.success('ok', {
task_id: taskId,
...cachedTask,
download_url: downloadUrl,
});
}
}
module.exports = entryService;