688 lines
17 KiB
JavaScript
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;
|