Compare commits

...

5 Commits

Author SHA1 Message Date
liufumingren
3e813c4975 fix: 将 storage.report 模块迁移至 stock.report,修正语义错误
库存报表属于 stock(商品库存)域而非 storage(库位存储)域。

变更:
- systemMethods/storage/report.js → systemMethods/stock/report.js
- 类名 StorageReportMethodService → StockReportMethodService
- 缓存键 storage_report_export_ → stock_report_export_
- 日志前缀 [storage.report] → [stock.report]
- methods/system.json: module + 5 method 名同步更新
- methods/changes/system.json: 追加迁移记录
- systems/storage/entry.js: 注释引用修正

旧文件直接删除,不保留兼容(旧 method 名为语义错误)。
2026-07-17 00:30:54 +08:00
liufumingren
391ab87112 fix(order_express): 包材批量绑定适配 current+dispatch 双表查询
修复波次团购包材批量绑定只查 current 表导致 dispatch 表订单遗漏的问题:
- bindExpressPackageMaterialByWaybill: 波次检测改为 current→dispatch 双表遍历
- _bindWavePackageMaterialByBusinessKey: 波次订单查询改为双表合并去重
- _getStoreName / _getWaveSysLogisticsName: 货主/物流名查询改为双表遍历
- _upsertPackageMaterialItemRelation: items_hash 查询改为双表遍历
- _updateSingleOrderWeight: items_weight 读取改为双表遍历
2026-07-16 20:19:03 +08:00
liufumingren
16d5f18fa1 feat(openapi): interface_type_id=2 强制合约注入 + 全链路 store_id 防护
核心改动:
- openapi.js: 新增 resolveOpenapiContract 强制合约解析(required:true JOIN),
  dispatchOpenapiMethod 统一注入上下文(setInfo)
- 5个 openapiMethods: 移除重复 resolveAppInfo, 统一使用 this.getInfo()
- deliveryorder/entryorder/stockout: findByPk(itemId) 后增加 store_id 一致性校验

安全修复:
- 修复 itemId 路径跨货主越权漏洞(FindByPk 无 store_id 过滤)
- deliveryorder/inventory/singleitem 查询补全 store_id 过滤
- 合约缺失返回 403 而非穿透业务层

测试覆盖: 9方法×3层防护(合约/注入/过滤)全部通过集成测试
2026-07-15 00:10:40 +08:00
liufumingren
fddd142427 fix: custom_barcode 唯一约束改为仓库级别,修复 batchUpdateSpaceInfo 等条码检查跨仓库问题 2026-07-10 18:10:11 +08:00
liufumingren
a1f5c5d532 fix(storeWarehouse): list 查询使用 OR 两边匹配,兼容新旧签约数据
- serializeRelation: 根据 currentSubject.id 匹配 store_id/warehouse_id 判定对方主体

- listForStore/listForWarehouse: 使用 store_id/warehouse_id OR 查询替代 buildListWhereByStoreId

- remask/use_status: 基于实际所在侧判定而非 isWarehouse 角色

- 修复仓库用户看不到签约货主方信息的问题
2026-07-09 11:54:53 +08:00
21 changed files with 2638 additions and 721 deletions

View File

@ -209,7 +209,7 @@ module.exports = app => {
unique: true,
fields: [ 'warehouse_id', 'space_code', 'deleted_at' ],
},
{ name: 'uk_custom_barcode', unique: true, fields: [ 'custom_barcode' ] },
{ name: 'uk_warehouse_custom_barcode', unique: true, fields: [ 'warehouse_id', 'custom_barcode', 'deleted_at' ] },
{ fields: [ 'warehouse_id', 'zone_id' ] },
{ fields: [ 'location_type_id' ] },
{ fields: [ 'space_status' ] },

View File

@ -41,14 +41,71 @@ class OpenapiService extends Service {
return methodService || null;
}
/**
* 解析 OpenAPI 合约信息(interface_type_id=2 必须绑定有效合约)。
* 查询 ApiApp 并强制关联 StoreWarehouse,校验 store_id 必须存在。
* @param {string} appKey 开放接口 app_key。
* @return {Promise<Object>} 包含 storeId、warehouseId、appKey、customerId、warehouseCode 的信息对象。
*/
async resolveOpenapiContract(appKey) {
const { ctx, app } = this;
const normalizedAppKey = String(appKey || '').trim();
if (!normalizedAppKey) {
throw new Error('app_key 缺失');
}
const appConfig = await ctx.model.ApiApp.findOne({
attributes: [
'id',
'warehouse_id',
'qimen_warehouse_code',
[ app.Sequelize.col('contract.store_id'), 'store_id' ],
],
where: {
self_app_key: normalizedAppKey,
is_enabled: 1,
},
include: [
{
model: ctx.model.StoreWarehouse,
as: 'contract',
attributes: [],
required: true,
},
],
raw: true,
});
if (!appConfig || !appConfig.warehouse_id) {
throw new Error(`无法解析仓库信息,请检查 app_key: ${normalizedAppKey}`);
}
if (!appConfig.store_id) {
throw new Error(`未找到 app_key 对应的货主合约关系: ${normalizedAppKey}`);
}
const warehouseId = appConfig.warehouse_id;
return {
storeId: appConfig.store_id,
warehouseId,
appKey: normalizedAppKey,
customerId: null,
warehouseCode: appConfig.qimen_warehouse_code || String(warehouseId),
};
}
/**
* 分发 openapi method 到 openapiMethods 目录。
* 分发前统一注入合约上下文(storeId/warehouseId/appKey 等),
* 确保所有下游方法可通过 this.getInfo() 获取货主范围信息。
* @param {string} methodName method 名称。
* @param {Object} body 请求体。
* @param {Object} query 请求 query。
* @param {Object} contractInfo 合约上下文信息。
* @return {Promise<Object>} method 执行结果。
*/
async dispatchOpenapiMethod(methodName, body, query) {
async dispatchOpenapiMethod(methodName, body, query, contractInfo) {
const { servicePath, actionName } = this.resolveOpenapiMethod(methodName);
const methodService = this.getOpenapiMethodService(servicePath);
@ -62,6 +119,17 @@ class OpenapiService extends Service {
};
}
// 统一注入合约上下文到方法服务实例
if (contractInfo && typeof methodService.setInfo === 'function') {
methodService.setInfo(
contractInfo.storeId,
contractInfo.warehouseId,
contractInfo.appKey,
contractInfo.customerId,
contractInfo.warehouseCode
);
}
const methodResult = await methodService[actionName]({
body,
query,
@ -241,10 +309,26 @@ class OpenapiService extends Service {
};
}
return await this.dispatchOpenapiMethod(query.method, body, {
// interface_type_id=2(OPENAPI)必须解析合约并注入货主信息
let contractInfo = null;
try {
contractInfo = await this.resolveOpenapiContract(appKey);
} catch (error) {
return {
ok: false,
httpStatus: 403,
code: 403,
message: `合约校验失败: ${error.message}`,
data: null,
};
}
const queryWithAppKey = {
...query,
app_key: appConfig.appKey,
});
};
return await this.dispatchOpenapiMethod(query.method, body, queryWithAppKey, contractInfo);
}
}

View File

