498 lines
17 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 Service = require('egg').Service;
class IndexService extends Service {
async findByStockAndBatch(stockId, batchNo, inventoryType = 'ZP') {
const { ctx } = this;
return await ctx.model.Storage.findOne({
where: {
stock_id: stockId,
batch_no: batchNo,
inventory_type: inventoryType,
is_enabled: 1,
delete_at: null,
},
include: [
{
model: ctx.model.LocationSpace,
as: 'space',
attributes: [ 'space_code', 'custom_name' ],
},
{
model: ctx.model.Store,
as: 'warehouse',
attributes: [[ 'company_name', 'store_name' ]],
},
],
});
}
async findBySpace(spaceId) {
const { ctx } = this;
return await ctx.model.Storage.findAll({
where: {
space_id: spaceId,
is_enabled: 1,
delete_at: null,
},
include: [
{
model: ctx.model.StockWarehouse,
as: 'stock',
attributes: [ 'product_code', 'product_name' ],
},
],
order: [[ 'inbound_time', 'ASC' ]],
});
}
async findAvailableByWarehouse(warehouseId, stockId = null) {
const { ctx, app } = this;
const where = {
warehouse_id: warehouseId,
is_enabled: 1,
delete_at: null,
available_quantity: { [app.Sequelize.Op.gt]: 0 },
};
if (stockId) {
where.stock_id = stockId;
}
return await ctx.model.Storage.findAll({
where,
include: [
{
model: ctx.model.LocationSpace,
as: 'space',
attributes: [ 'space_code', 'custom_name' ],
},
{
model: ctx.model.StockWarehouse,
as: 'stock',
attributes: [ 'product_code', 'product_name' ],
},
],
order: [
[ 'expiry_date', 'ASC' ],
[ 'inbound_time', 'ASC' ],
],
});
}
async findExpiringSoon(days = 30) {
const { ctx, app } = this;
const expiryDate = new Date();
expiryDate.setDate(expiryDate.getDate() + days);
return await ctx.model.Storage.findAll({
where: {
expiry_date: {
[app.Sequelize.Op.between]: [ new Date(), expiryDate ],
},
is_enabled: 1,
delete_at: null,
quantity: { [app.Sequelize.Op.gt]: 0 },
},
include: [
{
model: ctx.model.Store,
as: 'warehouse',
attributes: [[ 'company_name', 'store_name' ]],
},
{
model: ctx.model.StockWarehouse,
as: 'stock',
attributes: [ 'product_code', 'product_name' ],
},
],
order: [[ 'expiry_date', 'ASC' ]],
});
}
/**
* 更新库存数量、锁定数量与拦截锁定数量,并按统一口径重算可用数量。
*
* 可用数量统一口径:
* `available_quantity = quantity - locked_quantity - intercept_locked_quantity`。
*
* @param {number} id 库存记录 ID。
* @param {number} quantityChange 库存数量变化量(正数为增加,负数为减少)。
* @param {number} [lockedChange=0] 锁定数量变化量。
* @param {Object} [options={}] 执行上下文与事务参数。
* @param {Object} [options.transaction] Sequelize 事务对象。
* @param {number} [options.interceptLockedChange=0] 拦截锁定数量变化量(正数为拦截锁定,负数为释放;
* 允许结果为负值:差异对账场景下 storage 比 stock 少的差异以负拦截锁定入账,可用数量等量回补)。
* @return {Promise<Object>} 更新后的库存记录。
*/
async updateQuantity(id, quantityChange, lockedChange = 0, options = {}) {
const { ctx } = this;
const interceptLockedChange = Number((options && options.interceptLockedChange) || 0);
const applyUpdate = async transaction => {
const storage = await ctx.model.Storage.findByPk(id, {
transaction,
lock: transaction ? transaction.LOCK.UPDATE : undefined,
});
if (!storage) {
throw new Error('库存记录不存在');
}
const newQuantity = storage.quantity + quantityChange;
const newLocked = storage.locked_quantity + lockedChange;
const newInterceptLocked = Number(storage.intercept_locked_quantity || 0) + interceptLockedChange;
if (newQuantity < 0) {
throw new Error('库存数量不能为负数');
}
if (newLocked < 0) {
throw new Error('锁定数量无效');
}
// 拦截锁定允许为负(差异对账:storage 比 stock 少的差异以负值入账,可用数量回补);
// 上界仍禁止超过库存数量;锁定数量仍禁止为负
if (newInterceptLocked > newQuantity) {
throw new Error('拦截锁定数量无效');
}
// 总和上界:锁定与拦截锁定之和不能超过库存数量;
// 等价于锁定后可用不为负(available ≥ 0)。
// 负拦截锁(差异对账补回)时锁定量可超过 quantity,但总和上限口径不变,
// 保证补回的可用数量可真实被锁定使用。
if (newLocked + newInterceptLocked > newQuantity) {
throw new Error('锁定数量与拦截锁定数量之和不能超过库存数量');
}
const updateData = {
quantity: newQuantity,
locked_quantity: newLocked,
intercept_locked_quantity: newInterceptLocked,
available_quantity: newQuantity - newLocked - newInterceptLocked,
updated_at: new Date(),
};
await storage.update(updateData, {
transaction,
});
return storage;
};
if (options.transaction) {
return await applyUpdate(options.transaction);
}
return await ctx.model.transaction(async transaction => {
return await applyUpdate(transaction);
});
}
/**
* 锁定指定库存记录的可用数量。
*
* @param {number} id 库存记录 ID。
* @param {number} quantity 需要锁定的数量。
* @param {Object} [options={}] 执行上下文与事务参数。
* @param {Object} [options.transaction] Sequelize 事务对象。
* @param {string} [options.source] 调用来源标识。
* @param {string} [options.caller] 调用方标识。
* @param {string} [options.from] 来源模块标识。
* @param {string} [options.action] 操作标识。
* @return {Promise<Object>} 更新后的库存记录。
*/
async lockQuantity(id, quantity, options = {}) {
return await this.updateQuantity(id, 0, quantity, options);
}
/**
* 解除指定库存记录的锁定数量(锁定数量减少,可用数量等量增加)。
*
* @param {number} id 库存记录 ID。
* @param {number} quantity 需要解除锁定的数量。
* @param {Object} [options={}] 执行上下文与事务参数。
* @param {Object} [options.transaction] Sequelize 事务对象。
* @return {Promise<Object>} 更新后的库存记录。
*/
async unlockQuantity(id, quantity, options = {}) {
return await this.updateQuantity(id, 0, -quantity, options);
}
/**
* 从可用数量中分配锁定指定数量(锁定数量增加,可用数量等量减少)。
*
* @param {number} id 库存记录 ID。
* @param {number} quantity 需要分配锁定的数量。
* @param {Object} [options={}] 执行上下文与事务参数。
* @param {Object} [options.transaction] Sequelize 事务对象。
* @return {Promise<Object>} 更新后的库存记录。
*/
async allocateQuantity(id, quantity, options = {}) {
const { ctx } = this;
const storage = await ctx.model.Storage.findByPk(id, {
transaction: options.transaction,
});
if (!storage) {
throw new Error('库存记录不存在');
}
if (storage.available_quantity < quantity) {
throw new Error('可用数量不足');
}
return await this.updateQuantity(id, 0, quantity, options);
}
/**
* 将作业锁定数量迁移为拦截锁定数量(拦截确认专用,pending 拣货行)。
*
* 库存总量与可用数量均不变,仅将锁定类型从 `locked_quantity` 迁移到 `intercept_locked_quantity`:
* `locked_quantity -q`、`intercept_locked_quantity +q`、`quantity` 与 `available_quantity` 不变。
*
* @param {number} id 库存记录 ID。
* @param {number} quantity 需要迁移为拦截锁定的数量。
* @param {Object} [options={}] 执行上下文与事务参数。
* @param {Object} [options.transaction] Sequelize 事务对象。
* @return {Promise<Object>} 更新后的库存记录。
*/
async interceptLockQuantity(id, quantity, options = {}) {
return await this.updateQuantity(id, 0, -quantity, {
...options,
interceptLockedChange: quantity,
});
}
/**
* 实物返还并拦截锁定(拦截确认专用,fin 已拣货行)。
*
* 库存总量与拦截锁定数量等量增加,可用数量不变:
* `quantity +q`、`intercept_locked_quantity +q`、`locked_quantity` 与 `available_quantity` 不变。
*
* @param {number} id 库存记录 ID。
* @param {number} quantity 需要返还并拦截锁定的数量。
* @param {Object} [options={}] 执行上下文与事务参数。
* @param {Object} [options.transaction] Sequelize 事务对象。
* @return {Promise<Object>} 更新后的库存记录。
*/
async interceptReceiveQuantity(id, quantity, options = {}) {
return await this.updateQuantity(id, quantity, 0, {
...options,
interceptLockedChange: quantity,
});
}
/**
* 释放拦截锁定数量,使其回落到可用数量(解除拦截/退货登记专用)。
*
* 库存总量与作业锁定数量不变,拦截锁定数量减少、可用数量等量增加:
* `intercept_locked_quantity -q`、`available_quantity +q`、`quantity` 与 `locked_quantity` 不变。
*
* @param {number} id 库存记录 ID。
* @param {number} quantity 需要释放的拦截锁定数量。
* @param {Object} [options={}] 执行上下文与事务参数。
* @param {Object} [options.transaction] Sequelize 事务对象。
* @return {Promise<Object>} 更新后的库存记录。
*/
async interceptUnlockQuantity(id, quantity, options = {}) {
return await this.updateQuantity(id, 0, 0, {
...options,
interceptLockedChange: -quantity,
});
}
/**
* 入库回填平账:负库存入库时,按入库量冲销该商品的 GAP 补建行挂账。
*
* 背景:差异对账(INTERCEPT_GAP)对无行/截断差异会补建 GAP- 前缀库存行承载拦截锁定;
* 当负库存商品真实入库回填时,将补建行挂账按入库量冲销(quantity/intercept 同减),
* 账归真实入库数据,避免补建挂账与真实入库叠加造成虚账。
*
* 冲销口径:每行冲销量 m = min(入库量, 行 quantity, 行 intercept_locked_quantity);
* available 按统一口径重算(quantity 与 intercept 同减,available 不变);
* 写 INTERCEPT_GAP(UNLOCK 方向)冲销流水,保留快照可追溯。
*
* 冲销上限:差异基准为 max(SW.quantity, 0),只有 SW 在非负区间的增量才会收窄差异;
* SW 在负数区间回填(如 -10→0)不改变基准,不冲销。因此调用方应传入
* options.maxOffset = max(0, 入库后SW) - max(0, 入库前SW),缺省时按入库量冲销(兼容)。
*
* @param {number} stockId 商品SKU ID(wms_stock_warehouse.id)。
* @param {number} qty 本次入库数量。
* @param {Object} [options={}] 执行上下文与事务参数。
* @param {Object} [options.transaction] Sequelize 事务对象。
* @param {number} [options.maxOffset] 冲销上限(推荐传 SW 非负区间增量,缺省=入库量)。
* @param {string} [options.orderNo] 入库单号/来源标识(流水追溯)。
* @param {number} [options.orderId] 关联订单/入库单 ID。
* @param {string} [options.operatorId] 操作人 ID。
* @param {string} [options.operatorName] 操作人名。
* @return {Promise<number>} 实际冲销量。
*/
async offsetGapOnInbound(stockId, qty, options = {}) {
const { ctx, app } = this;
const inboundQty = Number(qty) || 0;
if (!stockId || inboundQty <= 0) return 0;
const maxOffset = options.maxOffset !== undefined && options.maxOffset !== null
? Math.max(0, Number(options.maxOffset) || 0)
: inboundQty;
if (maxOffset <= 0) return 0;
const apply = async transaction => {
const gapRows = await ctx.model.Storage.findAll({
where: {
stock_id: stockId,
is_enabled: 1,
delete_at: null,
[app.Sequelize.Op.or]: [
{ batch_no: { [app.Sequelize.Op.like]: 'GAP-%' } },
{ inbound_order_no: { [app.Sequelize.Op.like]: 'GAP-%' } },
],
},
order: [[ 'id', 'ASC' ]],
lock: transaction ? transaction.LOCK.UPDATE : undefined,
transaction,
});
let remain = inboundQty;
let offsetTotal = 0;
let offsetBudget = maxOffset;
for (const row of gapRows) {
if (remain <= 0 || offsetBudget <= 0) break;
const gapQty = Number(row.quantity) || 0;
const gapIntercept = Number(row.intercept_locked_quantity) || 0;
const offsetQty = Math.min(remain, offsetBudget, Math.min(gapQty, gapIntercept));
if (offsetQty <= 0) continue;
const newQty = gapQty - offsetQty;
const newIntercept = gapIntercept - offsetQty;
const lockedQty = Number(row.locked_quantity) || 0;
await row.update({
quantity: newQty,
intercept_locked_quantity: newIntercept,
available_quantity: newQty - lockedQty - newIntercept,
updated_at: new Date(),
}, { transaction });
// 冲销流水(UNLOCK 方向,快照守恒:after = before - offsetQty)
await ctx.model.StorageTransaction.create({
transaction_type: 'UNLOCK',
warehouse_id: row.warehouse_id,
store_id: row.store_id,
stock_id: stockId,
storage_id: row.id,
space_id: row.space_id,
quantity: offsetQty,
before_quantity: gapQty,
after_quantity: newQty,
before_locked_quantity: lockedQty,
after_locked_quantity: lockedQty,
before_intercept_locked_quantity: gapIntercept,
after_intercept_locked_quantity: newIntercept,
batch_no: row.batch_no,
inventory_type: row.inventory_type,
order_type: 'INTERCEPT_GAP',
order_no: String(options.orderNo || 'INBOUND_GAP_OFFSET').slice(0, 255),
order_id: Number(options.orderId || 0) || null,
operator_id: options.operatorId || null,
operator_name: options.operatorName || '',
remark: '入库回填平账(冲销差异挂账)',
created_at: new Date(),
}, { transaction });
remain -= offsetQty;
offsetBudget -= offsetQty;
offsetTotal += offsetQty;
}
return offsetTotal;
};
if (options.transaction) {
return await apply(options.transaction);
}
return await ctx.model.transaction(async transaction => {
return await apply(transaction);
});
}
async getStockSummary(warehouseId) {
const { ctx, app } = this;
return await ctx.model.Storage.findAll({
attributes: [
'stock_id',
'inventory_type',
[ app.Sequelize.fn('SUM', app.Sequelize.col('quantity')), 'total_quantity' ],
[ app.Sequelize.fn('SUM', app.Sequelize.col('locked_quantity')), 'total_locked' ],
[ app.Sequelize.fn('SUM', app.Sequelize.col('available_quantity')), 'total_available' ],
],
where: {
warehouse_id: warehouseId,
is_enabled: 1,
delete_at: null,
},
group: [ 'stock_id', 'inventory_type' ],
raw: true,
});
}
async getSpaceUsage(spaceId) {
const { ctx, app } = this;
const result = await ctx.model.Storage.findAll({
attributes: [
'inventory_type',
[ app.Sequelize.fn('COUNT', app.Sequelize.col('id')), 'record_count' ],
[ app.Sequelize.fn('SUM', app.Sequelize.col('quantity')), 'total_quantity' ],
],
where: {
space_id: spaceId,
is_enabled: 1,
delete_at: null,
},
group: [ 'inventory_type' ],
raw: true,
});
const usage = {
normal: 0,
defective: 0,
damaged: 0,
frozen: 0,
total: 0,
};
result.forEach(item => {
let type;
switch (item.inventory_type) {
case 'ZP':
type = 'normal';
break;
case 'CC':
type = 'defective';
break;
case 'JS':
case 'XS':
type = 'damaged';
break;
case 'DJ':
type = 'frozen';
break;
default:
return;
}
usage[type] = parseInt(item.total_quantity, 10) || 0;
usage.total += usage[type];
});
return usage;
}
}
module.exports = IndexService;