2026-03-25 23:26:10 +08:00

688 lines
17 KiB
JavaScript

'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,
},
};
}
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 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 === 'COMPLETED') {
return {
code: 400,
message: '已完成入库单不允许作废',
data: null,
};
}
await entryOrder.update({
order_status: 'CANCELLED',
updated_at: new Date(),
});
return {
code: 200,
message: '作废成功',
data: {
id: entryOrder.id,
},
};
}
/**
* 完成入库单。
* @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;