2026-04-09 15:45:14 +08:00

777 lines
19 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;
const { parseWhereConditions } = require('../../../lib/query_condition_parser');
class EntryService extends Service {
/**
* 入库单列表查询,复用 where 解构工具。
* @param {Object} where 筛选条件对象
* @param {Object} pageParams 分页参数
* @param {Object} sortParams 排序参数
* @return {Promise<Object>} code/data/message 结构
*/
async list(where = {}, pageParams = {}, sortParams = {}) {
const { ctx, app } = this;
const { Sequelize } = app;
const { Op } = Sequelize;
const page = Math.max(Number(pageParams.page) || 1, 1);
const pageSize = Math.max(Number(pageParams.pageSize) || 20, 1);
const sortField = sortParams.sortField || 'created_at';
const sortOrder = String(sortParams.sortOrder || 'DESC').toUpperCase() === 'ASC' ? 'ASC' : 'DESC';
const validSortFields = [
'id',
'entry_order_code',
'order_type',
'order_status',
'order_create_time',
'created_at',
'updated_at',
'total_order_lines',
];
const actualSortField = validSortFields.includes(sortField) ? sortField : 'created_at';
const baseWhere = {
warehouse_id: ctx.user.store_id,
is_enabled: 1,
deleted_at: null,
};
const normalizedWhere = ctx.where && typeof ctx.where === 'object'
? { ...ctx.where }
: (where && typeof where === 'object' ? { ...where } : {});
let parsedResult = ctx.whereParsed;
if (!parsedResult || !Array.isArray(parsedResult.dynamicConditions)) {
const parsed = parseWhereConditions({
where: normalizedWhere,
app,
specialFieldMap: {
quickWhere: {
bucket: 'quick',
},
},
});
if (!parsed.ok) {
return {
code: 400,
message: `筛选条件解析失败: ${parsed.reason}`,
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,
},
},
};
}
parsedResult = parsed.result;
}
const quickWhereInput = (parsedResult.rawConditionsByField && parsedResult.rawConditionsByField.quickWhere)
|| normalizedWhere.quickWhere
|| null;
const quickWhereValue = quickWhereInput && typeof quickWhereInput === 'object'
? quickWhereInput.value
: null;
const andConditions = [ baseWhere ];
if (quickWhereValue !== undefined && quickWhereValue !== null && String(quickWhereValue).trim() !== '') {
const kw = String(quickWhereValue).trim();
andConditions.push({
[Op.or]: [
{ entry_order_code: { [Op.like]: `%${kw}%` } },
{ purchase_order_code: { [Op.like]: `%${kw}%` } },
{ supplier_name: { [Op.like]: `%${kw}%` } },
{ store_name: { [Op.like]: `%${kw}%` } },
{ warehouse_name: { [Op.like]: `%${kw}%` } },
],
});
}
const dynamicConditions = parsedResult.dynamicConditions || [];
if (dynamicConditions.length > 0) {
andConditions.push({ [Op.and]: dynamicConditions });
}
const finalWhere = { [Op.and]: andConditions };
const 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,
},
];
const { count, rows } = await ctx.model.EntryOrder.findAndCountAll({
where: finalWhere,
include,
order: [[ actualSortField, sortOrder ]],
limit: pageSize,
offset: (page - 1) * pageSize,
distinct: true,
});
const statusRows = await ctx.model.EntryOrder.findAll({
attributes: [
'order_status',
[ Sequelize.fn('COUNT', Sequelize.col('id')), 'count' ],
],
where: finalWhere,
group: [ 'order_status' ],
raw: true,
});
const summary = {
total: count,
pending: 0,
creating: 0,
created: 0,
completed: 0,
cancelled: 0,
};
statusRows.forEach(item => {
const statusKey = String(item.order_status || '').toLowerCase();
if (Object.prototype.hasOwnProperty.call(summary, statusKey)) {
summary[statusKey] = Number(item.count) || 0;
}
});
return {
code: 200,
message: '查询成功',
data: {
list: rows,
pagination: {
page,
pageSize,
total: count,
totalPages: Math.ceil(count / pageSize),
hasPrevious: page > 1,
hasNext: page < Math.ceil(count / pageSize),
},
summary,
},
};
}
/**
* 查询入库单详情。
* @param {Object} data 请求体
* @return {Promise<Object>} code/data/message 结构
*/
async get(data = {}) {
const { ctx } = this;
const id = Number(data.id || 0);
const entryOrderCode = data.entry_order_code ? String(data.entry_order_code).trim() : '';
if (!id && !entryOrderCode) {
return {
code: 400,
message: 'id 或 entry_order_code 至少传一个',
data: null,
};
}
const where = {
warehouse_id: ctx.user.store_id,
is_enabled: 1,
deleted_at: null,
};
if (id) {
where.id = id;
} else {
where.entry_order_code = entryOrderCode;
}
const entryOrder = await ctx.model.EntryOrder.findOne({
where,
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',
include: [
{
model: ctx.model.StockWarehouse,
as: 'stock',
attributes: [ 'id', 'item_code', 'item_name' ],
required: false,
},
],
required: false,
},
],
});
if (!entryOrder) {
return {
code: 0,
message: '入库单不存在或无权访问',
data: null,
};
}
return {
code: 200,
message: '查询成功',
data: {
entryOrder,
},
};
}
generateOrderCode() {
const randomPart = Math.floor(Math.random() * 1000).toString().padStart(3, '0');
return `ENT${Date.now()}${randomPart}`;
}
/**
* 创建入库单。
* @param {Object} data 请求体
* @return {Promise<Object>} code/data/message 结构
*/
async create(data = {}) {
const { ctx } = this;
const allowedOrderTypes = new Set([ 'SCRK', 'LYRK', 'CCRK', 'CGRK', 'DBRK', 'QTRK', 'B2BRK', 'XNRK' ]);
const orderType = String(data.order_type || '').trim();
const storeId = Number(data.store_id || ctx.user.store_id || 0);
if (!orderType) {
return {
code: 400,
message: 'order_type 必填',
data: null,
};
}
if (!allowedOrderTypes.has(orderType)) {
return {
code: 400,
message: 'order_type 不合法',
data: null,
};
}
if (!storeId) {
return {
code: 400,
message: 'store_id 必填',
data: null,
};
}
const entryOrderCode = data.entry_order_code && String(data.entry_order_code).trim() !== ''
? String(data.entry_order_code).trim()
: this.generateOrderCode();
const exists = await ctx.model.EntryOrder.findOne({
where: {
entry_order_code: entryOrderCode,
warehouse_id: ctx.user.store_id,
store_id: storeId,
deleted_at: null,
},
});
if (exists) {
return {
code: 409,
message: '入库单号已存在',
data: {
id: exists.id,
entry_order_code: exists.entry_order_code,
},
};
}
const order = await ctx.model.EntryOrder.create({
entry_order_code: entryOrderCode,
order_type: orderType,
purchase_order_code: data.purchase_order_code || '',
total_order_lines: Number(data.total_order_lines || 0),
order_create_time: data.order_create_time ? new Date(data.order_create_time) : new Date(),
expect_start_time: data.expect_start_time ? new Date(data.expect_start_time) : null,
expect_end_time: data.expect_end_time ? new Date(data.expect_end_time) : null,
logistics_code: data.logistics_code || '',
logistics_name: data.logistics_name || '',
express_code: data.express_code || '',
supplier_code: data.supplier_code || '',
supplier_name: data.supplier_name || '',
source_type: 'API',
order_status: 'CREATED',
sync_status: 'PENDING',
sync_message: '',
is_enabled: 1,
warehouse_id: ctx.user.store_id,
store_id: storeId,
remark: data.remark || '',
created_at: new Date(),
updated_at: new Date(),
});
return {
code: 200,
message: '创建成功',
data: {
id: order.id,
entry_order_code: order.entry_order_code,
},
};
}
/**
* 归一化作废入参中的入库单 ID 列表。
* 优先使用 ids;未传 ids 时回退到 id。
* @param {Object} data 请求体
* @return {{ ok: boolean, ids?: number[], code?: number, message?: string }} 归一化结果
*/
normalizeCancelEntryOrderIds(data = {}) {
const hasIdsField = Object.prototype.hasOwnProperty.call(data, 'ids');
const hasIdField = Object.prototype.hasOwnProperty.call(data, 'id');
if (!hasIdsField && !hasIdField) {
return {
ok: false,
code: 400,
message: 'id 或 ids 必填',
};
}
const rawIds = hasIdsField ? data.ids : [ data.id ];
if (hasIdsField) {
if (!Array.isArray(rawIds) || rawIds.length === 0) {
return {
ok: false,
code: 400,
message: 'ids 必须是非空数组',
};
}
} else if (!Number.isInteger(Number(rawIds[0])) || Number(rawIds[0]) <= 0) {
return {
ok: false,
code: 400,
message: 'id 必填且必须为正整数',
};
}
const normalizedIds = [];
for (const rawId of rawIds) {
const normalizedId = Number(rawId);
if (!Number.isInteger(normalizedId) || normalizedId <= 0) {
return {
ok: false,
code: 400,
message: 'ids 必须为正整数数组',
};
}
normalizedIds.push(normalizedId);
}
return {
ok: true,
ids: [ ...new Set(normalizedIds) ],
};
}
/**
* 查询当前仓库可访问的入库单。
* @param {number} id 入库单ID
* @return {Promise<Object|null>} 入库单实例
*/
async getOwnedEntryOrderById(id) {
const { ctx } = this;
return await ctx.model.EntryOrder.findOne({
where: {
id,
warehouse_id: ctx.user.store_id,
is_enabled: 1,
deleted_at: null,
},
});
}
/**
* 新增入库明细。
* @param {Object} data 请求体
* @return {Promise<Object>} code/data/message 结构
*/
async addDetail(data = {}) {
const { ctx } = this;
const orderId = Number(data.order_id || 0);
const count = Number(data.count || 0);
if (!orderId) {
return {
code: 400,
message: 'order_id 必填',
data: null,
};
}
if (!count || count <= 0) {
return {
code: 400,
message: 'count 必须大于 0',
data: null,
};
}
const entryOrder = await this.getOwnedEntryOrderById(orderId);
if (!entryOrder) {
return {
code: 404,
message: '入库单不存在或无权访问',
data: null,
};
}
if (entryOrder.order_status === 'CANCELLED' || entryOrder.order_status === 'COMPLETED') {
return {
code: 400,
message: '当前状态不允许新增明细',
data: null,
};
}
const maxLineNo = Number(await ctx.model.EntryItems.max('order_line_no', {
where: { order_id: orderId },
})) || 0;
const detail = await ctx.model.EntryItems.create({
order_id: orderId,
order_line_no: maxLineNo + 1,
item_code: data.item_code || '',
item_id: data.item_id || null,
stock_id: data.stock_id || data.item_id || null,
count,
inventory_type: data.inventory_type || 'ZP',
received_quantity: 0,
confirm_quantity: 0,
owner_code: data.owner_code || '',
out_biz_code: data.out_biz_code || '',
});
await entryOrder.update({
total_order_lines: maxLineNo + 1,
updated_at: new Date(),
});
return {
code: 200,
message: '新增明细成功',
data: {
id: detail.id,
order_id: orderId,
},
};
}
/**
* 删除入库明细。
* @param {Object} data 请求体
* @return {Promise<Object>} code/data/message 结构
*/
async deleteDetail(data = {}) {
const { ctx } = this;
const detailId = Number(data.id || 0);
if (!detailId) {
return {
code: 400,
message: 'id 必填',
data: null,
};
}
const detail = await ctx.model.EntryItems.findByPk(detailId);
if (!detail) {
return {
code: 404,
message: '明细不存在',
data: null,
};
}
const entryOrder = await this.getOwnedEntryOrderById(detail.order_id);
if (!entryOrder) {
return {
code: 404,
message: '入库单不存在或无权访问',
data: null,
};
}
if (Number(detail.received_quantity || 0) > 0) {
return {
code: 400,
message: '已有收货数量的明细不允许删除',
data: null,
};
}
await detail.destroy();
const lineCount = await ctx.model.EntryItems.count({ where: { order_id: entryOrder.id } });
await entryOrder.update({
total_order_lines: lineCount,
updated_at: new Date(),
});
return {
code: 200,
message: '删除明细成功',
data: {
id: detailId,
},
};
}
/**
* 修改入库明细。
* @param {Object} data 请求体
* @return {Promise<Object>} code/data/message 结构
*/
async detailChange(data = {}) {
const { ctx } = this;
const detailId = Number(data.id || 0);
if (!detailId) {
return {
code: 400,
message: 'id 必填',
data: null,
};
}
const detail = await ctx.model.EntryItems.findByPk(detailId);
if (!detail) {
return {
code: 404,
message: '明细不存在',
data: null,
};
}
const entryOrder = await this.getOwnedEntryOrderById(detail.order_id);
if (!entryOrder) {
return {
code: 404,
message: '入库单不存在或无权访问',
data: null,
};
}
const updateData = {};
const mutableFields = [ 'item_code', 'item_id', 'inventory_type', 'stock_id', 'out_biz_code', 'owner_code' ];
for (const field of mutableFields) {
if (Object.prototype.hasOwnProperty.call(data, field)) {
updateData[field] = data[field];
}
}
if (Object.prototype.hasOwnProperty.call(data, 'count')) {
const count = Number(data.count);
if (!count || count <= 0) {
return {
code: 400,
message: 'count 必须大于 0',
data: null,
};
}
if (Number(detail.received_quantity || 0) > count) {
return {
code: 400,
message: 'count 不能小于已收货数量',
data: null,
};
}
updateData.count = count;
}
if (Object.keys(updateData).length === 0) {
return {
code: 400,
message: '没有可更新字段',
data: null,
};
}
await detail.update(updateData);
return {
code: 200,
message: '修改明细成功',
data: {
id: detail.id,
},
};
}
/**
* 作废入库单。
* @param {Object} data 请求体
* @return {Promise<Object>} code/data/message 结构
*/
async cancel(data = {}) {
const { ctx } = this;
const normalizedResult = this.normalizeCancelEntryOrderIds(data);
if (!normalizedResult.ok) {
return {
code: normalizedResult.code || 400,
message: normalizedResult.message || '参数错误',
data: null,
};
}
const orderIds = normalizedResult.ids || [];
const entryOrders = [];
for (const orderId of orderIds) {
const entryOrder = await this.getOwnedEntryOrderById(orderId);
if (!entryOrder) {
return {
code: 404,
message: '入库单不存在或无权访问',
data: null,
};
}
if (entryOrder.order_status === 'COMPLETED') {
return {
code: 400,
message: '已完成入库单不允许作废',
data: null,
};
}
entryOrders.push(entryOrder);
}
const transaction = ctx.model && typeof ctx.model.transaction === 'function'
? await ctx.model.transaction()
: null;
try {
const updatedAt = new Date();
for (const entryOrder of entryOrders) {
await entryOrder.update({
order_status: 'CANCELLED',
updated_at: updatedAt,
}, transaction ? {
transaction,
} : undefined);
}
if (transaction && typeof transaction.commit === 'function') {
await transaction.commit();
}
} catch (error) {
if (transaction && typeof transaction.rollback === 'function') {
await transaction.rollback();
}
throw error;
}
return {
code: 200,
message: '作废成功',
data: {
[orderIds.length === 1 ? 'id' : 'ids']: orderIds.length === 1 ? entryOrders[0].id : orderIds,
},
};
}
/**
* 完成入库单。
* @param {Object} data 请求体
* @return {Promise<Object>} code/data/message 结构
*/
async completeEntry(data = {}) {
const { ctx } = this;
const orderId = Number(data.id || 0);
if (!orderId) {
return {
code: 400,
message: 'id 必填',
data: null,
};
}
const entryOrder = await this.getOwnedEntryOrderById(orderId);
if (!entryOrder) {
return {
code: 404,
message: '入库单不存在或无权访问',
data: null,
};
}
if (entryOrder.order_status === 'CANCELLED') {
return {
code: 400,
message: '已作废入库单不允许完成',
data: null,
};
}
const detailCount = await ctx.model.EntryItems.count({ where: { order_id: orderId } });
if (detailCount <= 0) {
return {
code: 400,
message: '请先添加入库明细',
data: null,
};
}
await entryOrder.update({
order_status: 'COMPLETED',
updated_at: new Date(),
});
return {
code: 200,
message: '完成成功',
data: {
id: entryOrder.id,
},
};
}
}
module.exports = EntryService;