oms/backend/app/lib/billOwnerScope.js
liufumingren 9774ee1414 feat(stock): 出入库单/记录增加货主并按货主隔离,创建人显示员工名称
- 迁移:inbound_orders / outbound_orders 增加 subsidiary_id 与索引,按仓库回填
- 单据货主由仓库决定:创建写入、改仓库同步,接口不接受直写 subsidiary_id
- 入库单/出库单列表返回 subsidiary_name 并新增货主筛选;详情/编辑/删除/审核/
  推送/完成/取消/恢复/作废/驳回与明细接口统一加货主越界 403
- 出入库记录按仓库归属货主:列表与导出收窄、返回 subsidiary_id/subsidiary_name、
  新增货主列与筛选
- 导出:入库单/出库单/出入库记录新增货主列并按所在公司权限收窄
- 新增 resolveAccountNameMap:列表/详情返回 creator_name/auditor_name/voider_name,
  创建人展示员工名称(principal_users.name),不再回退成邮箱账号
- 前端:三个列表新增货主列与筛选,创建人/作废人展示改为员工名称

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-05 15:13:22 +08:00

142 lines
6.0 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';
/**
* 出入库单据的货主(下属公司)口径
*
* 单据头不单独存货主字段:货主由所选仓库决定(warehouses.subsidiary_id)。
* 为避免「某货主的货物进入另一货主的出入库单」,明细商品/组合必须与仓库同货主;
* 同时,所在公司权限的账号只能使用自己所属公司的仓库。
*/
/** 单据类型 → 单据头模型名(stock_items.bill_type) */
const BILL_MODEL = { 1: 'InboundOrder', 2: 'OutboundOrder' };
/**
* 解析当前账号在该主体下的权限范围(无登录态视为系统操作,按集团放行)
* @param {Object} ctx egg context
* @return {Promise<{isGroup: boolean, ownCompanyIds: Array<number>}>} 权限范围
*/
async function resolveAccess(ctx) {
const principalId = Number(ctx.state.principalId);
if (!ctx.userId || !Number.isInteger(principalId)) return { isGroup: true, ownCompanyIds: [] };
return ctx.service.access.resolve(ctx.userId, principalId);
}
/**
* 取仓库并校验主体隔离与货主权限
* @param {Object} ctx egg context
* @param {number|string} warehouseId 仓库ID
* @return {Promise<{ok: boolean, status?: number, message?: string, warehouse?: Object, subsidiaryId?: number|null}>} 校验结果
*/
async function resolveWarehouse(ctx, warehouseId) {
const principalId = Number(ctx.state.principalId);
const warehouse = await ctx.model.Warehouse.findOne({
where: { id: Number(warehouseId), principal_id: principalId },
attributes: [ 'id', 'code', 'name', 'subsidiary_id' ],
});
if (!warehouse) return { ok: false, status: 404, message: '仓库不存在或不属于当前主体' };
const subsidiaryId = warehouse.subsidiary_id == null ? null : Number(warehouse.subsidiary_id);
const access = await resolveAccess(ctx);
if (!access.isGroup && subsidiaryId !== null && !access.ownCompanyIds.includes(subsidiaryId)) {
return { ok: false, status: 403, message: '仓库不属于自己所属公司(货主),无权使用' };
}
return { ok: true, warehouse, subsidiaryId };
}
/**
* 校验明细商品/组合与仓库同货主(存在性 + 启用状态 + 货主一致)
* @param {Object} ctx egg context
* @param {Array} items 明细 [{ product_id, combo_product_id }]
* @param {number|null} subsidiaryId 仓库所属公司ID(null 表示仓库未关联货主,不做货主校验)
* @return {Promise<{ok: boolean, message?: string}>} 校验结果
*/
async function assertItemsOwner(ctx, items, subsidiaryId) {
const Op = ctx.app.Sequelize.Op;
const principalId = Number(ctx.state.principalId);
const list = Array.isArray(items) ? items : [];
const pickIds = key => [ ...new Set(list.map(it => Number(it && it[key])).filter(id => Number.isInteger(id) && id > 0)) ];
const productIds = pickIds('product_id');
const comboIds = pickIds('combo_product_id');
if (!productIds.length && !comboIds.length) return { ok: true };
const [ products, combos ] = await Promise.all([
productIds.length
? ctx.model.Product.findAll({
where: { id: { [Op.in]: productIds }, principal_id: principalId },
attributes: [ 'id', 'status', 'subsidiary_id' ],
raw: true,
})
: [],
comboIds.length
? ctx.model.ComboProduct.findAll({
where: { id: { [Op.in]: comboIds }, principal_id: principalId },
attributes: [ 'id', 'subsidiary_id' ],
raw: true,
})
: [],
]);
const disabled = products.filter(row => Number(row.status) !== 1);
if (disabled.length) return { ok: false, message: '明细关联的商品不存在或已禁用,无法保存' };
if (products.length !== productIds.length || combos.length !== comboIds.length) {
return { ok: false, message: '明细关联的商品/组合不存在或不属于当前主体' };
}
if (subsidiaryId === null || subsidiaryId === undefined) return { ok: true };
const mismatch = [ ...products, ...combos ].find(
row => row.subsidiary_id != null && Number(row.subsidiary_id) !== Number(subsidiaryId)
);
if (mismatch) return { ok: false, message: '明细商品不属于该仓库的货主,请选择同货主的商品' };
return { ok: true };
}
/**
* 取单据所在仓库的货主ID(明细增删改时校验商品货主用)
* @param {Object} ctx egg context
* @param {number} billType 单据类型:1入库 2出库
* @param {number} billId 单据头ID
* @return {Promise<{ok: boolean, status?: number, message?: string, subsidiaryId?: number|null}>} 校验结果
*/
async function resolveBillSubsidiary(ctx, billType, billId) {
const modelName = BILL_MODEL[Number(billType)];
if (!modelName) return { ok: false, status: 400, message: 'bill_type 不合法,仅支持 1入库 / 2出库' };
const order = await ctx.model[modelName].findByPk(billId, { attributes: [ 'id', 'warehouse_id' ] });
if (!order) return { ok: false, status: 404, message: '所属单据不存在' };
if (!order.warehouse_id) return { ok: true, subsidiaryId: null };
const warehouse = await resolveWarehouse(ctx, order.warehouse_id);
if (!warehouse.ok) return { ok: false, status: warehouse.status, message: warehouse.message };
return { ok: true, subsidiaryId: warehouse.subsidiaryId };
}
/**
* 判断某货主的数据是否在当前账号可见范围内
* @param {Object} access resolveAccess 的结果
* @param {number|null} subsidiaryId 数据所属货主ID
* @return {boolean} 是否可见/可操作
*/
function isVisible(access, subsidiaryId) {
if (!access || access.isGroup) return true;
if (subsidiaryId === null || subsidiaryId === undefined) return false;
return access.ownCompanyIds.includes(Number(subsidiaryId));
}
/**
* 取当前账号的货主可见范围(集团返回 null,表示不限制)
* @param {Object} access resolveAccess 的结果
* @return {Array<number>|null} 可见货主ID列表;null 表示不限制
*/
function ownSubsidiaryIds(access) {
if (!access || access.isGroup) return null;
return access.ownCompanyIds.map(Number);
}
module.exports = {
resolveAccess,
resolveWarehouse,
assertItemsOwner,
resolveBillSubsidiary,
isVisible,
ownSubsidiaryIds,
};