@ -3,62 +3,16 @@
const MainService = require('../main');
class OpenapiDeliveryorderService extends MainService {
/**
* 通过 app_key 解析仓库与货主信息。
* 查询 ApiApp 并关联 StoreWarehouse 以获取 storeId、warehouseId。
* @param {string} appKey 开放接口 app_key。
* @return {Promise<Object>} 包含 storeId、warehouseId、appKey、customerId、warehouseCode 的信息对象。
*/
async resolveAppInfo(appKey) {
const { ctx, app } = this;
const normalizedAppKey = String(appKey || '').trim();
if (!normalizedAppKey) {
throw new Error('app_key 缺失');
}
const appConfig = await ctx.model.ApiApp.findOne({
attributes: [
'id',
'warehouse_id',
[ app.Sequelize.col('contract.store_id'), 'store_id' ],
],
where: {
self_app_key: normalizedAppKey,
is_enabled: 1,
},
include: [
{
model: ctx.model.StoreWarehouse,
as: 'contract',
attributes: [],
required: false,
},
],
raw: true,
});
if (!appConfig || !appConfig.warehouse_id) {
throw new Error(`无法解析仓库信息,请检查 app_key: ${normalizedAppKey}`);
}
return {
storeId: appConfig.store_id || null,
warehouseId: appConfig.warehouse_id,
appKey: normalizedAppKey,
customerId: null,
warehouseCode: '',
};
}
/**
* 查询发货单。
* 上下文(storeId/warehouseId/appKey)已由 dispatchOpenapiMethod 统一注入。
* @param {Object} payload 调用参数。
* @param {Object} payload.body 请求体数据,需包含 deliveryOrderCode。
* @param {Object} payload.query 请求 query 数据,需包含 app_key。
* @param {Object} payload.query 请求 query 数据。
* @return {Promise<Object>} 查询结果,成功时返回订单详情,失败时返回错误信息。
*/
async query(payload = {}) {
const { body = {}, query = {} } = payload;
const { body = {} } = payload;
const { deliveryOrderCode } = body;
if (!deliveryOrderCode) {
@ -66,10 +20,13 @@ class OpenapiDeliveryorderService extends MainService {
}
try {
const info = await this.resolveAppInfo(query.app_key);
const DeliveryModel = await this.ctx.model.OrderDeliveryFactory.getCurrentModel(info.warehouseId);
const { storeId, warehouseId } = this.getInfo();
const DeliveryModel = await this.ctx.model.OrderDeliveryFactory.getCurrentModel(warehouseId);
const order = await DeliveryModel.findOne({
where: { delivery_order_code: deliveryOrderCode },
where: {
delivery_order_code: deliveryOrderCode,
store_id: storeId,
},
});
if (order) {
@ -101,13 +58,14 @@ class OpenapiDeliveryorderService extends MainService {
/**
* 创建发货单。
* 上下文(storeId/warehouseId/appKey)已由 dispatchOpenapiMethod 统一注入。
* @param {Object} payload 调用参数。
* @param {Object} payload.body 请求体数据,需包含 deliveryOrder 与 orderLines。
* @param {Object} payload.query 请求 query 数据,需包含 app_key。
* @param {Object} payload.query 请求 query 数据。
* @return {Promise<Object>} 创建结果,成功时返回订单ID等,失败时返回错误信息。
*/
async create(payload = {}) {
const { body = {}, query = {} } = payload;
const { body = {} } = payload;
const { deliveryOrder, orderLines } = body;
if (!deliveryOrder || !deliveryOrder.deliveryOrderCode) {
@ -118,15 +76,6 @@ class OpenapiDeliveryorderService extends MainService {
}
try {
const info = await this.resolveAppInfo(query.app_key);
this.setInfo(
info.storeId,
info.warehouseId,
info.appKey,
info.customerId,
info.warehouseCode
);
const data = {
request: {
deliveryOrder,
@ -144,7 +93,7 @@ class OpenapiDeliveryorderService extends MainService {
return this.success(res.message, {
createTime: this.app.formatDate(new Date()),
deliveryOrderId: res.data.orderId,
warehouseCode: info.warehouseCode,
warehouseCode: this.warehouseCode,
logisticsCode: '',
});
}

View File

@ -8,67 +8,17 @@ const MainService = require('../main');
*/
class OpenapiEntryorderService extends MainService {
/**
* 通过 app_key 解析仓库与货主信息。
* 查询 ApiApp 并关联 StoreWarehouse 以获取 storeId、warehouseId。
* warehouseCode 优先使用 qimen_warehouse_code,为空时回退使用 warehouseId。
* @param {string} appKey 开放接口 app_key。
* @return {Promise<Object>} 包含 storeId、warehouseId、appKey、customerId、warehouseCode 的信息对象。
*/
async resolveAppInfo(appKey) {
const { ctx, app } = this;
const normalizedAppKey = String(appKey || '').trim();
if (!normalizedAppKey) {
throw new Error('app_key 缺失');
}
const appConfig = await ctx.model.ApiApp.findOne({
attributes: [
'id',
'warehouse_id',
'qimen_warehouse_code',
[ app.Sequelize.col('contract.store_id'), 'store_id' ],
],
where: {
self_app_key: normalizedAppKey,
is_enabled: 1,
},
include: [
{
model: ctx.model.StoreWarehouse,
as: 'contract',
attributes: [],
required: false,
},
],
raw: true,
});
if (!appConfig || !appConfig.warehouse_id) {
throw new Error(`无法解析仓库信息,请检查 app_key: ${normalizedAppKey}`);
}
const warehouseId = appConfig.warehouse_id;
return {
storeId: appConfig.store_id || null,
warehouseId,
appKey: normalizedAppKey,
customerId: null,
warehouseCode: appConfig.qimen_warehouse_code || String(warehouseId),
};
}
/**
* 创建入库单。
* 上下文(storeId/warehouseId/appKey/warehouseCode)已由 dispatchOpenapiMethod 统一注入。
* 接收外部系统的入库单数据,校验后通过底层 entryOrder 服务完成入库单创建。
* @param {Object} payload 调用参数。
* @param {Object} payload.body 请求体数据,包含 entryOrder(入库单信息)和 orderLines(明细行)。
* @param {Object} payload.query 请求 query 数据,需包含 app_key。
* @param {Object} payload.query 请求 query 数据。
* @return {Promise<Object>} 创建结果,成功时返回 entryOrderId、entryOrderCode、status 和 createTime。
*/
async create(payload = {}) {
const { body = {}, query = {} } = payload;
const { body = {} } = payload;
const { entryOrder, orderLines } = body;
if (!entryOrder || !entryOrder.entryOrderCode) {
@ -101,15 +51,6 @@ class OpenapiEntryorderService extends MainService {
};
try {
const info = await this.resolveAppInfo(query.app_key);
this.setInfo(
info.storeId,
info.warehouseId,
info.appKey,
info.customerId,
info.warehouseCode
);
const data = {
request: {
entryOrder: mappedEntryOrder,
@ -140,14 +81,15 @@ class OpenapiEntryorderService extends MainService {
/**
* 查询入库单。
* 上下文(storeId/warehouseId)已由 dispatchOpenapiMethod 统一注入。
* 根据入库单号查询入库单详情,包括基本信息与商品明细。
* @param {Object} payload 调用参数。
* @param {Object} payload.body 请求体数据,需包含 entryOrderCode(入库单号)。
* @param {Object} payload.query 请求 query 数据,需包含 app_key。
* @param {Object} payload.query 请求 query 数据。
* @return {Promise<Object>} 查询结果,成功时返回入库单详情。
*/
async query(payload = {}) {
const { body = {}, query = {} } = payload;
const { body = {} } = payload;
const { entryOrderCode } = body;
if (!entryOrderCode) {
@ -155,11 +97,11 @@ class OpenapiEntryorderService extends MainService {
}
try {
const info = await this.resolveAppInfo(query.app_key);
const { storeId, warehouseId, warehouseCode } = this.getInfo();
const order = await this.ctx.service.systems.entryOrder.findByOrderCode(
entryOrderCode,
info.warehouseId,
info.storeId
warehouseId,
storeId
);
if (!order) {
@ -189,7 +131,7 @@ class OpenapiEntryorderService extends MainService {
createTime: order.created_at || '',
operateTime: order.updated_at || '',
operatorName: order.operator_name || '',
warehouseCode: order.warehouse_code || info.warehouseCode,
warehouseCode: order.warehouse_code || warehouseCode,
ownerCode: order.store_code || '',
totalOrderLines: order.total_order_lines || 0,
orderLines,

View File

@ -8,82 +8,33 @@ const MainService = require('../main');
*/
class OpenapiInventoryService extends MainService {
/**
* 通过 app_key 解析仓库与货主信息。
* 查询 ApiApp 并关联 StoreWarehouse 以获取 storeId、warehouseId。
* warehouseCode 优先使用 qimen_warehouse_code,为空时回退使用 warehouseId;
* ownerCode 优先使用 store_id,为空时回退使用空字符串。
* @param {string} appKey 开放接口 app_key。
* @return {Promise<Object>} 包含 storeId、warehouseId、appKey、customerId、warehouseCode、ownerCode 的信息对象。
*/
async resolveAppInfo(appKey) {
const { ctx, app } = this;
const normalizedAppKey = String(appKey || '').trim();
if (!normalizedAppKey) {
throw new Error('app_key 缺失');
}
const appConfig = await ctx.model.ApiApp.findOne({
attributes: [
'id',
'warehouse_id',
'qimen_warehouse_code',
[ app.Sequelize.col('contract.store_id'), 'store_id' ],
],
where: {
self_app_key: normalizedAppKey,
is_enabled: 1,
},
include: [
{
model: ctx.model.StoreWarehouse,
as: 'contract',
attributes: [],
required: false,
},
],
raw: true,
});
if (!appConfig || !appConfig.warehouse_id) {
throw new Error(`无法解析仓库信息,请检查 app_key: ${normalizedAppKey}`);
}
const warehouseId = appConfig.warehouse_id;
const storeId = appConfig.store_id || null;
return {
storeId,
warehouseId,
appKey: normalizedAppKey,
customerId: null,
warehouseCode: appConfig.qimen_warehouse_code || String(warehouseId),
ownerCode: storeId ? String(storeId) : '',
};
}
/**
* 库存查询。
* 上下文(storeId)已由 dispatchOpenapiMethod 统一注入,查询结果按货主范围校验。
* 根据商品 ID 列表查询对应的库存信息,包括总库存、锁定量和可用量。
* @param {Object} payload 调用参数。
* @param {Object} payload.body 请求体数据,需包含 itemIds(商品 ID 数组)。
* @param {Object} payload.query 请求 query 数据,需包含 app_key。
* @param {Object} payload.query 请求 query 数据。
* @return {Promise<Object>} 查询结果,成功时返回 items 数组。
*/
async query(payload = {}) {
const { body = {}, query = {} } = payload;
const { body = {} } = payload;
const { itemIds } = body;
if (!Array.isArray(itemIds) || itemIds.length === 0) {
return this.fail('itemIds 参数缺失或为空');
}
await this.resolveAppInfo(query.app_key);
const { storeId } = this.getInfo();
const items = [];
for (const itemId of itemIds) {
const result = await this.ctx.service.systems.stockStore.getItemStorages(itemId);
if (result.success && result.data) {
// 按货主范围过滤:仅返回属于当前合约货主的库存
if (Number(result.data.storage.storeId) !== Number(storeId)) {
continue;
}
items.push({
itemId: result.data.stock.id,
itemCode: result.data.stock.item_code,

View File

@ -3,59 +3,13 @@
const MainService = require('../main');
class OpenapiOrderService extends MainService {
/**
* 通过 app_key 解析仓库与货主信息。
* 查询 ApiApp 并关联 StoreWarehouse 以获取 storeId、warehouseId。
* @param {string} appKey 开放接口 app_key。
* @return {Promise<Object>} 包含 storeId、warehouseId、appKey、customerId、warehouseCode 的信息对象。
*/
async resolveAppInfo(appKey) {
const { ctx, app } = this;
const normalizedAppKey = String(appKey || '').trim();
if (!normalizedAppKey) {
throw new Error('app_key 缺失');
}
const appConfig = await ctx.model.ApiApp.findOne({
attributes: [
'id',
'warehouse_id',
[ app.Sequelize.col('contract.store_id'), 'store_id' ],
],
where: {
self_app_key: normalizedAppKey,
is_enabled: 1,
},
include: [
{
model: ctx.model.StoreWarehouse,
as: 'contract',
attributes: [],
required: false,
},
],
raw: true,
});
if (!appConfig || !appConfig.warehouse_id) {
throw new Error(`无法解析仓库信息,请检查 app_key: ${normalizedAppKey}`);
}
return {
storeId: appConfig.store_id || null,
warehouseId: appConfig.warehouse_id,
appKey: normalizedAppKey,
customerId: null,
warehouseCode: '',
};
}
/**
* 取消发货单。
* 上下文(storeId/warehouseId/appKey)已由 dispatchOpenapiMethod 统一注入。
* 当前仅支持出库单类型(JYCK/HHCK/BFCK → ORDER),非出库单类型返回不支持。
* @param {Object} payload 调用参数。
* @param {Object} payload.body 请求体数据,包含 orderCode、orderType。
* @param {Object} payload.query 请求 query 数据,包含 app_key。
* @param {Object} payload.query 请求 query 数据。
* @return {Promise<Object>} 取消结果,成功时返回成功消息,失败时返回错误信息。
*/
async cancel(payload = {}) {
@ -76,16 +30,16 @@ class OpenapiOrderService extends MainService {
}
try {
const info = await this.resolveAppInfo(query.app_key);
const { storeId, warehouseId, appKey: ctxAppKey } = this.getInfo();
const DeliveryModel = await ctx.model.OrderDeliveryFactory.getCurrentModel(info.warehouseId);
const DeliveryModel = await ctx.model.OrderDeliveryFactory.getCurrentModel(warehouseId);
const transaction = await ctx.model.transaction();
try {
const existingOrder = await DeliveryModel.findOne({
where: {
delivery_order_code: normalizedOrderCode,
warehouse_id: info.warehouseId,
store_id: info.storeId,
warehouse_id: warehouseId,
store_id: storeId,
},
transaction,
lock: transaction.LOCK.UPDATE,
@ -123,7 +77,7 @@ class OpenapiOrderService extends MainService {
// 释放储位分配锁定库存
await this.releaseStockLockForCancel({
orderId: existingOrder.id,
warehouseId: info.warehouseId,
warehouseId,
transaction,
});
@ -132,7 +86,7 @@ class OpenapiOrderService extends MainService {
// 写入取消操作日志(不影响主流程)
try {
if (this.ctx.model && this.ctx.model.OperationLog) {
const appKey = String(query.app_key || '').trim();
const appKey = String(query.app_key || ctxAppKey || '').trim();
await this.ctx.model.OperationLog.create({
business_type: 'order',
business_id: String(existingOrder.id),
@ -140,7 +94,7 @@ class OpenapiOrderService extends MainService {
operator_id: null,
operator_name: appKey ? `openapi:${appKey}` : 'openapi',
external_log_type: 'NONE',
warehouse_id: info.warehouseId || null,
warehouse_id: warehouseId || null,
platform_code: appKey || 'SYSTEM',
message: 'OpenAPI 取消订单',
});
@ -153,7 +107,7 @@ class OpenapiOrderService extends MainService {
try {
const callbackService = this.ctx.service.openapi && this.ctx.service.openapi.callback;
if (callbackService && typeof callbackService.sendByAppKey === 'function') {
const appKey = String(query.app_key || '').trim();
const appKey = String(query.app_key || ctxAppKey || '').trim();
if (appKey) {
callbackService.sendByAppKey({
appKey,

View File

@ -8,70 +8,17 @@ const MainService = require('../main');
*/
class OpenapiSingleitemService extends MainService {
/**
* 通过 app_key 解析仓库与货主信息。
* 查询 ApiApp 并关联 StoreWarehouse 以获取 storeId、warehouseId。
* warehouseCode 优先使用 qimen_warehouse_code,为空时回退使用 warehouseId;
* ownerCode 优先使用 store_id,为空时回退使用空字符串。
* @param {string} appKey 开放接口 app_key。
* @return {Promise<Object>} 包含 storeId、warehouseId、appKey、customerId、warehouseCode、ownerCode 的信息对象。
*/
async resolveAppInfo(appKey) {
const { ctx, app } = this;
const normalizedAppKey = String(appKey || '').trim();
if (!normalizedAppKey) {
throw new Error('app_key 缺失');
}
const appConfig = await ctx.model.ApiApp.findOne({
attributes: [
'id',
'warehouse_id',
'qimen_warehouse_code',
[ app.Sequelize.col('contract.store_id'), 'store_id' ],
],
where: {
self_app_key: normalizedAppKey,
is_enabled: 1,
},
include: [
{
model: ctx.model.StoreWarehouse,
as: 'contract',
attributes: [],
required: false,
},
],
raw: true,
});
if (!appConfig || !appConfig.warehouse_id) {
throw new Error(`无法解析仓库信息,请检查 app_key: ${normalizedAppKey}`);
}
const warehouseId = appConfig.warehouse_id;
const storeId = appConfig.store_id || null;
return {
storeId,
warehouseId,
appKey: normalizedAppKey,
customerId: null,
warehouseCode: appConfig.qimen_warehouse_code || String(warehouseId),
ownerCode: storeId ? String(storeId) : '',
};
}
/**
* 同步(新增或更新)单品信息。
* 上下文(storeId/warehouseId/appKey/warehouseCode)已由 dispatchOpenapiMethod 统一注入。
* 将外部系统的商品数据写入 StockStore,并自动同步到库存表。
* @param {Object} payload 调用参数。
* @param {Object} payload.body 请求体数据,仅需包含 item;warehouseCode 和 ownerCode 由 app_key 自动解析,调用方不得传入。
* @param {Object} payload.query 请求 query 数据,需包含 app_key。
* @param {Object} payload.query 请求 query 数据。
* @return {Promise<Object>} 同步结果,成功时返回 itemId。
*/
async synchronize(payload = {}) {
const { body = {}, query = {} } = payload;
const { body = {} } = payload;
const { item } = body;
if (!item || !item.itemCode) {
@ -79,7 +26,8 @@ class OpenapiSingleitemService extends MainService {
}
try {
const { storeId, warehouseId, appKey, warehouseCode, ownerCode } = await this.resolveAppInfo(query.app_key);
const { storeId, warehouseId, appKey, warehouseCode } = this.getInfo();
const ownerCode = storeId ? String(storeId) : '';
const requestData = {
warehouseCode: warehouseCode || '',
@ -103,14 +51,15 @@ class OpenapiSingleitemService extends MainService {
/**
* 查询单品详情。
* 上下文(storeId)已由 dispatchOpenapiMethod 统一注入,查询按货主范围过滤。
* 根据 itemId 查询 StockStore 记录并转换为 OpenAPI 统一格式。
* @param {Object} payload 调用参数。
* @param {Object} payload.body 请求体数据,需包含 itemId。
* @param {Object} payload.query 请求 query 数据,需包含 app_key。
* @param {Object} payload.query 请求 query 数据。
* @return {Promise<Object>} 查询结果,成功时返回商品详情。
*/
async query(payload = {}) {
const { body = {}, query = {} } = payload;
const { body = {} } = payload;
const { itemId } = body;
if (!itemId) {
@ -118,10 +67,14 @@ class OpenapiSingleitemService extends MainService {
}
try {
// 验证 app_key 有效性
await this.resolveAppInfo(query.app_key);
const { storeId } = this.getInfo();
const row = await this.ctx.model.StockStore.findByPk(itemId);
const row = await this.ctx.model.StockStore.findOne({
where: {
id: itemId,
store_id: storeId,
},
});
if (!row) {
return this.fail(`商品不存在,itemId: ${itemId}`);
}

View File

@ -46,6 +46,13 @@ class stockoutServer extends MainService {
for (let i = 0; i < orderLine.length; i++) {
const line = orderLine[i];
const wmsStock = await app.model.StockStore.findByPk(line.itemId);
// 校验 StockStore 记录的 store_id 与当前上下文一致,防止跨货主越权
if (wmsStock && Number(wmsStock.store_id) !== Number(this.storeId)) {
errors.push(
`SKU${line.itemId}商品《${line.itemName}》编码《${line.itemCode}》\n未同步推送到仓库`
);
continue;
}
if (!wmsStock) {
errors.push(
`SKU${line.itemId}商品《${line.itemName}》编码《${line.itemCode}》\n未同步推送到仓库`

View File

@ -0,0 +1,508 @@
'use strict';
const MainService = require('../../main');
const STOCK_REPORT_EXPORT_TASK_CACHE_KEY_PREFIX = 'stock_report_export_task_';
const STOCK_REPORT_EXPORT_TASK_CACHE_TTL_SECONDS = 1800;
/**
* 系统方法层:stock.report(库存流水报表接口包装层)。
*/
class StockReportMethodService extends MainService {
constructor(ctx) {
super(ctx);
const _noNeedLogin = '';
const _noNeedRight = 'search,searchStore,export,exportStore,exportTaskProgress';
const _noNeedLog = 'search,searchStore,export,exportStore,exportTaskProgress';
const _noNeedAuth = 'search,searchStore,export,exportStore,exportTaskProgress';
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
}
/**
* 查询库存流水统计报表。
* @param {Object} data 请求体
* @param {Object} [data.where] 查询条件
* @param {Object} [data.sort] 排序参数
* @param {string} [data.sort.sortField] 排序字段(兼容:sort_field)
* @param {string} [data.sort.sortOrder] 排序顺序(兼容:sort_order)
* @param {string|Date} [data.where.start_time] 开始时间
* @param {string|Date} [data.where.end_time] 结束时间
* @param {boolean|string|number} [data.where.by_space=false] 是否按库位返回
* @param {Array<number|string>} [data.where.store_ids] 货主ID列表
* @param {number|number[]} [data.where.stock_id] 商品库存ID(单数)
* @param {number[]} [data.where.stock_ids] 商品库存ID列表(复数)
* @param {string} [data.where.keyword] 商品关键字(按 item_code/item_name/goods_code/barcode 模糊匹配)
* @return {Promise<Object>} 统一 success 包装
*/
async search(data = {}) {
const { service } = this;
const { whereValue = {} } = this.prepareWhereContext(data);
const {
start_time: startTime,
end_time: endTime,
by_space: bySpace,
store_ids: storeIds,
stock_id: stockIdRaw,
stock_ids: stockIdsRaw,
keyword,
sort_field: whereSortField,
sortField: whereSortFieldCamel,
sort_order: whereSortOrder,
sortOrder: whereSortOrderCamel,
} = whereValue;
// 兼容 stock_id(单数)和 stock_ids(数组)
const stockIds = stockIdsRaw !== undefined
? stockIdsRaw
: (stockIdRaw !== undefined ? [ stockIdRaw ] : null);
const { sort = {} } = data;
const {
sort_field: sortFieldSnake,
sortField: sortFieldCamel,
sort_order: sortOrderSnake,
sortOrder: sortOrderCamel,
} = sort || {};
const result = await service.systems.storage.report.search(startTime, endTime, bySpace, storeIds, {
sortField: sortFieldCamel || sortFieldSnake || whereSortFieldCamel || whereSortField,
sortOrder: sortOrderCamel || sortOrderSnake || whereSortOrderCamel || whereSortOrder,
}, 'warehouse', stockIds, keyword);
return this.success('ok', result);
}
/**
* 货主侧库存流水统计报表。
* 以货主维度查询库存流水,只关注商品入库和订单出库,不涉及库位维度。
* @param {Object} data 请求体
* @param {Object} [data.where] 查询条件
* @param {Object} [data.sort] 排序参数
* @param {string} [data.sort.sortField] 排序字段(兼容:sort_field)
* @param {string} [data.sort.sortOrder] 排序顺序(兼容:sort_order)
* @param {string|Date} [data.where.start_time] 开始时间
* @param {string|Date} [data.where.end_time] 结束时间
* @param {Array<number|string>} [data.where.warehouse_ids] 仓库ID列表(可选过滤)
* @param {number|number[]} [data.where.stock_id] 商品库存ID(单数)
* @param {number[]} [data.where.stock_ids] 商品库存ID列表(复数)
* @param {string} [data.where.keyword] 商品关键字(按 item_code/item_name/goods_code/barcode 模糊匹配)
* @return {Promise<Object>} 统一 success 包装
*/
async searchStore(data = {}) {
const { service } = this;
const { whereValue = {} } = this.prepareWhereContext(data);
const {
start_time: startTime,
end_time: endTime,
warehouse_ids: warehouseIdsRaw,
warehouse_id: warehouseIdRaw,
stock_id: stockIdRaw,
stock_ids: stockIdsRaw,
keyword,
sort_field: whereSortField,
sortField: whereSortFieldCamel,
sort_order: whereSortOrder,
sortOrder: whereSortOrderCamel,
} = whereValue;
// 兼容 warehouse_id(单数)和 warehouse_ids(数组)
const warehouseIds = warehouseIdsRaw !== undefined
? warehouseIdsRaw
: (warehouseIdRaw !== undefined ? [ warehouseIdRaw ] : undefined);
// 兼容 stock_id(单数)和 stock_ids(数组)
const stockIds = stockIdsRaw !== undefined
? stockIdsRaw
: (stockIdRaw !== undefined ? [ stockIdRaw ] : null);
const { sort = {} } = data;
const {
sort_field: sortFieldSnake,
sortField: sortFieldCamel,
sort_order: sortOrderSnake,
sortOrder: sortOrderCamel,
} = sort || {};
// 货主侧不涉及库位维度(by_space 固定为 false)
const result = await service.systems.storage.report.search(
startTime,
endTime,
false,
warehouseIds, // store 模式下 storeIds 参数实际承载 warehouse_id 过滤
{
sortField: sortFieldCamel || sortFieldSnake || whereSortFieldCamel || whereSortField,
sortOrder: sortOrderCamel || sortOrderSnake || whereSortOrderCamel || whereSortOrder,
},
'store',
stockIds,
keyword
);
return this.success('ok', result);
}
/**
* 货主侧提交库存报表导出任务。
* 与 export 逻辑一致但使用货主维度,只关注商品入库和订单出库,不涉及库位维度。
* 异步执行,立即返回任务ID。
* @param {Object} data 请求体
* @param {Object} [data.where] 查询条件
* @param {Object} [data.sort] 排序参数
* @param {string} [data.sort.sortField] 排序字段(兼容:sort_field)
* @param {string} [data.sort.sortOrder] 排序顺序(兼容:sort_order)
* @param {string|Date} [data.where.start_time] 开始时间
* @param {string|Date} [data.where.end_time] 结束时间
* @param {Array<number|string>} [data.where.warehouse_ids] 仓库ID列表
* @param {number|number[]} [data.where.stock_id] 商品库存ID(单数)
* @param {number[]} [data.where.stock_ids] 商品库存ID列表(复数)
* @param {string} [data.where.keyword] 商品关键字(模糊匹配)
* @param {string} [data.export_mode] 导出模式:'item' 导出含锁定类型的全部变更记录
* @param {string} [data.exportMode] 导出模式(驼峰写法,同 export_mode)
* @return {Promise<Object>} 统一 success 包装(返回任务ID)
*/
async exportStore(data = {}) {
const { service } = this;
const { whereValue = {} } = this.prepareWhereContext(data);
const {
start_time: startTime,
end_time: endTime,
warehouse_ids: warehouseIdsRaw,
warehouse_id: warehouseIdRaw,
stock_id: stockIdRaw,
stock_ids: stockIdsRaw,
keyword,
sort_field: whereSortField,
sortField: whereSortFieldCamel,
sort_order: whereSortOrder,
sortOrder: whereSortOrderCamel,
} = whereValue;
// 兼容 warehouse_id(单数)和 warehouse_ids(数组)
const warehouseIds = warehouseIdsRaw !== undefined
? warehouseIdsRaw
: (warehouseIdRaw !== undefined ? [ warehouseIdRaw ] : undefined);
// 兼容 stock_id(单数)和 stock_ids(数组)
const stockIds = stockIdsRaw !== undefined
? stockIdsRaw
: (stockIdRaw !== undefined ? [ stockIdRaw ] : null);
const { sort = {} } = data;
const {
sort_field: sortFieldSnake,
sortField: sortFieldCamel,
sort_order: sortOrderSnake,
sortOrder: sortOrderCamel,
} = sort || {};
const exportMode = String(data.export_mode || data.exportMode || '').trim();
const taskId = this.generateExportTaskId();
const taskPayload = {
task_id: taskId,
status: 'submitted',
progress: 0,
message: '导出任务已提交',
result: null,
error: '',
};
await this.setExportTaskProgress(taskId, taskPayload);
const sortOption = {
sortField: sortFieldCamel || sortFieldSnake || whereSortFieldCamel || whereSortField,
sortOrder: sortOrderCamel || sortOrderSnake || whereSortOrderCamel || whereSortOrder,
};
setImmediate(async () => {
try {
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: 'running',
progress: 10,
message: '导出任务执行中',
result: null,
error: '',
});
const result = await service.systems.storage.report.export(
startTime, endTime, false, warehouseIds,
sortOption, exportMode, 'store', stockIds, keyword
);
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 {Object} [data.where] 查询条件
* @param {Object} [data.sort] 排序参数
* @param {string} [data.sort.sortField] 排序字段(兼容:sort_field)
* @param {string} [data.sort.sortOrder] 排序顺序(兼容:sort_order)
* @param {string|Date} [data.where.start_time] 开始时间
* @param {string|Date} [data.where.end_time] 结束时间
* @param {boolean|string|number} [data.where.by_space=false] 是否按库位返回
* @param {Array<number|string>} [data.where.store_ids] 货主ID列表
* @param {number|number[]} [data.where.stock_id] 商品库存ID(单数)
* @param {number[]} [data.where.stock_ids] 商品库存ID列表(复数)
* @param {string} [data.where.keyword] 商品关键字(模糊匹配)
* @param {string} [data.export_mode] 导出模式:'item' 导出含锁定类型的全部变更记录,不传则排除锁定类型
* @param {string} [data.exportMode] 导出模式(驼峰写法,同 export_mode)
* @return {Promise<Object>} 统一 success 包装(返回任务ID)
*/
async export(data = {}) {
const { service } = this;
const { whereValue = {} } = this.prepareWhereContext(data);
const {
start_time: startTime,
end_time: endTime,
by_space: bySpace,
store_ids: storeIds,
stock_id: stockIdRaw,
stock_ids: stockIdsRaw,
keyword,
sort_field: whereSortField,
sortField: whereSortFieldCamel,
sort_order: whereSortOrder,
sortOrder: whereSortOrderCamel,
} = whereValue;
// 兼容 stock_id(单数)和 stock_ids(数组)
const stockIds = stockIdsRaw !== undefined
? stockIdsRaw
: (stockIdRaw !== undefined ? [ stockIdRaw ] : null);
const { sort = {} } = data;
const {
sort_field: sortFieldSnake,
sortField: sortFieldCamel,
sort_order: sortOrderSnake,
sortOrder: sortOrderCamel,
} = sort || {};
const exportMode = String(data.export_mode || data.exportMode || '').trim();
const taskId = this.generateExportTaskId();
const taskPayload = {
task_id: taskId,
status: 'submitted',
progress: 0,
message: '导出任务已提交',
result: null,
error: '',
};
await this.setExportTaskProgress(taskId, taskPayload);
const sortOption = {
sortField: sortFieldCamel || sortFieldSnake || whereSortFieldCamel || whereSortField,
sortOrder: sortOrderCamel || sortOrderSnake || whereSortOrderCamel || whereSortOrder,
};
setImmediate(async () => {
try {
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: 'running',
progress: 10,
message: '导出任务执行中',
result: null,
error: '',
});
const result = await service.systems.storage.report.export(startTime, endTime, bySpace, storeIds, sortOption, exportMode, 'warehouse', stockIds, keyword);
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>} 统一 success 包装
*/
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.cndUrl
|| safeResult.cosUrl
|| safeResult.fileKey
|| ''
);
return this.success('ok', {
task_id: taskId,
...cachedTask,
download_url: downloadUrl,
});
}
/**
* 生成导出任务ID。
* @return {string} 导出任务ID
*/
generateExportTaskId() {
const warehouseId = this.ctx?.user?.store_id || 'unknown';
const timestamp = Date.now();
const randomToken = Math.random().toString(36).slice(2, 10);
return `stock_report_export_${warehouseId}_${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 `${STOCK_REPORT_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, STOCK_REPORT_EXPORT_TASK_CACHE_TTL_SECONDS);
} catch (error) {
this.ctx.logger.warn('[stock.report.export] 写入导出任务缓存失败: %s', error && error.message ? error.message : error);
}
}
/**
* 读取导出任务进度缓存。
* @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) {
this.ctx.logger.warn('[stock.report.export] 读取导出任务缓存失败: %s', error && error.message ? error.message : error);
return null;
}
}
}
module.exports = StockReportMethodService;

View File

@ -1,302 +0,0 @@
'use strict';
const MainService = require('../../main');
const STORAGE_REPORT_EXPORT_TASK_CACHE_KEY_PREFIX = 'storage_report_export_task_';
const STORAGE_REPORT_EXPORT_TASK_CACHE_TTL_SECONDS = 1800;
/**
* 系统方法层:storage.report(库存流水报表接口包装层)。
*/
class StorageReportMethodService extends MainService {
constructor(ctx) {
super(ctx);
const _noNeedLogin = '';
const _noNeedRight = 'search,export,exportTaskProgress';
const _noNeedLog = 'search,export,exportTaskProgress';
const _noNeedAuth = 'search,export,exportTaskProgress';
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
}
/**
* 查询库存流水统计报表。
* @param {Object} data 请求体
* @param {Object} [data.where] 查询条件
* @param {Object} [data.sort] 排序参数
* @param {string} [data.sort.sortField] 排序字段(兼容:sort_field)
* @param {string} [data.sort.sortOrder] 排序顺序(兼容:sort_order)
* @param {string|Date} [data.where.start_time] 开始时间
* @param {string|Date} [data.where.end_time] 结束时间
* @param {boolean|string|number} [data.where.by_space=false] 是否按库位返回
* @param {Array<number|string>} [data.where.store_ids] 货主ID列表
* @return {Promise<Object>} 统一 success 包装
*/
async search(data = {}) {
const { service } = this;
const { whereValue = {} } = this.prepareWhereContext(data);
const {
start_time: startTime,
end_time: endTime,
by_space: bySpace,
store_ids: storeIds,
sort_field: whereSortField,
sortField: whereSortFieldCamel,
sort_order: whereSortOrder,
sortOrder: whereSortOrderCamel,
} = whereValue;
const { sort = {} } = data;
const {
sort_field: sortFieldSnake,
sortField: sortFieldCamel,
sort_order: sortOrderSnake,
sortOrder: sortOrderCamel,
} = sort || {};
const result = await service.systems.storage.report.search(startTime, endTime, bySpace, storeIds, {
sortField: sortFieldCamel || sortFieldSnake || whereSortFieldCamel || whereSortField,
sortOrder: sortOrderCamel || sortOrderSnake || whereSortOrderCamel || whereSortOrder,
});
return this.success('ok', result);
}
/**
* 提交库存流水统计报表导出任务。
* @param {Object} data 请求体
* @param {Object} [data.where] 查询条件
* @param {Object} [data.sort] 排序参数
* @param {string} [data.sort.sortField] 排序字段(兼容:sort_field)
* @param {string} [data.sort.sortOrder] 排序顺序(兼容:sort_order)
* @param {string|Date} [data.where.start_time] 开始时间
* @param {string|Date} [data.where.end_time] 结束时间
* @param {boolean|string|number} [data.where.by_space=false] 是否按库位返回
* @param {Array<number|string>} [data.where.store_ids] 货主ID列表
* @param {string} [data.export_mode] 导出模式:'item' 导出含锁定类型的全部变更记录,不传则排除锁定类型
* @param {string} [data.exportMode] 导出模式(驼峰写法,同 export_mode)
* @return {Promise<Object>} 统一 success 包装(返回任务ID)
*/
async export(data = {}) {
const { service } = this;
const { whereValue = {} } = this.prepareWhereContext(data);
const {
start_time: startTime,
end_time: endTime,
by_space: bySpace,
store_ids: storeIds,
sort_field: whereSortField,
sortField: whereSortFieldCamel,
sort_order: whereSortOrder,
sortOrder: whereSortOrderCamel,
} = whereValue;
const { sort = {} } = data;
const {
sort_field: sortFieldSnake,
sortField: sortFieldCamel,
sort_order: sortOrderSnake,
sortOrder: sortOrderCamel,
} = sort || {};
const exportMode = String(data.export_mode || data.exportMode || '').trim();
const taskId = this.generateExportTaskId();
const taskPayload = {
task_id: taskId,
status: 'submitted',
progress: 0,
message: '导出任务已提交',
result: null,
error: '',
};
await this.setExportTaskProgress(taskId, taskPayload);
const sortOption = {
sortField: sortFieldCamel || sortFieldSnake || whereSortFieldCamel || whereSortField,
sortOrder: sortOrderCamel || sortOrderSnake || whereSortOrderCamel || whereSortOrder,
};
setImmediate(async () => {
try {
await this.setExportTaskProgress(taskId, {
task_id: taskId,
status: 'running',
progress: 10,
message: '导出任务执行中',
result: null,
error: '',
});
const result = await service.systems.storage.report.export(startTime, endTime, bySpace, storeIds, sortOption, exportMode);
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>} 统一 success 包装
*/
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.cndUrl
|| safeResult.cosUrl
|| safeResult.fileKey
|| ''
);
return this.success('ok', {
task_id: taskId,
...cachedTask,
download_url: downloadUrl,
});
}
/**
* 生成导出任务ID。
* @return {string} 导出任务ID
*/
generateExportTaskId() {
const warehouseId = this.ctx?.user?.store_id || 'unknown';
const timestamp = Date.now();
const randomToken = Math.random().toString(36).slice(2, 10);
return `storage_report_export_${warehouseId}_${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 `${STORAGE_REPORT_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, STORAGE_REPORT_EXPORT_TASK_CACHE_TTL_SECONDS);
} catch (error) {
this.ctx.logger.warn('[storage.report.export] 写入导出任务缓存失败: %s', error && error.message ? error.message : error);
}
}
/**
* 读取导出任务进度缓存。
* @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) {
this.ctx.logger.warn('[storage.report.export] 读取导出任务缓存失败: %s', error && error.message ? error.message : error);
return null;
}
}
}
module.exports = StorageReportMethodService;

View File

@ -145,7 +145,7 @@ class warehouseService extends MainService {
if (!barcode) {
return this.fail('条码不能为空');
}
const data = await service.systems.locationZone.checkBarcodeUnique(parseInt(id), barcode);
const data = await service.systems.locationZone.checkBarcodeUnique(parseInt(id), barcode, this.ctx.user.store_id);
return this.success('获取成功', { data, code: 200 });
} catch (error) {
return this.fail(error.message);
@ -409,7 +409,7 @@ class warehouseService extends MainService {
throw new Error('仓位不存在');
}
if (data.custom_barcode) {
const { isUnique } = await service.systems.locationZone.checkBarcodeUnique(parseInt(id), data.custom_barcode);
const { isUnique } = await service.systems.locationZone.checkBarcodeUnique(parseInt(id), data.custom_barcode, ctx.user.store_id);
if (!isUnique) {
throw new Error('自定义条码已存在');
}
@ -651,6 +651,7 @@ class warehouseService extends MainService {
if (requestedBarcodes.length > 0) {
const conflictSpace = await ctx.model.LocationSpace.findOne({
where: {
warehouse_id: warehouseId,
deleted_at: null,
id: {
[Op.notIn]: targetIds,

View File

@ -1202,6 +1202,10 @@ class DeliveryOrderService extends Service {
wms_stock = await app.model.StockStore.findOne({ where: stockWhere, transaction });
} else {
wms_stock = await app.model.StockStore.findByPk(line.itemId, { transaction });
// 校验 StockStore 记录的 store_id 与当前上下文一致,防止跨货主越权
if (wms_stock && Number(wms_stock.store_id) !== Number(storeId)) {
wms_stock = null;
}
}
if (!wms_stock) {

View File

@ -42,6 +42,10 @@ class entryOrderService extends Service {
}, transaction });
} else {
wms_stock = await app.model.StockStore.findByPk(orderLine[i].itemId, { transaction });
// 校验 StockStore 记录的 store_id 与当前上下文一致,防止跨货主越权
if (wms_stock && Number(wms_stock.store_id) !== Number(storeId)) {
wms_stock = null;
}
}
if (!wms_stock) {
errors.push(`SKU${orderLine[i].itemId}商品《${orderLine[i].itemName}》编码《${orderLine[i].itemCode}》\n未同步推送到仓库`);

View File

@ -48,10 +48,13 @@ class LocationSpaceService extends Service {
ctx.throw(400, '仓位编码已存在');
}
// 检查条码唯一性
// 检查条码唯一性(仓库内唯一)
if (data.custom_barcode) {
const barcodeExists = await ctx.model.LocationSpace.findOne({
where: { custom_barcode: data.custom_barcode },
where: {
warehouse_id: data.warehouse_id,
custom_barcode: data.custom_barcode,
},
});
if (barcodeExists) {
@ -103,10 +106,11 @@ class LocationSpaceService extends Service {
ctx.throw(400, `以下仓位编码已存在: ${codes}`);
}
// 检查条码重复
// 检查条码重复(仓库内唯一)
if (barcodes.length > 0) {
const duplicateBarcodes = await ctx.model.LocationSpace.findAll({
where: {
warehouse_id: warehouseId,
custom_barcode: { [ctx.app.Sequelize.Op.in]: barcodes },
},
attributes: [ 'custom_barcode' ],
@ -294,10 +298,11 @@ class LocationSpaceService extends Service {
}
}
// 如果修改条码,检查唯一性
// 如果修改条码,检查唯一性(仓库内唯一)
if (data.custom_barcode && data.custom_barcode !== locationSpace.custom_barcode) {
const exists = await ctx.model.LocationSpace.findOne({
where: {
warehouse_id: locationSpace.warehouse_id,
custom_barcode: data.custom_barcode,
id: { [ctx.app.Sequelize.Op.ne]: id },
},

View File

@ -1274,27 +1274,31 @@ class LocationZoneService extends Service {
throw error;
}
}
async checkBarcodeUnique(id, barcode) {
async checkBarcodeUnique(id, barcode, warehouseId) {
const { ctx, app } = this;
const { Op } = this.app.Sequelize || app.Sequelize;
try {
// 检查条码是否被其他仓位使用(排除当前仓位)
// 检查条码是否被其他仓位使用(排除当前仓位,仓库内唯一)
const whereConditions = [
{
id: {
[Op.ne]: id, // 排除当前仓位ID
},
},
{
[Op.or]: [
{ custom_barcode: barcode }, // 检查自定义条码
{ space_code: barcode }, // 检查仓位编码
],
},
{ deleted_at: null }, // 未删除的记录
];
if (warehouseId) {
whereConditions.push({ warehouse_id: warehouseId });
}
const space = await ctx.model.LocationSpace.findOne({
where: {
[Op.and]: [
{
id: {
[Op.ne]: id, // 排除当前仓位ID
},
},
{
[Op.or]: [
{ custom_barcode: barcode }, // 检查自定义条码
{ space_code: barcode }, // 检查仓位编码
],
},
{ deleted_at: null }, // 未删除的记录
],
[Op.and]: whereConditions,
},
attributes: [ 'id' ],
});

View File

@ -690,17 +690,27 @@ class OrderExpressService extends Service {
return '';
}
const { Op } = this.app.Sequelize;
const orderDeliveryModel = await orderDeliveryFactory.getCurrentModel(warehouseId);
const orderRow = await orderDeliveryModel.findOne({
where: {
id: { [Op.in]: orderIds },
warehouse_id: warehouseId,
shop_nick: { [Op.ne]: null },
},
attributes: [ 'shop_nick' ],
raw: true,
});
return orderRow ? String(orderRow.shop_nick || '').trim() : '';
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findOne !== 'function') continue;
const orderRow = await model.findOne({
where: {
id: { [Op.in]: orderIds },
warehouse_id: warehouseId,
shop_nick: { [Op.ne]: null },
},
attributes: [ 'shop_nick' ],
raw: true,
});
if (orderRow) return String(orderRow.shop_nick || '').trim();
} catch (_err) { continue; }
}
return '';
} catch (_err) {
return '';
}
@ -722,17 +732,27 @@ class OrderExpressService extends Service {
return '';
}
const { Op } = this.app.Sequelize;
const orderDeliveryModel = await orderDeliveryFactory.getCurrentModel(warehouseId);
const orderRow = await orderDeliveryModel.findOne({
where: {
id: { [Op.in]: orderIds },
warehouse_id: warehouseId,
sys_logistics_name: { [Op.ne]: null },
},
attributes: [ 'sys_logistics_name' ],
raw: true,
});
return orderRow ? String(orderRow.sys_logistics_name || '').trim() : '';
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findOne !== 'function') continue;
const orderRow = await model.findOne({
where: {
id: { [Op.in]: orderIds },
warehouse_id: warehouseId,
sys_logistics_name: { [Op.ne]: null },
},
attributes: [ 'sys_logistics_name' ],
raw: true,
});
if (orderRow) return String(orderRow.sys_logistics_name || '').trim();
} catch (_err) { continue; }
}
return '';
} catch (_err) {
return '';
}
@ -792,18 +812,28 @@ class OrderExpressService extends Service {
});
// 从订单表读取当前 items_weight(只读,不做 UPDATE)
// 依次查 current / dispatch 两张表
let itemsWeight = 0;
if (warehouseId) {
try {
const orderDeliveryFactory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
if (orderDeliveryFactory && typeof orderDeliveryFactory.getCurrentModel === 'function') {
const orderDeliveryModel = await orderDeliveryFactory.getCurrentModel(warehouseId);
const orderRow = await orderDeliveryModel.findOne({
where: { id: Number(targetRow.order_id), warehouse_id: warehouseId },
attributes: [ 'items_weight' ],
raw: true,
});
itemsWeight = orderRow ? Number(orderRow.items_weight || 0) : 0;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findOne !== 'function') continue;
const orderRow = await model.findOne({
where: { id: Number(targetRow.order_id), warehouse_id: warehouseId },
attributes: [ 'items_weight' ],
raw: true,
});
if (orderRow) { itemsWeight = Number(orderRow.items_weight || 0); break; }
} catch (_err) { continue; }
}
}
} catch (_err) {
// 查询失败时静默降级为 0
@ -1131,16 +1161,28 @@ class OrderExpressService extends Service {
async _upsertPackageMaterialItemRelation({ orderId, waybillCode, packageMaterialId, packageMaterialCode, packageMaterialName, warehouseId }) {
const { ctx } = this;
try {
// 1. 查订单的 items_hash / items_crc
// 1. 查订单的 items_hash / items_crc(依次查 current / dispatch 两张表)
const orderDeliveryFactory = ctx.model && ctx.model.OrderDeliveryFactory;
if (!orderDeliveryFactory || typeof orderDeliveryFactory.getCurrentModel !== 'function') return;
const orderDeliveryModel = await orderDeliveryFactory.getCurrentModel(warehouseId);
const orderRow = await orderDeliveryModel.findOne({
where: { id: orderId, warehouse_id: warehouseId },
attributes: [ 'items_hash', 'items_crc' ],
raw: true,
});
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
let orderRow = null;
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findOne !== 'function') continue;
const row = await model.findOne({
where: { id: orderId, warehouse_id: warehouseId },
attributes: [ 'items_hash', 'items_crc' ],
raw: true,
});
if (row) { orderRow = row; break; }
} catch (_err) { continue; }
}
if (!orderRow || !orderRow.items_hash) return;
const { items_hash: itemsHash, items_crc: itemsCrc } = orderRow;
@ -1329,16 +1371,28 @@ class OrderExpressService extends Service {
const materialRow = await this.findActivePackageMaterialById(normalizedPackageMaterialId, warehouseId);
// --- 团购波次自动感知 ---
// 尝试查询运单所属订单是否属于团购波次
// 依次查询 current / dispatch 表获取波次信息
const orderDeliveryFactory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
if (orderDeliveryFactory && typeof orderDeliveryFactory.getCurrentModel === 'function') {
try {
const orderDeliveryModel = await orderDeliveryFactory.getCurrentModel(warehouseId);
const orderRow = await orderDeliveryModel.findOne({
where: { id: Number(orderExpressRow.order_id), warehouse_id: warehouseId },
attributes: [ 'id', 'wave_id', 'wave_no' ],
raw: true,
});
const orderTableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
let orderRow = null;
for (const entry of orderTableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findOne !== 'function') continue;
const row = await model.findOne({
where: { id: Number(orderExpressRow.order_id), warehouse_id: warehouseId },
attributes: [ 'id', 'wave_id', 'wave_no' ],
raw: true,
});
if (row) { orderRow = row; break; }
} catch (_err) { continue; }
}
if (orderRow) {
const waveId = Number(orderRow.wave_id || 0);
@ -1499,24 +1553,38 @@ class OrderExpressService extends Service {
triggerOrderId,
triggerWaybillCode,
}) {
// 1. 查询波次下所有订单
// 1. 查询波次下所有订单(current + dispatch 两张表)
const orderDeliveryFactory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
if (!orderDeliveryFactory || typeof orderDeliveryFactory.getCurrentModel !== 'function') {
throw this.createBusinessError('订单模型未初始化', 500);
}
const orderDeliveryModel = await orderDeliveryFactory.getCurrentModel(warehouseId);
const waveOrders = await orderDeliveryModel.findAll({
where: { wave_id: waveId, warehouse_id: warehouseId },
attributes: [ 'id' ],
raw: true,
});
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
if (!waveOrders || waveOrders.length === 0) {
const orderIdSet = new Set();
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findAll !== 'function') continue;
const rows = await model.findAll({
where: { wave_id: waveId, warehouse_id: warehouseId },
attributes: [ 'id' ],
raw: true,
});
if (Array.isArray(rows)) {
rows.forEach(r => orderIdSet.add(Number(r.id)));
}
} catch (_err) { continue; }
}
if (orderIdSet.size === 0) {
throw this.createBusinessError('波次下未找到订单', 404);
}
const orderIds = waveOrders.map(o => Number(o.id));
const orderIds = Array.from(orderIdSet);
// 2. 查询这些订单下相同 business_key 的所有有效运单
const { Op } = this.app.Sequelize;

View File

@ -245,9 +245,10 @@ class EntryService extends Service {
* @param {Object} where 筛选条件对象
* @param {Object} pageParams 分页参数
* @param {Object} sortParams 排序参数
* @param {string} [mode='warehouse'] 查询模式:warehouse=仓库侧(按 warehouse_id 过滤),store=货主侧(按 store_id 过滤)
* @return {Promise<Object>} code/data/message 结构
*/
async list(where = {}, pageParams = {}, sortParams = {}) {
async list(where = {}, pageParams = {}, sortParams = {}, mode = 'warehouse') {
const { ctx, app } = this;
const { Sequelize } = app;
const { Op } = Sequelize;
@ -268,11 +269,39 @@ class EntryService extends Service {
];
const actualSortField = validSortFields.includes(sortField) ? sortField : 'created_at';
const baseWhere = {
warehouse_id: ctx.user.store_id,
is_enabled: 1,
deleted_at: null,
};
const isStoreMode = String(mode).toLowerCase() === 'store';
// 参考 stock.report.search:从 ctx.user.store_id 提取主维度 ID,
// Number(undefined)=NaN(falsy),防止 Sequelize 静默剔除 undefined 键导致过滤失效
const rawPrimaryId = Number(ctx.user && ctx.user.store_id);
const storeId = isStoreMode ? rawPrimaryId : null;
const warehouseId = isStoreMode ? null : rawPrimaryId;
if (isStoreMode && !storeId) {
return {
code: 400,
message: '用户未绑定货主,无法查询货主侧入库单',
data: {
list: [],
pagination: { page, pageSize, total: 0, totalPages: 0, hasPrevious: false, hasNext: false },
summary: { total: 0, pending: 0, creating: 0, created: 0, completed: 0, cancelled: 0 },
},
};
}
if (!isStoreMode && !warehouseId) {
return {
code: 400,
message: '用户未绑定仓库,无法查询入库单',
data: {
list: [],
pagination: { page, pageSize, total: 0, totalPages: 0, hasPrevious: false, hasNext: false },
summary: { total: 0, pending: 0, creating: 0, created: 0, completed: 0, cancelled: 0 },
},
};
}
const baseWhere = isStoreMode
? { store_id: storeId, is_enabled: 1, deleted_at: null }
: { warehouse_id: warehouseId, is_enabled: 1, deleted_at: null };
const normalizedWhere = ctx.where && typeof ctx.where === 'object'
? { ...ctx.where }
@ -506,22 +535,18 @@ class EntryService extends Service {
};
}
/**
* 查询入库单详情。
* @param {Object} data 请求体
* @return {Promise<Object>} code/data/message 结构
*/
/**
* 查询入库单详情(与原 storage.directInbound.getItems 输出格式一致)。
* 返回入库单基本信息、商品明细(含计划数量与已完成数量)、收货单绑定关系。
* @param {Object} data 请求参数
* @param {number} data.id 入库单主键 ID(必填)
* @param {string} [mode='warehouse'] 查询维度:'warehouse' 按仓库校验权限(默认),'store' 按货主校验权限
* @return {Promise<Object>} code/data/message 结构
* - data.entryOrder: { id, entry_order_code, order_status, store_remask }
* - data.items: [{ id, stock_id, planned, completed, stock, bindings }]
* - data.receivingBindings: [{ id, receiving_id, receiving }]
*/
async get(data = {}) {
async get(data = {}, mode = 'warehouse') {
const { ctx, app } = this;
const id = Number(data.id || 0);
@ -564,9 +589,18 @@ class EntryService extends Service {
return { code: 404, message: '入库单不存在', data: null };
}
// 校验仓库权限
if (entryOrder.warehouse_id !== ctx.user.store_id || !entryOrder.is_enabled) {
return { code: 404, message: '入库单不存在或无权访问', data: null };
const isStoreMode = String(mode).toLowerCase() === 'store';
const rawPrimaryId = Number(ctx.user && ctx.user.store_id);
// 校验权限:仓库模式校验 warehouse_id,货主模式校验 store_id
if (isStoreMode) {
if (entryOrder.store_id !== rawPrimaryId || !entryOrder.is_enabled) {
return { code: 404, message: '入库单不存在或无权访问', data: null };
}
} else {
if (entryOrder.warehouse_id !== rawPrimaryId || !entryOrder.is_enabled) {
return { code: 404, message: '入库单不存在或无权访问', data: null };
}
}
// 查询货主商家备注
@ -627,8 +661,9 @@ class EntryService extends Service {
/** @type {Map<number, Object>} */
const stockMap = new Map();
if (stockIds.length > 0) {
const warehouseId = ctx.user.store_id;
const stockDetails = await ctx.service.systems.stockWarehouse.getStockDetails(stockIds, { warehouseId });
// 货主模式下传 null 跳过 warehouse 过滤,避免 store_id 误当 warehouse_id 导致查不到商品
const stockWarehouseId = isStoreMode ? null : rawPrimaryId;
const stockDetails = await ctx.service.systems.stockWarehouse.getStockDetails(stockIds, { warehouseId: stockWarehouseId });
for (const detail of stockDetails) {
stockMap.set(detail.id, detail);
}

View File

@ -1324,9 +1324,12 @@ class SettingStoreWarehouseService extends Service {
const authStatus = Number(item.auth_status || 0);
const currentIsWarehouse = !!(currentSubject && currentSubject.isWarehouse);
const subjectId = currentSubject ? Number(currentSubject.id) : 0;
// 当前主体始终在 store_id 方(货主方/消费方),对方始终在 warehouse_id 方(仓库方/提供方)
const counterparty = item.warehouse;
// 根据当前主体在 store_id 还是 warehouse_id 判定对方主体(兼容新旧签约数据)
const subjectIsStore = subjectId > 0 && subjectId === Number(item.store_id || 0);
const subjectIsWarehouse = subjectId > 0 && subjectId === Number(item.warehouse_id || 0);
const counterparty = subjectIsStore ? item.warehouse : item.store;
const counterpartyRole = counterparty && counterparty.project === 'warehouse' ? 'warehouse' : 'store';
const storeName = item.store_remask || (item.store && item.store.company_name ? item.store.company_name : '');
@ -1369,8 +1372,8 @@ class SettingStoreWarehouseService extends Service {
applied_by: item.applied_by ? Number(item.applied_by) : null,
reviewed_by: item.reviewed_by ? Number(item.reviewed_by) : null,
ended_by: item.ended_by ? Number(item.ended_by) : null,
remask: currentIsWarehouse ? (item.store_remask || '') : (item.warehouse_remask || ''),
use_status: currentIsWarehouse
remask: subjectIsWarehouse ? (item.store_remask || '') : (item.warehouse_remask || ''),
use_status: subjectIsWarehouse
? Number(item.warehouse_use_status || 0)
: Number(item.store_use_status || 0),
warehouse_use_status: Number(item.warehouse_use_status || 0),
@ -1430,9 +1433,9 @@ class SettingStoreWarehouseService extends Service {
}
/**
* 货主侧查询签约关系列表。
* 货主侧查询签约关系列表(兼容新旧签约数据)。
*
* 当前货主主体在 store_id 方,对方仓库在 warehouse_id 方。
* 使用 OR 查询 store_id / warehouse_id 两边,确保新旧签约数据都能被正确展示。
*
* @param {Object} [data={}] 请求参数。
* @return {Promise<Object>} 接口响应对象。
@ -1444,7 +1447,49 @@ class SettingStoreWarehouseService extends Service {
const page = this.normalizePage(data.page, 'page', 1, 1000000);
const pageSize = this.normalizePage(data.page_size || data.pageSize, 'page_size', 20, 200);
const offset = (page - 1) * pageSize;
const where = this.buildListWhereByStoreId(data, currentSubject);
// OR 查询两边,兼容新旧签约数据
const where = {
[Op.or]: [
{ store_id: currentSubject.id },
{ warehouse_id: currentSubject.id },
],
};
const relationId = this.resolveRelationId(data);
if (relationId) {
where.id = relationId;
}
const counterpartyId = this.toPositiveNumber(data.counterparty_id || data.warehouse_id, 'counterparty_id', { allowEmpty: true });
if (counterpartyId) {
// 对方可能在 store_id 或 warehouse_id,两边都过滤
where[Op.and] = where[Op.and] || [];
where[Op.and].push({
[Op.or]: [
{ store_id: counterpartyId, warehouse_id: currentSubject.id },
{ warehouse_id: counterpartyId, store_id: currentSubject.id },
],
});
}
const authStatus = this.normalizeAuthStatus(data.auth_status);
if (authStatus !== null) {
where.auth_status = authStatus;
}
const rawUseStatus = data.use_status !== undefined ? data.use_status : data.store_use_status;
if (rawUseStatus !== undefined && rawUseStatus !== null && rawUseStatus !== '') {
// 同时过滤 store_use_status 和 warehouse_use_status
where[Op.and] = where[Op.and] || [];
where[Op.and].push({
[Op.or]: [
{ store_use_status: Number(rawUseStatus), store_id: currentSubject.id },
{ warehouse_use_status: Number(rawUseStatus), warehouse_id: currentSubject.id },
],
});
}
const keyword = typeof data.keyword === 'string' ? data.keyword.trim() : '';
if (keyword) {
@ -1507,9 +1552,9 @@ class SettingStoreWarehouseService extends Service {
}
/**
* 仓库侧查询签约关系列表。
* 仓库侧查询签约关系列表(兼容新旧签约数据)。
*
* 当前仓库主体在 store_id 方(消费方),对方(可能是仓库或货主)在 warehouse_id 方(提供方)。
* 使用 OR 查询 store_id / warehouse_id 两边,确保新旧签约数据都能被正确展示。
* 支持查询仓库与外部合作仓库的关系。
*
* @param {Object} [data={}] 请求参数。
@ -1522,7 +1567,49 @@ class SettingStoreWarehouseService extends Service {
const page = this.normalizePage(data.page, 'page', 1, 1000000);
const pageSize = this.normalizePage(data.page_size || data.pageSize, 'page_size', 20, 200);
const offset = (page - 1) * pageSize;
const where = this.buildListWhereByStoreId(data, currentSubject);
// OR 查询两边,兼容新旧签约数据
const where = {
[Op.or]: [
{ store_id: currentSubject.id },
{ warehouse_id: currentSubject.id },
],
};
const relationId = this.resolveRelationId(data);
if (relationId) {
where.id = relationId;
}
const counterpartyId = this.toPositiveNumber(data.counterparty_id || data.warehouse_id, 'counterparty_id', { allowEmpty: true });
if (counterpartyId) {
// 对方可能在 store_id 或 warehouse_id,两边都过滤
where[Op.and] = where[Op.and] || [];
where[Op.and].push({
[Op.or]: [
{ store_id: counterpartyId, warehouse_id: currentSubject.id },
{ warehouse_id: counterpartyId, store_id: currentSubject.id },
],
});
}
const authStatus = this.normalizeAuthStatus(data.auth_status);
if (authStatus !== null) {
where.auth_status = authStatus;
}
const rawUseStatus = data.use_status !== undefined ? data.use_status : data.store_use_status;
if (rawUseStatus !== undefined && rawUseStatus !== null && rawUseStatus !== '') {
// 同时过滤 store_use_status 和 warehouse_use_status
where[Op.and] = where[Op.and] || [];
where[Op.and].push({
[Op.or]: [
{ store_use_status: Number(rawUseStatus), store_id: currentSubject.id },
{ warehouse_use_status: Number(rawUseStatus), warehouse_id: currentSubject.id },
],
});
}
const keyword = typeof data.keyword === 'string' ? data.keyword.trim() : '';
if (keyword) {

View File

@ -0,0 +1,20 @@
'use strict';
module.exports = {
async up(queryInterface, Sequelize) {
// 将 custom_barcode 唯一索引从全局改为仓库级别
await queryInterface.removeIndex('wms_location_space', 'uk_custom_barcode');
await queryInterface.addIndex('wms_location_space', ['warehouse_id', 'custom_barcode', 'deleted_at'], {
name: 'uk_warehouse_custom_barcode',
unique: true,
});
},
async down(queryInterface, Sequelize) {
await queryInterface.removeIndex('wms_location_space', 'uk_warehouse_custom_barcode');
await queryInterface.addIndex('wms_location_space', ['custom_barcode'], {
name: 'uk_custom_barcode',
unique: true,
});
},
};

View File

@ -1,4 +1,25 @@
[
{
"version": "2026.07.10-system-01",
"date": "2026-07-10",
"type": "added",
"summary": "新增 storage.report.searchStore 货主侧库存报表,以 store_id 为主维度查询库存流水",
"methods": [
"storage.report.searchStore",
"storage.report.exportStore"
],
"notes": [
"新增 searchStore 方法:与 search 共享核心逻辑,通过 searchMode='store' 切换主维度从 warehouse_id → store_id。",
"新增 exportStore 方法:与 export 共享核心逻辑,支持货主侧导出 Excel(含汇总 + 变更记录两个 sheet)。",
"systems 层 search/export 方法新增 searchMode 参数(默认 'warehouse'),不影响现有 warehouse 侧行为。",
"货主侧使用 ctx.user.store_id 作为主维度 store_id,辅助维度支持 warehouse_ids 过滤特定仓库。",
"systemMethods 层 searchStore 从 where.warehouse_ids 取值传给 search 的 storeIds(承载 warehouse 过滤)。",
"输出新增 warehouse_id / warehouse_name 字段,货主侧可区分不同仓库的库存。search 方法也同步输出这两个字段(向后兼容)。",
"修复 getStockDetails 的 warehouseId 判断:从 != null 改为 !== undefined,使显式传 null 可跳过 warehouse 过滤。",
"修复 loadReportReferenceMaps 未传递 warehouseId 给 getStockDetails 的问题。"
],
"module": "storage.report"
},
{
"version": "2026.07.09-system-01",
"date": "2026-07-09",
@ -4859,5 +4880,37 @@
"备注修改功能已独立为 order.pendingOrder.updateRemark 方法。"
],
"module": "order.pendingOrder"
},
{
"version": "2026-07-16",
"date": "2026-07-16",
"summary": "新增 workbench.bindCamera 接口,支持工作台绑定/解绑摄像头",
"methods": [
"workbench.bindCamera"
],
"notes": [
"通过 device_ids JSON 字段存储绑定关系",
"传空数组可解绑"
]
},
{
"version": "2026.07.17-stock-report-migration-01",
"date": "2026-07-17",
"type": "updated",
"summary": "storage.report 模块迁移至 stock.report:修正语义错误,库存报表属于 stock 域而非 storage 域",
"methods": [
"stock.report.search",
"stock.report.searchStore",
"stock.report.export",
"stock.report.exportStore",
"stock.report.exportTaskProgress"
],
"notes": [
"将 systemMethods/storage/report.js 移动到 systemMethods/stock/report.js",
"内部引用同步更新:类名 StorageReportMethodService→StockReportMethodService,缓存键 storage_report→stock_report,日志前缀 [storage.report]→[stock.report]",
"旧文件直接删除,不保留兼容(storage.report 为语义错误,调用方需同步更新 method 名)",
"更新 systems/storage/entry.js L273 注释引用",
"文档:methods/system.json module storage.report→stock.report,5个 method 名同步更新"
]
}
]

File diff suppressed because it is too large Load Diff