WMS_MAIN/app/service/systems/warehouse_panel.js

1021 lines
42 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;
// 面板数据缓存 TTL(秒):缓存期内直接复用;过期视为无最后更新时间,重新聚合并兜底设置
const PANEL_CACHE_TTL_SECONDS = 300;
// 缓存键前缀(按仓库存储:{prefix}:lastChangeAt:{warehouseId})
const PANEL_CACHE_KEY_PREFIX = 'index:warehousePanel';
// 订单履约链路环节定义(每环节按未/已两个数值输出;field 为订单分表状态字段)
const FULFILLMENT_STAGES = [
{ key: 'alloc', icon: 'alloc', undone: '未分配', done: '已分配', field: 'post_status' },
{ key: 'print', icon: 'print', undone: '未打印', done: '已打印', field: 'print_status' },
{ key: 'pick', icon: 'pick', undone: '未拣货', done: '已拣货', field: 'pick_status' },
{ key: 'recheck', icon: 'recheck', undone: '未复核', done: '已复核', field: 'recheck_status' },
{ key: 'pack', icon: 'pack', undone: '未打包', done: '已打包', field: 'pack_status' },
{ key: 'ship', icon: 'ship', undone: '待出库', done: '已出库', field: 'outbound_status' },
];
// 拣货任务活跃状态(排除 9=已取消)
const PICK_TASK_ACTIVE_STATUSES = [ 0, 1, 2, 3 ];
class WarehousePanelService extends Service {
/**
* 面板缓存键(按仓库存储)。
*
* @param {number|string} warehouseId 仓库 ID
* @return {string} 缓存键
*/
getPanelCacheKey(warehouseId) {
return `${PANEL_CACHE_KEY_PREFIX}:lastChangeAt:${warehouseId}`;
}
/**
* 读取仓库自然日开始时间(wms_store.subject_config.day_start_time)。
*
* 配置缺失/非法/查询异常时回退默认 06:00。
*
* @param {number} warehouseId 仓库 ID
* @return {Promise<string>} HH:mm 格式时间(如 06:00)
*/
async getWarehouseDayStartTime(warehouseId) {
try {
const store = await this.ctx.model.Store.findOne({
where: { id: warehouseId, project: 'warehouse' },
attributes: [ 'subject_config' ],
raw: true,
});
let config = store && store.subject_config ? store.subject_config : {};
if (typeof config === 'string') {
try {
config = JSON.parse(config);
} catch (parseError) {
config = {};
}
}
const raw = config.day_start_time;
if (typeof raw === 'string' && /^([01]\d|2[0-3]):[0-5]\d$/.test(raw)) {
return raw;
}
return '06:00';
} catch (error) {
const logger = this.ctx.logger;
if (logger && typeof logger.warn === 'function') {
logger.warn(`[WarehousePanel] 读取自然日开始时间失败,回退 06:00: ${error.message}`);
}
return '06:00';
}
}
/**
* 解析业务日窗口 [businessStart, businessEnd)。
*
* 业务日从配置的 day_start_time 开始持续 24 小时;当前时间早于今日该时间点时,
* 窗口从昨日该时间点开始(昨日该时间点后的订单视为今日)。
*
* @param {number} warehouseId 仓库 ID
* @param {Date} now 当前时间
* @return {Promise<Array<Date>>} [ 业务日开始, 业务日结束 ]
*/
async resolveBusinessDayRange(warehouseId, now) {
const dayStartTime = await this.getWarehouseDayStartTime(warehouseId);
const [ hh, mm ] = dayStartTime.split(':').map(Number);
let businessStart = new Date(now.getFullYear(), now.getMonth(), now.getDate(), hh, mm, 0, 0);
if (now < businessStart) {
businessStart = new Date(businessStart.getTime() - 86400000);
}
return [ businessStart, new Date(businessStart.getTime() + 86400000) ];
}
/**
* 获取面板数据。
*
* 最后更新时间一般由外部驱动(业务数据变化时写入缓存键的 last_change_at);
* 本方法仅在缓存中没有最后更新时间时,才查库拉取数据并兜底设置最后更新时间。
*
* 拉取逻辑:
* - 缓存有最后更新时间:is_change=false(传入时间戳不小于缓存时间戳)时返回空 data(节约流量);
* is_change=true 时优先输出缓存数据;缓存无数据(外部只驱动了时间戳)则查库补数据并保留外部时间戳;
* - 缓存无最后更新时间(未命中/过期):查库拉数据并设置最后更新时间。
*
* is_change 语义:传入时间戳小于缓存最后更改时间戳时为 true。
*
* @param {number} warehouseId 仓库 ID
* @param {Object} [options] 选项
* @param {number} [options.lastChangeAt=0] 客户端持有的最后更改时间戳
* @return {Promise<Object>} 组装后的面板数据(含 title/fulfillment/stageOverview 等数据块)
*/
async getPanelData(warehouseId, options = {}) {
const lastChangeAt = Number(options.lastChangeAt || 0);
const cacheKey = this.getPanelCacheKey(warehouseId);
const cached = await this.app.getCacheAsync(cacheKey);
// 缓存有最后更新时间
if (cached && cached.last_change_at) {
const cachedTs = Number(cached.last_change_at);
const isChange = lastChangeAt < cachedTs;
// 未变化:空 data 节约流量,不查库
if (!isChange) {
return { is_change: false, last_change_at: cachedTs, data: {} };
}
// 已有缓存数据:直接输出,不查库
if (cached.data) {
return { is_change: true, last_change_at: cachedTs, data: cached.data };
}
// 外部只驱动了最后更新时间(无缓存数据):查库拉数据补入缓存,保留外部时间戳
const data = await this.buildPanelData(warehouseId);
await this.app.setCacheAsync(cacheKey, { last_change_at: cachedTs, data }, PANEL_CACHE_TTL_SECONDS);
return { is_change: true, last_change_at: cachedTs, data };
}
// 缓存无最后更新时间:查库拉数据并设置最后更新时间
const data = await this.buildPanelData(warehouseId);
const nowTs = Math.floor(Date.now() / 1000);
await this.app.setCacheAsync(cacheKey, { last_change_at: nowTs, data }, PANEL_CACHE_TTL_SECONDS);
return { is_change: true, last_change_at: nowTs, data };
}
/**
* 聚合全部面板数据块。
*
* 各数据块独立容错:单块查询失败时该块返回 null(前端按字段缺失处理),不影响其他块。
*
* @param {number} warehouseId 仓库 ID
* @return {Promise<Object>} 组装后的面板数据(含 title/fulfillment/stageOverview 等数据块)
*/
async buildPanelData(warehouseId) {
const { ctx } = this;
const { model } = ctx;
const { Op } = this.app.Sequelize;
const now = new Date();
const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
// 业务日窗口(仓库配置 day_start_time,默认 06:00):昨日 06:00 后的订单视为今日
const [ businessStart, businessEnd ] = await this.resolveBusinessDayRange(warehouseId, now);
const factory = model.OrderDeliveryFactory;
const [ currentModel, dispatchModel ] = await Promise.all([
factory.getCurrentModel(warehouseId),
factory.getDispatchModel(warehouseId),
]);
const currentTableName = currentModel.getTableName();
const dispatchTableName = dispatchModel.getTableName();
const pendingBase = {
step: { [Op.in]: [ 1, 2, 3 ] },
outbound_status: { [Op.ne]: 'padding' },
status: { [Op.ne]: 'cancel' },
};
const blocks = await Promise.all([
this.queryFulfillment(currentModel, dispatchModel, pendingBase, warehouseId, businessStart, businessEnd)
.catch(error => this.logBlockError('fulfillment', error)),
this.queryStageOverview(warehouseId, currentModel, dispatchModel, pendingBase, businessStart, businessEnd)
.catch(error => this.logBlockError('stageOverview', error)),
this.queryB2b(currentModel, dispatchModel, businessStart, businessEnd)
.catch(error => this.logBlockError('b2b', error)),
this.queryPickingBlock(warehouseId, currentTableName, dispatchTableName, true, businessStart, businessEnd)
.catch(error => this.logBlockError('groupPicking', error)),
this.queryPickingBlock(warehouseId, currentTableName, dispatchTableName, false, businessStart, businessEnd)
.catch(error => this.logBlockError('scatterPicking', error)),
this.queryPackingBlock(warehouseId, businessStart, businessEnd, true)
.catch(error => this.logBlockError('groupPacking', error)),
this.queryPackingBlock(warehouseId, businessStart, businessEnd, false)
.catch(error => this.logBlockError('scatterPacking', error)),
this.queryTrend(currentModel, dispatchModel, pendingBase, businessStart, businessEnd)
.catch(error => this.logBlockError('trend', error)),
this.queryWeeklyIntercept(currentModel, dispatchModel, todayStart)
.catch(error => this.logBlockError('weeklyEfficiency', error)),
]);
const [ fulfillment, stageOverview, b2b, groupPicking, scatterPicking, groupPacking, scatterPacking, trend, weeklyEfficiency ] = blocks;
// 趋势补充总单量字段(与 fulfillment.total 同口径:待处理订单池 + 配送表今日出库;
// fulfillment 块失败时兜底 0)
if (trend) {
trend.total = fulfillment ? (fulfillment.total || 0) : 0;
}
const data = {
title: ctx.user?.store_name || '',
fulfillment,
stageOverview,
b2b,
groupPicking,
scatterPicking,
groupPacking,
scatterPacking,
trend,
weeklyEfficiency,
};
return data;
}
/**
* 记录数据块聚合失败日志(返回 null,前端按字段缺失处理)。
*
* @param {string} blockName 数据块名
* @param {Error} error 异常
* @return {null} 恒返回 null(调用方将对应数据块置空)
*/
logBlockError(blockName, error) {
const logger = this.ctx.logger;
if (logger && typeof logger.warn === 'function') {
logger.warn(`[WarehousePanel] 数据块聚合失败,已跳过: ${blockName}`, error.message);
}
return null;
}
/**
* 订单履约链路:6 个环节 × 未/已 + 分母 + 今日退回指标。
*
* 配送表补数:已出库订单会从常用表迁移到配送分表(outbound_status=fin);
* 各环节未* = 池内未完成 + 配送表今日出库未完成(真实状态);
* 各环节已* 口径:分配/打印/拣货/打包从订单表状态获取(池内 fin + 配送表今日出库 fin,
* 保证已分配≥已打印≥已拣货≥已复核≥已打包的流程约束),
* 复核=今日复核时间(recheck_time)双表、出库=今日出库数。
*
* 今日退回收件数/今日拆包件数:按 wms_return_received / wms_return_unpack
* 的 created_at 落在今日(含今天 00:00)且仓库匹配统计,以两项追加在
* items 数组末尾(label/icon/value 与环节项同构)。
*
* @param {Object} currentModel 常用分表模型
* @param {Object} dispatchModel 配送分表模型
* @param {Object} pendingBase 待处理基础过滤
* @param {number} warehouseId 仓库 ID
* @param {Date} todayStart 今日开始
* @param {Date} tomorrowStart 明日开始
* @return {Promise<Object>} { total, items }(items 末尾追加今日退件/今日拆包两项)
*/
async queryFulfillment(currentModel, dispatchModel, pendingBase, warehouseId, todayStart, tomorrowStart) {
const { model } = this.ctx;
const { Op } = this.app.Sequelize;
const todayRange = { [Op.gte]: todayStart, [Op.lt]: tomorrowStart };
// 配送表今日出库且未取消:出库环节已*(今日出库数)与总数叠加(已迁移订单)
const dispatchTodayBase = {
status: { [Op.ne]: 'cancel' },
outbound_status: 'fin',
delivery_time: todayRange,
dispatch_lane: { [Op.in]: [ 'm4', 'm5' ] },
};
const totalCountPromise = currentModel.count({ where: pendingBase });
const dispatchTodayCountPromise = dispatchModel.count({ where: dispatchTodayBase });
// 各环节已* 口径:分配/打印/拣货/打包均从订单表状态获取(池内 fin + 配送表今日出库 fin),
// 保证已分配 ≥ 已打印 ≥ 已拣货 ≥ 已复核 ≥ 已打包 的流程约束;
// 注:打包环节此前用「今日打包任务订单数」口径,会大于已复核(打包任务快照含未复核/重复计入),
// 已改回订单状态存量口径(pack_status=fin);复核=今日复核时间、出库=今日出库数
const todayAllocOrdersPromise = Promise.all([
currentModel.count({ where: { ...pendingBase, post_status: 'fin' } }),
dispatchModel.count({ where: { ...dispatchTodayBase, post_status: 'fin' } }),
]).then(([ currentCount, dispatchCount ]) => currentCount + dispatchCount);
const todayPrintOrdersPromise = Promise.all([
currentModel.count({ where: { ...pendingBase, print_status: 'fin' } }),
dispatchModel.count({ where: { ...dispatchTodayBase, print_status: 'fin' } }),
]).then(([ currentCount, dispatchCount ]) => currentCount + dispatchCount);
const todayPickOrdersPromise = Promise.all([
currentModel.count({ where: { ...pendingBase, pick_status: 'fin' } }),
dispatchModel.count({
where: {
status: { [Op.ne]: 'cancel' },
outbound_status: 'fin',
pick_status: 'fin',
delivery_time: todayRange,
dispatch_lane: { [Op.in]: [ 'm4', 'm5' ] },
},
}),
]).then(([ currentCount, dispatchCount ]) => currentCount + dispatchCount);
const todayPackOrdersPromise = Promise.all([
currentModel.count({ where: { ...pendingBase, pack_status: 'fin' } }),
dispatchModel.count({ where: { ...dispatchTodayBase, pack_status: 'fin' } }),
]).then(([ currentCount, dispatchCount ]) => currentCount + dispatchCount);
const todayRecheckOrdersPromise = Promise.all([
currentModel.count({ where: { status: { [Op.ne]: 'cancel' }, recheck_time: todayRange } }),
dispatchModel.count({
where: {
status: { [Op.ne]: 'cancel' },
recheck_time: todayRange,
dispatch_lane: { [Op.in]: [ 'm4', 'm5' ] },
},
}),
]).then(([ currentCount, dispatchCount ]) => currentCount + dispatchCount);
const returnReceivedTodayPromise = model.ReturnReceived.count({
where: { warehouse_id: warehouseId, created_at: todayRange },
});
const returnUnpackTodayPromise = model.ReturnUnpack.count({
where: { warehouse_id: warehouseId, created_at: todayRange },
});
const stageCounts = await Promise.all(FULFILLMENT_STAGES.map(async stage => {
const [ undoneCurrent, dispatchFin, dispatchTodayOutbound, todayAlloc, todayPrint, todayPick, todayRecheck, todayPack ] = await Promise.all([
currentModel.count({
where: {
...pendingBase,
[Op.or]: [
{ [stage.field]: { [Op.ne]: 'fin' } },
{ [stage.field]: { [Op.is]: null } },
],
},
}),
dispatchModel.count({
where: { ...dispatchTodayBase, [stage.field]: 'fin' },
}),
dispatchTodayCountPromise,
todayAllocOrdersPromise,
todayPrintOrdersPromise,
todayPickOrdersPromise,
todayRecheckOrdersPromise,
todayPackOrdersPromise,
]);
// 已* 按环节取今日作业口径数据源;出库环节=今日出库数;
// 未* = 池内未完成 + 配送表今日出库未完成(真实状态)
const doneTodayMap = {
post_status: todayAlloc,
print_status: todayPrint,
pick_status: todayPick,
recheck_status: todayRecheck,
pack_status: todayPack,
outbound_status: dispatchTodayOutbound,
};
const doneToday = doneTodayMap[stage.field] || 0;
return {
undone: undoneCurrent + (dispatchTodayOutbound - dispatchFin),
done: doneToday,
};
}));
const [ total, dispatchTodayOutbound, returnReceivedToday, returnUnpackToday ] = await Promise.all([
totalCountPromise,
dispatchTodayCountPromise,
returnReceivedTodayPromise,
returnUnpackTodayPromise,
]);
const items = [];
FULFILLMENT_STAGES.forEach((stage, index) => {
const counts = stageCounts[index] || { undone: 0, done: 0 };
items.push({ label: stage.undone, icon: stage.icon, value: counts.undone || 0 });
items.push({ label: stage.done, icon: stage.icon, value: counts.done || 0 });
});
items.push({ label: '今日退件', icon: 'returnReceived', value: returnReceivedToday || 0 });
items.push({ label: '今日拆包', icon: 'returnUnpack', value: returnUnpackToday || 0 });
return { total: (total || 0) + dispatchTodayOutbound, items };
}
/**
* 执行一条 count 原生 SQL 并返回计数。
*
* @param {string} sql SQL 文本
* @param {Object} replacements 替换参数
* @return {Promise<number>} 计数结果
*/
async countSql(sql, replacements) {
const rows = await this.ctx.model.query(sql, {
replacements,
type: this.ctx.model.QueryTypes.SELECT,
});
const first = Array.isArray(rows) && rows.length > 0 ? rows[0] : null;
return Number(first && first.cnt || 0);
}
/**
* 作业环节概览:总量 + 拦截 + 5 张环节卡(缺数据源的字段不写入)。
*
* @param {number} warehouseId 仓库 ID
* @param {Object} currentModel 常用分表模型
* @param {Object} dispatchModel 配送分表模型(已出库订单迁移目标,今日出库双表合计)
* @param {Object} pendingBase 待处理基础过滤
* @param {Date} todayStart 今日开始
* @param {Date} tomorrowStart 明日开始
* @return {Promise<Object>} { totalOrders, interceptOrders, stages }
*/
async queryStageOverview(warehouseId, currentModel, dispatchModel, pendingBase, todayStart, tomorrowStart) {
const { model } = this.ctx;
const { Op } = this.app.Sequelize;
const todayRange = { [Op.gte]: todayStart, [Op.lt]: tomorrowStart };
const [
totalPending,
todayOutbound,
interceptOrders,
receivingToday,
receivingDoing,
shelfDoing,
pickToday,
pickDoing,
pickAbnormal,
recheckToday,
recheckDoing,
recheckAbnormal,
packToday,
packDoing,
packAbnormal,
] = await Promise.all([
currentModel.count({ where: pendingBase }),
Promise.all([
currentModel.count({
where: { step: 4, outbound_status: 'fin', status: { [Op.ne]: 'cancel' }, delivery_time: todayRange },
}),
dispatchModel.count({
where: {
status: { [Op.ne]: 'cancel' },
outbound_status: 'fin',
delivery_time: todayRange,
dispatch_lane: { [Op.in]: [ 'm4', 'm5' ] },
},
}),
]).then(([ currentCount, dispatchCount ]) => currentCount + dispatchCount),
currentModel.count({
where: { ...pendingBase, intercept_status: { [Op.not]: null, [Op.ne]: 'none' } },
}),
model.Receiving.count({ where: { warehouse_id: warehouseId, created_at: todayRange } }),
model.Receiving.count({ where: { warehouse_id: warehouseId, status: 'receiving' } }),
model.Receiving.count({
where: { warehouse_id: warehouseId, storage_status: { [Op.in]: [ 'waiting', 'partial' ] } },
}),
Promise.all([
currentModel.count({ where: { ...pendingBase, pick_status: 'fin' } }),
dispatchModel.count({
where: {
status: { [Op.ne]: 'cancel' },
outbound_status: 'fin',
pick_status: 'fin',
delivery_time: todayRange,
dispatch_lane: { [Op.in]: [ 'm4', 'm5' ] },
},
}),
]).then(([ currentCount, dispatchCount ]) => currentCount + dispatchCount),
this.countSql(
`SELECT COUNT(*) AS cnt FROM wms_wave_pick_task
WHERE warehouse_id = :warehouseId AND status = 1`,
{ warehouseId }
),
currentModel.count({ where: { ...pendingBase, pick_status: 'error' } }),
Promise.all([
currentModel.count({ where: { status: { [Op.ne]: 'cancel' }, recheck_time: todayRange } }),
dispatchModel.count({
where: {
status: { [Op.ne]: 'cancel' },
recheck_time: todayRange,
dispatch_lane: { [Op.in]: [ 'm4', 'm5' ] },
},
}),
]).then(([ currentCount, dispatchCount ]) => currentCount + dispatchCount),
model.WaveBatch.count({
where: {
warehouse_id: warehouseId,
recheck_start_time: { [Op.not]: null },
wave_status: { [Op.in]: [ 3, 4 ] },
},
}),
currentModel.count({ where: { ...pendingBase, recheck_status: 'error' } }),
this.countSql(
`SELECT
(SELECT COUNT(*) FROM wms_pack_task
WHERE warehouse_id = :warehouseId
AND create_time >= :start AND create_time < :end
AND status != 3 AND deleted_at IS NULL
AND pack_mode != 2)
+
(SELECT COUNT(*) FROM wms_order_wave_index
WHERE wave_id IN (
SELECT DISTINCT wave_id FROM wms_pack_task
WHERE warehouse_id = :warehouseId
AND create_time >= :start AND create_time < :end
AND status != 3 AND deleted_at IS NULL
AND pack_mode = 2
)) AS cnt`,
{ warehouseId, start: todayStart, end: tomorrowStart }
),
model.PackTask.count({ where: { warehouse_id: warehouseId, status: 1 } }),
model.PackTask.count({ where: { warehouse_id: warehouseId, status: 3 } }),
]);
const stages = [
{
key: 'receiving',
name: '收货',
icon: 'car',
tone: 'green',
today: receivingToday,
doing: receivingDoing,
},
{
key: 'shelf',
name: '上架',
icon: 'rack',
tone: 'amber',
doing: shelfDoing,
},
{
key: 'pick',
name: '拣货',
icon: 'cart',
tone: 'blue',
today: pickToday,
doing: pickDoing,
abnormal: pickAbnormal,
},
{
key: 'recheck',
name: '复核',
icon: 'scan',
tone: 'violet',
today: recheckToday,
doing: recheckDoing,
abnormal: recheckAbnormal,
},
{
key: 'pack',
name: '打包',
icon: 'box',
tone: 'cyan',
today: packToday,
doing: packDoing,
abnormal: packAbnormal,
},
];
return {
totalOrders: totalPending + todayOutbound,
interceptOrders,
stages,
};
}
/**
* B2B 今日出库统计(常用表 + 配送表双表聚合)。
*
* @param {Object} currentModel 常用分表模型
* @param {Object} dispatchModel 配送分表模型
* @param {Date} todayStart 今日开始
* @param {Date} tomorrowStart 明日开始
* @return {Promise<Object>} { orders, goods, sku }
*/
async queryB2b(currentModel, dispatchModel, todayStart, tomorrowStart) {
const { Op, fn, col, literal } = this.app.Sequelize;
const todayRange = { [Op.gte]: todayStart, [Op.lt]: tomorrowStart };
const where = {
is_b2b: 'Y',
status: { [Op.ne]: 'cancel' },
outbound_status: 'fin',
delivery_time: todayRange,
};
const attrs = [
[ fn('COUNT', literal('*')), 'orders' ],
[ fn('SUM', col('items_total')), 'goods' ],
[ fn('SUM', col('items_count')), 'sku' ],
];
const [ currentAgg, dispatchAgg ] = await Promise.all([
currentModel.findOne({ attributes: attrs, where, raw: true }),
dispatchModel.findOne({ attributes: attrs, where, raw: true }),
]);
return {
orders: Number(currentAgg?.orders || 0) + Number(dispatchAgg?.orders || 0),
goods: Number(currentAgg?.goods || 0) + Number(dispatchAgg?.goods || 0),
sku: Number(currentAgg?.sku || 0) + Number(dispatchAgg?.sku || 0),
};
}
/**
* 拣货统计块(团购 wave_scope IN (1,3);散单其余)。
*
* orders/goods/sku/wave 汇总按订单表状态口径(池内 pick fin + 配送表今日出库 pick fin,
* 与 fulfillment 已拣货一致,保证团购+散单=已拣货);
* top 按今日创建任务(pick_mode 1,5 团购 / 2,3,4 散单)按人聚合(任务口径)。
*
* @param {number} warehouseId 仓库 ID
* @param {string} currentTableName 常用分表名
* @param {string} dispatchTableName 配送分表名
* @param {boolean} isGroup true=团购(wave_scope 1/3);false=散单(其余)
* @param {Date} todayStart 今日开始
* @param {Date} tomorrowStart 明日开始
* @return {Promise<Object>} { orders, goods, sku, wave, top }
*/
async queryPickingBlock(warehouseId, currentTableName, dispatchTableName, isGroup, todayStart, tomorrowStart) {
const { model } = this.ctx;
const { QueryTypes } = model;
const scopeWhere = isGroup ? 'wave_scope IN (1, 3)' : 'wave_scope NOT IN (1, 3)';
const pickModes = isGroup ? [ 1, 5 ] : [ 2, 3, 4 ];
const replacements = {
warehouseId,
pickModes,
activeStatuses: PICK_TASK_ACTIVE_STATUSES,
start: todayStart,
end: tomorrowStart,
};
// top:今日创建任务按人聚合(任务口径)
const taskWindowWhere = `
t.warehouse_id = :warehouseId AND t.pick_mode IN (:pickModes)
AND t.create_time >= :start AND t.create_time < :end
AND t.status IN (:activeStatuses)
`;
// 汇总:订单表状态口径(池内 pick fin + 配送表今日出库 pick fin,与已拣货一致)
const summarySql = (tableName, whereFragment) => `
SELECT COUNT(*) AS orders, COALESCE(SUM(items_total), 0) AS goods,
COALESCE(SUM(items_count), 0) AS sku,
COUNT(DISTINCT CASE WHEN wave_id > 0 THEN wave_id END) AS wave
FROM \`${tableName}\` WHERE ${whereFragment}
`;
const poolWhere = `
step IN (1, 2, 3) AND outbound_status != 'padding' AND status != 'cancel'
AND pick_status = 'fin' AND ${scopeWhere}
`;
const dispatchWhere = `
status != 'cancel' AND outbound_status = 'fin' AND pick_status = 'fin'
AND dispatch_lane IN ('m4', 'm5')
AND delivery_time >= :start AND delivery_time < :end AND ${scopeWhere}
`;
const [ currentRows, dispatchRows, topRows ] = await Promise.all([
model.query(summarySql(currentTableName, poolWhere), { replacements, type: QueryTypes.SELECT }),
model.query(summarySql(dispatchTableName, dispatchWhere), { replacements, type: QueryTypes.SELECT }),
model.query(`
SELECT t.pick_user_id AS user_id, t.pick_user_name AS name,
COALESCE(SUM(t.order_count), 0) AS orders, COALESCE(SUM(t.wave_count), 0) AS waves
FROM wms_wave_pick_task t
WHERE ${taskWindowWhere}
GROUP BY t.pick_user_id, t.pick_user_name
ORDER BY orders DESC
LIMIT 5
`, { replacements, type: QueryTypes.SELECT }),
]);
const current = Array.isArray(currentRows) && currentRows.length > 0 ? currentRows[0] : {};
const dispatch = Array.isArray(dispatchRows) && dispatchRows.length > 0 ? dispatchRows[0] : {};
const summary = {
orders: Number(current.orders || 0) + Number(dispatch.orders || 0),
goods: Number(current.goods || 0) + Number(dispatch.goods || 0),
sku: Number(current.sku || 0) + Number(dispatch.sku || 0),
wave: Number(current.wave || 0) + Number(dispatch.wave || 0),
};
// top 的 goods/sku 仍按任务口径(订单表无拣货人,无法按人拆分)
const [ , topGoodsSkuRows ] = await this.queryPickingGoodsSku(
currentTableName, dispatchTableName, taskWindowWhere, replacements
);
const topGoodsSkuMap = new Map();
(topGoodsSkuRows || []).forEach(row => {
topGoodsSkuMap.set(String(row.user_id), { goods: Number(row.goods || 0), sku: Number(row.sku || 0) });
});
const top = (topRows || []).map((row, index) => {
const goodsSku = topGoodsSkuMap.get(String(row.user_id)) || { goods: 0, sku: 0 };
return {
rank: index + 1,
name: row.name || '',
orders: Number(row.orders || 0),
goods: goodsSku.goods,
sku: goodsSku.sku,
wave: Number(row.waves || 0),
};
});
return {
orders: summary.orders,
goods: summary.goods,
sku: summary.sku,
wave: summary.wave,
top,
};
}
/**
* 查询拣货任务的 goods/sku(总量 + 按人分组),经任务订单关联表 join 订单分表。
*
* @param {string} currentTableName 常用分表名
* @param {string} dispatchTableName 配送分表名
* @param {string} taskWindowWhere 任务窗口 where 片段
* @param {Object} replacements 替换参数
* @return {Promise<Array<Object>>} [ 总量行, top 行数组 ]
*/
async queryPickingGoodsSku(currentTableName, dispatchTableName, taskWindowWhere, replacements) {
const { model } = this.ctx;
const { QueryTypes } = model;
// 任务订单关联表缺失的任务(如 pick_mode=1 团购任务,实测 60 个任务 3862 单无 pto 记录)
// 按 wave_id 从订单分表统计,避免 goods/sku 漏算;有 pto 记录的仍走 pto 精确统计
const taskWindowWhere2 = taskWindowWhere.replace(/\bt\./g, 't2.');
const goodsSkuSelect = tableName => `
SELECT COALESCE(SUM(x.items_total), 0) AS goods, COALESCE(SUM(x.items_count), 0) AS sku
FROM (
SELECT od.items_total, od.items_count
FROM wms_wave_pick_task t
JOIN wms_wave_pick_task_order pto ON pto.task_id = t.id
JOIN \`${tableName}\` od ON od.id = pto.order_id AND od.status != 'cancel'
WHERE ${taskWindowWhere}
UNION ALL
SELECT od2.items_total, od2.items_count
FROM wms_wave_pick_task t2
JOIN \`${tableName}\` od2 ON od2.wave_id = t2.wave_id AND od2.status != 'cancel'
WHERE ${taskWindowWhere2} AND t2.wave_id > 0
AND NOT EXISTS (SELECT 1 FROM wms_wave_pick_task_order pto2 WHERE pto2.task_id = t2.id)
) x
`;
const topGoodsSkuSelect = tableName => `
SELECT t.pick_user_id AS user_id, COALESCE(SUM(g.items_total), 0) AS goods, COALESCE(SUM(g.items_count), 0) AS sku
FROM wms_wave_pick_task t
JOIN (
SELECT pto.task_id AS task_id, od.items_total, od.items_count
FROM wms_wave_pick_task_order pto
JOIN \`${tableName}\` od ON od.id = pto.order_id AND od.status != 'cancel'
UNION ALL
SELECT t2.id AS task_id, od2.items_total, od2.items_count
FROM wms_wave_pick_task t2
JOIN \`${tableName}\` od2 ON od2.wave_id = t2.wave_id AND od2.status != 'cancel'
WHERE ${taskWindowWhere2} AND t2.wave_id > 0
AND NOT EXISTS (SELECT 1 FROM wms_wave_pick_task_order pto2 WHERE pto2.task_id = t2.id)
) g ON g.task_id = t.id
WHERE ${taskWindowWhere}
GROUP BY t.pick_user_id
`;
const [ currentRows, dispatchRows, topCurrentRows, topDispatchRows ] = await Promise.all([
model.query(goodsSkuSelect(currentTableName), { replacements, type: QueryTypes.SELECT }),
model.query(goodsSkuSelect(dispatchTableName), { replacements, type: QueryTypes.SELECT }),
model.query(topGoodsSkuSelect(currentTableName), { replacements, type: QueryTypes.SELECT }),
model.query(topGoodsSkuSelect(dispatchTableName), { replacements, type: QueryTypes.SELECT }),
]);
const current = Array.isArray(currentRows) && currentRows.length > 0 ? currentRows[0] : {};
const dispatch = Array.isArray(dispatchRows) && dispatchRows.length > 0 ? dispatchRows[0] : {};
const totalGoodsSku = {
goods: Number(current.goods || 0) + Number(dispatch.goods || 0),
sku: Number(current.sku || 0) + Number(dispatch.sku || 0),
};
const topGoodsSkuMap = new Map();
[ ...(topCurrentRows || []), ...(topDispatchRows || []) ].forEach(row => {
const key = String(row.user_id);
const prev = topGoodsSkuMap.get(key) || { goods: 0, sku: 0 };
topGoodsSkuMap.set(key, {
goods: prev.goods + Number(row.goods || 0),
sku: prev.sku + Number(row.sku || 0),
});
});
return [ totalGoodsSku, [ ...topGoodsSkuMap.entries() ].map(([ user_id, item ]) => ({ user_id, ...item })) ];
}
/**
* 打包统计块(按波次范围区分:wave_scope 1 大团购/3 小团购为团购块,其余为散单块)。
*
* 口径:今日创建(create_time 今日)且非异常(status != 3)且未删除的任务;
* orders 按打包模式统计——pack_mode=2(团购模式)按 pack_quantity(波次订单数快照)
* 求和,pack_mode=1 散单每任务 1 单;
* 团购块 top 按打包台(wms_workbench.name)聚合;散单块 top 按打包员
* (pack_task_packer.account_name)聚合。
*
* @param {number} warehouseId 仓库 ID
* @param {Date} todayStart 今日开始
* @param {Date} tomorrowStart 明日开始
* @param {boolean} isGroup true=团购(wave_scope 1/3,top 按打包台);false=散单(wave_scope 非 1/3,top 按打包员)
* @return {Promise<Object>} { orders, goods, sku, wave, top }
*/
async queryPackingBlock(warehouseId, todayStart, tomorrowStart, isGroup) {
const { model } = this.ctx;
const { QueryTypes } = model;
const scopeWhere = isGroup ? 'pt.wave_scope IN (1, 3)' : 'pt.wave_scope NOT IN (1, 3)';
// 订单数口径:pack_mode=2(团购模式,含 wave_scope=3 小团购)按 pack_quantity 求和;散单每任务 1 单
const ordersExpr = 'SUM(CASE WHEN pt.pack_mode = 2 THEN pt.pack_quantity ELSE 1 END) AS orders';
const replacements = { warehouseId, start: todayStart, end: tomorrowStart };
const taskWindowWhere = `
pt.warehouse_id = :warehouseId AND ${scopeWhere}
AND pt.create_time >= :start AND pt.create_time < :end
AND pt.status != 3 AND pt.deleted_at IS NULL
`;
// 团购块按打包台聚合;散单块按打包员聚合
const topSql = isGroup
? `
SELECT COALESCE(w.name, '未指定打包台') AS name, ${ordersExpr},
COALESCE(SUM(pt.item_quantity), 0) AS goods,
COALESCE(SUM(pt.sku_count), 0) AS sku,
COUNT(DISTINCT CASE WHEN pt.wave_id > 0 THEN pt.wave_id END) AS wave
FROM wms_pack_task pt
LEFT JOIN wms_workbench w ON w.id = pt.workbench_id AND w.deleted_at IS NULL
WHERE ${taskWindowWhere}
GROUP BY pt.workbench_id, w.name
ORDER BY orders DESC
LIMIT 5
`
: `
SELECT pp.account_name AS name, ${ordersExpr},
COALESCE(SUM(pt.item_quantity), 0) AS goods,
COALESCE(SUM(pt.sku_count), 0) AS sku,
COUNT(DISTINCT CASE WHEN pt.wave_id > 0 THEN pt.wave_id END) AS wave
FROM wms_pack_task pt
JOIN wms_pack_task_packer pp ON pp.pack_task_id = pt.id AND pp.deleted_at IS NULL
WHERE ${taskWindowWhere}
GROUP BY pp.account_name
ORDER BY orders DESC
LIMIT 5
`;
const [ summaryRows, topRows ] = await Promise.all([
model.query(`
SELECT ${ordersExpr}, COALESCE(SUM(pt.item_quantity), 0) AS goods,
COALESCE(SUM(pt.sku_count), 0) AS sku,
COUNT(DISTINCT CASE WHEN pt.wave_id > 0 THEN pt.wave_id END) AS wave
FROM wms_pack_task pt
WHERE ${taskWindowWhere}
`, { replacements, type: QueryTypes.SELECT }),
model.query(topSql, { replacements, type: QueryTypes.SELECT }),
]);
const summary = Array.isArray(summaryRows) && summaryRows.length > 0 ? summaryRows[0] : {};
const top = (topRows || []).map((row, index) => ({
rank: index + 1,
name: row.name || '',
orders: Number(row.orders || 0),
goods: Number(row.goods || 0),
sku: Number(row.sku || 0),
wave: Number(row.wave || 0),
}));
return {
orders: Number(summary.orders || 0),
goods: Number(summary.goods || 0),
sku: Number(summary.sku || 0),
wave: Number(summary.wave || 0),
top,
};
}
/**
* 今日订单实时趋势(业务日窗口 24 点,label 从仓库自然日开始时间起每小时一点,到次日自然日开始时间)。
* created_count:业务日窗口内下单量(池内待处理 + 配送表今日出库订单,按订单创建时间落桶)
* 按小时累计(最后一点=业务日内下单总量);窗口即业务日:未到次日自然日开始时间时
* 为 [今日自然日开始时间, 次日自然日开始时间),凌晨(已过零点)时为 [昨日自然日开始时间, 今日自然日开始时间)。
*
* @param {Object} currentModel 常用分表模型
* @param {Object} dispatchModel 配送分表模型
* @param {Object} pendingBase 待处理基础过滤
* @param {Date} todayStart 业务日开始时间(仓库自然日 day_start_time)
* @param {Date} tomorrowStart 业务日结束时间(次日自然日开始时间)
* @return {Promise<Object>} { max, points },points 每项 { label, created_count }
*/
async queryTrend(currentModel, dispatchModel, pendingBase, todayStart, tomorrowStart) {
const { Op, fn, col, literal } = this.app.Sequelize;
// 横轴 24 点:从自然日开始时间起每小时一点(跨天,label=桶起点 HH:00)
const points = [];
const bucketByHour = new Map();
for (let index = 0; index < 24; index++) {
const bucketStart = new Date(todayStart.getTime() + index * 3600000);
bucketByHour.set(bucketStart.getHours(), index);
points.push({
label: `${String(bucketStart.getHours()).padStart(2, '0')}:00`,
created_count: 0,
});
}
const bucketIndexOf = hour => {
const bucket = bucketByHour.get(Number(hour));
return bucket === undefined ? 0 : bucket;
};
// 下单量按创建时间落桶(池内待处理 + 配送表今日出库,窗口=业务日 [todayStart, tomorrowStart))
const dispatchTodayBase = {
status: { [Op.ne]: 'cancel' },
outbound_status: 'fin',
delivery_time: { [Op.gte]: todayStart, [Op.lt]: tomorrowStart },
dispatch_lane: { [Op.in]: [ 'm4', 'm5' ] },
};
const [
createdRows,
dispatchCreatedRows,
] = await Promise.all([
currentModel.findAll({
attributes: [
[ fn('HOUR', col('create_at')), 'hour' ],
[ fn('COUNT', literal('*')), 'count' ],
],
where: { ...pendingBase, create_at: { [Op.gte]: todayStart, [Op.lt]: tomorrowStart } },
group: [ 'hour' ],
raw: true,
}),
dispatchModel.findAll({
attributes: [
[ fn('HOUR', col('create_at')), 'hour' ],
[ fn('COUNT', literal('*')), 'count' ],
],
where: { ...dispatchTodayBase, create_at: { [Op.gte]: todayStart, [Op.lt]: tomorrowStart } },
group: [ 'hour' ],
raw: true,
}),
]);
[ ...(createdRows || []), ...(dispatchCreatedRows || []) ].forEach(row => {
points[bucketIndexOf(row.hour)].created_count += Number(row.count || 0);
});
// 累计口径:每点为截至该小时结束的累计总数(最后一点=业务日内下单总量)
for (let index = 1; index < points.length; index++) {
points[index].created_count += points[index - 1].created_count;
}
const peak = points.reduce(
(maxValue, point) => Math.max(maxValue, point.created_count),
0
);
const max = Math.max(Math.ceil(peak / 10) * 10, 10);
return { max, points };
}
/**
* 近 7 日拦截量按天统计(时间锚点:intercept_time,为空时回落 create_at)。
*
* 吞吐量(throughput)口径未定义,暂不输出;仅输出 days[].intercept。
*
* @param {Object} currentModel 常用分表模型
* @param {Object} dispatchModel 配送分表模型
* @param {Date} todayStart 今日开始
* @return {Promise<Object>} { days }
*/
async queryWeeklyIntercept(currentModel, dispatchModel, todayStart) {
const { Op, fn, col, literal } = this.app.Sequelize;
const sevenDaysAgo = new Date(todayStart.getTime() - 6 * 86400000);
const tomorrowStart = new Date(todayStart.getTime() + 86400000);
const anchor = fn('COALESCE', col('intercept_time'), col('create_at'));
const where = {
[Op.and]: [
{ intercept_status: { [Op.not]: null, [Op.ne]: 'none' } },
this.app.Sequelize.where(anchor, { [Op.gte]: sevenDaysAgo, [Op.lt]: tomorrowStart }),
],
};
const attributes = [
[ fn('DATE', anchor), 'day' ],
[ fn('COUNT', literal('*')), 'count' ],
];
const [ currentRows, dispatchRows ] = await Promise.all([
currentModel.findAll({ attributes, where, group: [ 'day' ], raw: true }),
dispatchModel.findAll({ attributes, where, group: [ 'day' ], raw: true }),
]);
const dayMap = new Map();
[ ...(currentRows || []), ...(dispatchRows || []) ].forEach(row => {
const dayKey = this.normalizeDayKey(row.day);
if (!dayKey) {
return;
}
dayMap.set(dayKey, (dayMap.get(dayKey) || 0) + Number(row.count || 0));
});
const days = [];
for (let offset = 6; offset >= 0; offset--) {
const day = new Date(todayStart.getTime() - offset * 86400000);
const dayKey = this.formatDateKey(day);
const label = `${String(day.getMonth() + 1).padStart(2, '0')}-${String(day.getDate()).padStart(2, '0')}`;
days.push({ label, intercept: dayMap.get(dayKey) || 0 });
}
return { days };
}
/**
* 归一化日期分组键(DATE() 结果可能为 Date 对象或 'YYYY-MM-DD' 字符串)。
*
* @param {*} value 分组值
* @return {string} 'YYYY-MM-DD'
*/
normalizeDayKey(value) {
if (!value) {
return '';
}
if (value instanceof Date) {
return this.formatDateKey(value);
}
const text = String(value);
return text.length >= 10 ? text.slice(0, 10) : text;
}
/**
* 格式化为本地日期键 'YYYY-MM-DD'。
*
* @param {Date} date 日期
* @return {string} 'YYYY-MM-DD'
*/
formatDateKey(date) {
return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
}
}
module.exports = WarehousePanelService;