WEB/src/views/order/waveOrder/config/wave-config.ts
2026-10-20 18:00:51 +08:00

1855 lines
71 KiB
TypeScript
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.

/** 波次管理页面配置 */
export const WAVE_PAGE_CONFIG = {
/**
* 单页模式:开启后不显示「团购波次」「散单波次」等标签切换区域,
* 直接展示默认页签(团购波次)的内容
*/
singlePage: false
}
import {
buyerMessageHasFilterOptions,
scanBasicField,
scanWorkflowField,
type ToolbarButtonConfig,
type UpperTableCopyAction
} from '@/views/order/orderManagement/config/order-common-config'
import type { WavePlatformPrintDataPayload } from '@/api/order.print/orderprint'
import type { WaveStrategyCreateParams, WaveStrategyUpdateParams } from '@/api/order.wave/orderwave'
import { orderPendingOrder } from '@/api/order.pendingorder/orderpendingOrder'
import {
isOrderIndexApiSuccess,
normalizeOrderDetailItems,
parseOrderDetailPayload,
parseOrderListResponse
} from '@/views/order/orderManagement/utils/order-index-helpers'
import { resolveRowBarcode } from '@/utils/barcode'
/** ScanBox 筛选字段分组(波次模块专用,策略/散单候选等页仍可使用) */
export const WAVE_SCAN_FIELD_GROUPS = {
wave: '波次信息',
process: '流程状态',
logistics: '物流信息',
person: '人员信息',
stats: '商品统计',
strategy: '策略配置',
task: '任务信息',
status: '状态筛选',
time: '时间范围',
} as const
type WaveScanFieldGroupKey = keyof typeof WAVE_SCAN_FIELD_GROUPS
/** 为波次 ScanBox 字段附加分组标签 */
export function waveScanField<G extends WaveScanFieldGroupKey>(
group: G,
field: Record<string, any>
) {
return { ...field, group: WAVE_SCAN_FIELD_GROUPS[group] }
}
/** 波次列表 ScanBox:基础信息分组(对齐待处理订单「订单基础信息」排版) */
export const WAVE_SCAN_BASIC_INFO_GROUP = '波次信息'
/** 波次列表 ScanBox:流程状态分组(对齐待处理订单「流程状态」,所有流程字段归入一组) */
export const WAVE_SCAN_PROCESS_STATUS_GROUP = '流程状态'
/** 波次列表 ScanBox:订单统计分组 */
export const WAVE_SCAN_STATS_GROUP = '订单统计'
/** 波次列表 ScanBox:其他信息分组 */
export const WAVE_SCAN_OTHER_GROUP = '其他信息'
/** 拣货任务 ScanBox:基础信息分组 */
export const PICK_TASK_SCAN_BASIC_INFO_GROUP = '任务信息'
/** 拣货任务 ScanBox:流程状态分组(对齐波次列表,所有流程字段归入一组) */
export const PICK_TASK_SCAN_PROCESS_STATUS_GROUP = '流程状态'
/** 波次列表 ScanBox 基础信息字段 */
export function waveScanBasicField(field: Record<string, any>) {
return { ...field, group: WAVE_SCAN_BASIC_INFO_GROUP }
}
/** 拣货任务 ScanBox 基础信息字段 */
export function pickTaskScanBasicField(field: Record<string, any>) {
return { ...field, group: PICK_TASK_SCAN_BASIC_INFO_GROUP }
}
/** 工具栏按钮:可限定仅在对应波次页签显示(1 团购 / 2 散单) */
export type WaveToolbarButtonConfig = ToolbarButtonConfig & {
onlyForWaveType?: 1 | 2
}
/** ScanBox 默认 props(全站 scan-box 侧栏宽度统一为 220px) */
export const waveScanBoxConfig = {
width: '220px',
treeProps: { children: 'children', label: 'label' } as const,
autoSubmit: false
}
/** 主表 UpperTable 展示与行为默认值 */
export const waveUpperTableDefaults = {
title: '波次列表',
enableColumnConfig: true,
showIndex: true,
showSelection: true,
emptyText: '暂无波次数据'
}
/** 左侧筛选可用字段(对标待处理订单 ScanBox 分组排序) */
export const waveAvailableFields = [
// ===== 波次信息 =====
waveScanBasicField({ label: '波次号', value: 'wave_no', type: 'text' }),
waveScanBasicField({
label: '货主',
value: 'store_id',
type: 'select',
// options 由页面加载货主列表后动态注入(indexApi.loadStores)
options: []
}),
waveScanBasicField({
label: '波次类型',
value: 'wave_type',
type: 'select',
options: [
{ label: '团购', value: 1 },
{ label: '散单', value: 2 }
]
}),
waveScanBasicField({
label: '波次状态',
value: 'wave_status',
type: 'select',
options: [
{ label: '自动加团中', value: 0 },
{ label: '已就绪', value: 1 }
]
}),
// ===== 流程状态(合并为一组,对齐待处理订单 ScanBox) =====
{ ...scanWorkflowField({
label: '库位分配',
value: 'storage_assignment_status',
type: 'select',
options: [
{ label: '未分配', value: '未分配' },
{ label: '部分分配', value: '部分分配' },
{ label: '已分配', value: '已分配' },
]
}), group: WAVE_SCAN_PROCESS_STATUS_GROUP },
{ ...scanWorkflowField({
label: '快递分配',
value: 'express_assignment_status',
type: 'select',
options: [
{ label: '未分配', value: 'unassigned' },
{ label: '部分分配', value: 'partially_assigned' },
{ label: '已分配', value: 'assigned' },
]
}), group: WAVE_SCAN_PROCESS_STATUS_GROUP },
{ ...scanWorkflowField({
label: '打印状态',
value: 'print_assignment_status',
type: 'select',
options: [
{ label: '未打印', value: 'unprinted' },
{ label: '部分打印', value: 'partially_printed' },
{ label: '已打印', value: 'printed' },
]
}), group: WAVE_SCAN_PROCESS_STATUS_GROUP },
{
// order.wave.batchList where:仅 eq,英文枚举 unconfirmed/partially_confirmed/confirmed
// (列表返回的是中文文案 未确认打印/部分确认打印/已确认打印,与筛选入参是两套)
...scanWorkflowField({
label: '确认打印状态',
value: 'confirm_print_assignment_status',
type: 'select',
options: [
{ label: '未确认打印', value: 'unconfirmed' },
{ label: '部分确认打印', value: 'partially_confirmed' },
{ label: '已确认打印', value: 'confirmed' },
]
}),
group: WAVE_SCAN_PROCESS_STATUS_GROUP
},
{
// order.wave.batchList where:仅 eq,英文枚举 unclaimed/claimed(二态),也兼容中文 未领料/已领料
...scanWorkflowField({
label: '领料状态',
value: 'claim_assignment_status',
type: 'select',
options: [
{ label: '未领料', value: 'unclaimed' },
{ label: '已领料', value: 'claimed' },
]
}),
group: WAVE_SCAN_PROCESS_STATUS_GROUP
},
{
// ⚠️ 文档差异(2026-09-21 快照):order.wave.batchList 的 where 描述【字段清单】未列 pick_assignment_status,
// 但响应仍返回该字段、本页与 waveOrder2「拣货状态」tab 一直按它筛选 → 暂判为文档漏列,保留筛选项;
// 若后端确已收紧白名单(不在允许集合内返回 400),需同步移除本页 + waveOrder2 的该筛选项。
...scanWorkflowField({
label: '拣货状态',
value: 'pick_assignment_status',
type: 'select',
options: [
{ label: '未拣货', value: 'unpicked' },
{ label: '部分拣货', value: 'partially_picked' },
{ label: '已拣货', value: 'picked' },
]
}),
group: WAVE_SCAN_PROCESS_STATUS_GROUP
},
{ ...scanWorkflowField({
label: '复核状态',
value: 'review_assignment_status',
type: 'select',
options: [
{ label: '未复核', value: 'unreviewed' },
{ label: '部分复核', value: 'partially_reviewed' },
{ label: '已复核', value: 'reviewed' },
]
}), group: WAVE_SCAN_PROCESS_STATUS_GROUP },
{
// order.wave.batchList where:仅 eq,英文枚举 unsynced/partially_synced/synced
// (同步异常 error 在后端并入未同步集合,故筛选无独立「同步异常」项)
...scanWorkflowField({
label: '同步状态',
value: 'sync_assignment_status',
type: 'select',
options: [
{ label: '未同步', value: 'unsynced' },
{ label: '部分同步', value: 'partially_synced' },
{ label: '已同步', value: 'synced' },
]
}),
group: WAVE_SCAN_PROCESS_STATUS_GROUP
},
// ===== 订单统计 =====
{ ...waveScanBasicField({ label: '最小订单数', value: 'total_orders_min', type: 'number' }), group: WAVE_SCAN_STATS_GROUP },
{ ...waveScanBasicField({ label: '最大订单数', value: 'total_orders_max', type: 'number' }), group: WAVE_SCAN_STATS_GROUP },
{ ...waveScanBasicField({ label: '最小已处理订单', value: 'processed_orders_min', type: 'number' }), group: WAVE_SCAN_STATS_GROUP },
{ ...waveScanBasicField({ label: '最大已处理订单', value: 'processed_orders_max', type: 'number' }), group: WAVE_SCAN_STATS_GROUP },
// ===== 其他信息 =====
{ ...waveScanBasicField({
label: '区分快递',
value: 'distinguish_express',
type: 'select',
options: [
{ label: '是', value: 1 },
{ label: '否', value: 0 }
]
}), group: WAVE_SCAN_OTHER_GROUP },
{ ...waveScanBasicField({
label: '来源',
value: 'source',
type: 'select',
options: [
{ label: '普通波次', value: 0 },
{ label: '后台策略', value: 1 },
{ label: 'PDA策略', value: 2 }
]
}), group: WAVE_SCAN_OTHER_GROUP },
{ ...waveScanBasicField({ label: '快递', value: 'logistics_name', type: 'text' }), group: WAVE_SCAN_OTHER_GROUP },
{ ...waveScanBasicField({ label: '创建人', value: 'creator', type: 'text' }), group: WAVE_SCAN_OTHER_GROUP },
]
/** 抓取散单候选:左侧筛选可用字段 */
export const fallbackOrderAvailableFields = [
scanBasicField({ label: '订单号', value: 'delivery_no', type: 'text' }),
scanBasicField({ label: '物流单号', value: 'tracking_no', type: 'text' }),
scanBasicField({ label: '店铺名称', value: 'store_name', type: 'text' }),
scanBasicField({ label: '平台', value: 'sys_platform_name', type: 'select', options: [] }),
scanBasicField({ label: '物流公司', value: 'sys_logistics_name', type: 'select', options: [] }),
waveScanField('stats', { label: '商品种数最小值', value: 'items_count_min', type: 'number' }),
waveScanField('stats', { label: '商品种数最大值', value: 'items_count_max', type: 'number' }),
waveScanField('stats', { label: '商品总数最小值', value: 'items_total_min', type: 'number' }),
waveScanField('stats', { label: '商品总数最大值', value: 'items_total_max', type: 'number' }),
scanBasicField({
label: '有无留言',
value: 'buyer_message_has',
type: 'select',
options: buyerMessageHasFilterOptions
}),
scanBasicField({ label: '买家留言', value: 'buyer_message', type: 'text' }),
]
const WAVE_LIST_COPY_ACTIONS: Record<string, UpperTableCopyAction> = {
wave_no: 'copy',
delivery_no: 'copy',
tracking_no: 'copyQr',
task_no: 'copy',
}
const WAVE_LIST_COPY_VALUE_KEYS: Record<string, string[]> = {
wave_no: ['wave_no', 'wave_code', 'batch_code', 'batch_no', 'code'],
delivery_no: ['delivery_no', 'delivery_order_code', 'order_sn'],
tracking_no: ['tracking_no', 'tracking_number'],
}
export function applyWaveListCopyActions<
T extends { prop: string; formatter?: unknown; copyAction?: UpperTableCopyAction; copyValueKeys?: string[] }
>(columns: T[]): T[] {
return columns.map((col) => {
const copyAction = col.copyAction ?? WAVE_LIST_COPY_ACTIONS[col.prop]
if (!copyAction) return col
const copyValueKeys = col.copyValueKeys ?? WAVE_LIST_COPY_VALUE_KEYS[col.prop]
if (copyAction === 'copyQr') {
const { formatter, ...rest } = col
return {
...rest,
copyAction,
...(copyValueKeys ? { copyValueKeys } : {})
} as unknown as T
}
return {
...col,
copyAction,
...(copyValueKeys ? { copyValueKeys } : {})
} as T
})
}
export function getPickTaskWaveNos(row: any): string[] {
if (!Array.isArray(row?.wave_list) || !row.wave_list.length) return []
return row.wave_list
.map((wave: any) => String(wave?.wave_no ?? '').trim())
.filter(Boolean)
}
/** 不符合波次策略订单列表:UpperTable 列配置 */
export const fallbackOrderColumns = applyWaveListCopyActions([
// { prop: 'id', label: 'ID', width: 80, align: 'center', fixed: 'left' },
// 序号列不启用(:show-index 未在 UpperTable 实现,序号由后端 wave_index 字段提供)
// { prop: 'wave_index', label: '序号', width: 70, align: 'center' },
{ prop: 'delivery_no', label: '订单号', minWidth: 180, fixed: 'left' },
{ prop: 'tracking_no', label: '物流单号', minWidth: 160 },
{ prop: 'store_name', label: '店铺', minWidth: 140 },
{ prop: 'sys_platform_name', label: '平台', minWidth: 120 },
{ prop: 'sys_logistics_name', label: '物流公司', minWidth: 130 },
{ prop: 'province', label: '省份', minWidth: 100 },
{ prop: 'weight_type', label: '重量类型', minWidth: 100 },
{ prop: 'items_count', label: '商品种数', minWidth: 100, sortable: 'custom' as const },
{ prop: 'items_total', label: '商品总数', minWidth: 100, sortable: 'custom' as const },
{ prop: 'items_weight', label: '商品重量(g)', minWidth: 110 },
{ prop: 'item_snapshot', label: '商品快照', minWidth: 260 },
{ prop: 'excluded_reason', label: '排除原因', minWidth: 130 }
])
/** 波次策略:左侧筛选可用字段 */
export const waveStrategyAvailableFields = [
waveScanField('strategy', { label: '策略名称', value: 'strategy_name', type: 'text' }),
waveScanField('strategy', {
label: '策略类型',
value: 'strategy_type',
type: 'select',
options: [
{ label: '散单', value: 1 },
{ label: '团购', value: 2 }
]
}),
waveScanField('strategy', { label: '波次前缀', value: 'wave_prefix', type: 'text' }),
waveScanField('status', {
label: '启用状态',
value: 'status',
type: 'select',
options: [
{ label: '启用', value: 1 },
{ label: '停用', value: 0 }
]
}),
waveScanField('status', {
label: '批次模式',
value: 'batch_mode',
type: 'select',
options: [
{ label: '团购', value: 0 },
{ label: '单品单件', value: 1 },
{ label: '先拣后分', value: 2 },
{ label: '边拣边分', value: 3 },
{ label: '边拣边分H型', value: 4 },
{ label: '播种墙', value: 5 },
{ label: '流利架', value: 6 }
]
}),
]
/** 波次策略:UpperTable 列配置 */
export const waveStrategyColumns = [
// { prop: 'id', label: 'ID', width: 72, align: 'center', fixed: 'left' },
{ prop: 'strategy_name', label: '策略名称', minWidth: 160, fixed: 'left' },
{ prop: 'wave_prefix', label: '波次前缀', width: 100, align: 'center' },
{ prop: 'matched_order_count_filtered', label: '匹配订单数', width: 110, align: 'center', sortable: true },
{ prop: 'next_fetch_order_count', label: '下一波抓取数量', width: 130, align: 'center' },
{ prop: 'strategy_type', label: '策略类型', width: 90, align: 'center' },
{ prop: 'status', label: '状态', width: 80, align: 'center' },
{ prop: 'batch_mode', label: '批次模式', width: 110, align: 'center' },
{ prop: 'sku_range', label: 'SKU区间', minWidth: 120, align: 'center' },
{ prop: 'qty_range', label: '件数区间', minWidth: 120, align: 'center' },
{ prop: 'same_structure_range', label: '同结构区间', minWidth: 130, align: 'center' },
{ prop: 'require_same_express', label: '同快递', width: 80, align: 'center' },
{ prop: 'allow_cross_owner', label: '跨货主', width: 80, align: 'center' },
{ prop: 'batch_max_orders', label: '单波最大订单', width: 120, align: 'center' },
{ prop: 'batch_max_skus', label: '单波最大SKU', width: 120, align: 'center' },
{ prop: 'group_batch_max_orders', label: '团购单波最大', width: 120, align: 'center' },
// { prop: 'warehouse_id', label: '仓库ID', width: 90, align: 'center' },
{ prop: 'creator_name', label: '创建人', width: 100, align: 'center' },
// { prop: 'allowed_expresses', label: '允许快递', minWidth: 130 },
{ prop: 'allowed_provinces', label: '允许省份', minWidth: 130 },
{ prop: 'allowed_platforms', label: '允许平台', minWidth: 130 },
{ prop: 'description', label: '说明', minWidth: 160 },
{ prop: 'create_time', label: '创建时间', minWidth: 168 },
{ prop: 'update_time', label: '更新时间', minWidth: 168 },
{ prop: 'operation', label: '操作', width: 140, fixed: 'right', align: 'center' }
]
/** 主表列配置 */
export const waveBatchColumns = applyWaveListCopyActions([
// { prop: 'wave_id', label: '波次ID', minWidth: 160, fixed: 'left' },
{ prop: 'wave_no', label: '波次号', minWidth: 180, fixed: 'left' },
{ prop: 'store_name', label: '货主', minWidth: 120 },
{ prop: 'wave_type', label: '波次类型', minWidth: 96 },
{ prop: 'wave_status', label: '波次状态', minWidth: 110 },
{ prop: 'total_orders', label: '总订单数', minWidth: 110, sortable: true },
{ prop: 'order_count', label: '订单数量', minWidth: 100, sortable: true },
{ prop: 'processed_orders', label: '已处理订单', minWidth: 108, sortable: true },
// { prop: 'item_detail_machine', label: '商品结构', minWidth: 320 },
// { prop: 'item_part_type', label: '商品类型', minWidth: 120 },
// { prop: 'item_part', label: '商品部位', minWidth: 220 },
{ prop: 'distinguish_express', label: '区分快递', minWidth: 100 },
{ prop: 'source', label: '来源', minWidth: 100 },
// { prop: 'logistics_code', label: '快递编码', minWidth: 110 },
{ prop: 'storage_assignment_status', label: '库位分配', minWidth: 120 },
{ prop: 'express_assignment_status', label: '快递分配', minWidth: 120 },
{ prop: 'print_assignment_status', label: '打印状态', minWidth: 110 },
{ prop: 'confirm_print_assignment_status', label: '确认打印状态', minWidth: 120 },
{ prop: 'claim_assignment_status', label: '领料状态', minWidth: 110 },
{ prop: 'pick_assignment_status', label: '拣货状态', minWidth: 110 },
{ prop: 'review_assignment_status', label: '复核状态', minWidth: 110 },
{ prop: 'sync_assignment_status', label: '同步状态', minWidth: 110 },
{ prop: 'unreviewed_order_count', label: '未复核数', minWidth: 96, sortable: true },
{ prop: 'logistics_name', label: '快递', minWidth: 120 },
{ prop: 'creator', label: '创建人', minWidth: 100 },
// { prop: 'warehouse_id', label: '仓库ID', minWidth: 110 },
{ prop: 'create_time', label: '创建时间', minWidth: 168 },
{ prop: 'update_time', label: '更新时间', minWidth: 168 },
{ prop: 'operation', label: '操作', minWidth: 140, fixed: 'right' }
])
/**
* 「抓取团购单」弹窗:可抓取结构列表列配置(UpperTable)
* 注:货主 / 状态汇总 / 商品快照 / 首末单时间由面板插槽渲染(column-<prop>)
*/
export const waveGroupOrderColumns = [
{ prop: 'item_detail', label: '商品结构', minWidth: 260, showOverflowTooltip: true },
{ prop: 'logistics_name', label: '快递', minWidth: 130, showOverflowTooltip: true },
{ prop: 'group_count', label: '同组订单数', minWidth: 100, align: 'right' },
{ prop: 'items_total', label: '商品总数', minWidth: 100, align: 'right' },
{ prop: 'store_name', label: '货主', minWidth: 110 },
{ prop: 'status_summary', label: '状态汇总', minWidth: 240 },
{ prop: 'item_snapshot_text', label: '商品快照', minWidth: 280 },
{ prop: 'first_order_time', label: '首单时间', minWidth: 168 },
{ prop: 'last_order_time', label: '末单时间', minWidth: 168 }
]
/** 列表查询 where 白名单(与 sanitizeWaveWhere 一致) */
export const waveWhereAllowedFieldList = [
'wave_id',
'wave_no',
'wave_type',
'wave_status',
'creator',
'logistics_name',
'item_part_type',
'item_part',
'item_snapshot_key',
'item_detail_machine',
'distinguish_express',
'storage_assignment_status',
'express_assignment_status',
'print_assignment_status',
// 确认打印状态(order.wave.batchList where 仅 eq,英文枚举 unconfirmed/partially_confirmed/confirmed)
'confirm_print_assignment_status',
// 领料状态(order.wave.batchList where 仅 eq,英文枚举 unclaimed/claimed,二态)
'claim_assignment_status',
'pick_assignment_status',
'review_assignment_status',
// 同步状态(order.wave.batchList where 仅 eq,英文枚举 unsynced/partially_synced/synced)
'sync_assignment_status',
// ⚠️ 文档差异:2026-09-21 快照的 where【字段清单】未列 pick_assignment_status,但响应仍返回该字段、
// 页面(本页与 waveOrder2 拣货状态 tab)按它筛选 → 暂判为文档漏列,保留白名单
'pick_assignment_status',
'total_orders',
'total_orders_min',
'total_orders_max',
'processed_orders',
'processed_orders_min',
'processed_orders_max',
'source',
'store_id'
] as const
export const waveWhereAllowedFields = new Set<string>(waveWhereAllowedFieldList)
/**
* order.wave.batchList where 中需按 { operator, value } 显式下发的文本/多值字段
* (对齐 src/api/order/order.ts 的 WaveBatchListWhere 声明:wave_no / creator / logistics_name 支持对象结构;
* 避免裸值/裸数组丢失操作符语义,数组是 in/contains 还是模糊由显式 operator 决定)
*/
export const waveWhereTextOperatorFieldList = ['wave_no', 'creator', 'logistics_name'] as const
export const waveWhereTextOperatorFields = new Set<string>(waveWhereTextOperatorFieldList)
/** 列表/详情展示:接口可能返回英文枚举或历史中文 */
const waveExpressAssignmentStatusLabelMap: Record<string, string> = {
unassigned: '未分配',
partially_assigned: '部分分配',
assigned: '已分配',
未分配: '未分配',
部分分配: '部分分配',
已分配: '已分配'
}
const wavePrintAssignmentStatusLabelMap: Record<string, string> = {
unprinted: '未打印',
partially_printed: '部分打印',
printed: '已打印',
未打印: '未打印',
部分打印: '部分打印',
已打印: '已打印'
}
/** 确认打印状态:接口返回中文(未确认打印/部分确认打印/已确认打印),where 筛选传英文枚举 */
const waveConfirmPrintAssignmentStatusLabelMap: Record<string, string> = {
unconfirmed: '未确认打印',
partially_confirmed: '部分确认打印',
confirmed: '已确认打印',
未确认打印: '未确认打印',
部分确认打印: '部分确认打印',
已确认打印: '已确认打印'
}
/** 领料状态:接口返回中文(未领料/已领料),where 筛选传英文枚举(二态) */
const waveClaimAssignmentStatusLabelMap: Record<string, string> = {
unclaimed: '未领料',
claimed: '已领料',
未领料: '未领料',
已领料: '已领料'
}
const wavePickAssignmentStatusLabelMap: Record<string, string> = {
unpicked: '未拣货',
partially_picked: '部分拣货',
picked: '已拣货',
未拣货: '未拣货',
部分拣货: '部分拣货',
已拣货: '已拣货',
// 兼容历史/别名枚举
unassigned: '未拣货',
partially_assigned: '部分拣货',
assigned: '已拣货',
未分配: '未拣货',
部分分配: '部分拣货',
已分配: '已拣货'
}
const waveReviewAssignmentStatusLabelMap: Record<string, string> = {
unreviewed: '未复核',
partially_reviewed: '部分复核',
reviewed: '已复核',
未复核: '未复核',
部分复核: '部分复核',
已复核: '已复核'
}
/** 同步状态:接口返回中文(未同步/部分同步/已同步/同步异常),where 筛选传英文枚举 */
const waveSyncAssignmentStatusLabelMap: Record<string, string> = {
unsynced: '未同步',
partially_synced: '部分同步',
synced: '已同步',
未同步: '未同步',
部分同步: '部分同步',
已同步: '已同步',
同步异常: '同步异常'
}
export function formatWaveExpressAssignmentStatusLabel(value: string | number | null | undefined): string {
if (value === undefined || value === null || value === '') return '—'
const key = String(value).trim()
return waveExpressAssignmentStatusLabelMap[key] ?? waveExpressAssignmentStatusLabelMap[key.toLowerCase()] ?? key
}
export function formatWavePrintAssignmentStatusLabel(value: string | number | null | undefined): string {
if (value === undefined || value === null || value === '') return '—'
const key = String(value).trim()
return wavePrintAssignmentStatusLabelMap[key] ?? wavePrintAssignmentStatusLabelMap[key.toLowerCase()] ?? key
}
export function formatWaveConfirmPrintAssignmentStatusLabel(value: string | number | null | undefined): string {
if (value === undefined || value === null || value === '') return '—'
const key = String(value).trim()
return waveConfirmPrintAssignmentStatusLabelMap[key] ?? waveConfirmPrintAssignmentStatusLabelMap[key.toLowerCase()] ?? key
}
export function formatWaveClaimAssignmentStatusLabel(value: string | number | null | undefined): string {
if (value === undefined || value === null || value === '') return '—'
const key = String(value).trim()
return waveClaimAssignmentStatusLabelMap[key] ?? waveClaimAssignmentStatusLabelMap[key.toLowerCase()] ?? key
}
export function formatWavePickAssignmentStatusLabel(value: string | number | null | undefined): string {
if (value === undefined || value === null || value === '') return '—'
const key = String(value).trim()
return wavePickAssignmentStatusLabelMap[key] ?? wavePickAssignmentStatusLabelMap[key.toLowerCase()] ?? key
}
export function formatWaveReviewAssignmentStatusLabel(value: string | number | null | undefined): string {
if (value === undefined || value === null || value === '') return '—'
const key = String(value).trim()
return waveReviewAssignmentStatusLabelMap[key] ?? waveReviewAssignmentStatusLabelMap[key.toLowerCase()] ?? key
}
export function formatWaveSyncAssignmentStatusLabel(value: string | number | null | undefined): string {
if (value === undefined || value === null || value === '') return '—'
const key = String(value).trim()
const mapped = waveSyncAssignmentStatusLabelMap[key] ?? waveSyncAssignmentStatusLabelMap[key.toLowerCase()]
if (mapped) return mapped
// 兼容后端可能返回的其他异常类文案(如 error/failure)
const lower = key.toLowerCase()
if (lower === 'error' || lower === 'failure' || lower === 'failed') return '同步异常'
return key
}
/** 快递分配 / 打印状态 / 库位分配等聚合状态列的 tag 类型(兼容英文枚举与中文文案) */
export function getWaveAssignmentAggregateTagType(value: string | number | null | undefined): 'success' | 'warning' | 'info' | 'danger' {
const v = String(value ?? '').toLowerCase().trim()
if (v === 'unassigned' || v === 'unprinted' || v === 'unsynced' || v === 'unreviewed' || v === 'unpicked') return 'info'
if (v === 'partially_assigned' || v === 'partially_printed' || v === 'partially_synced' || v === 'partially_reviewed' || v === 'partially_picked') return 'warning'
if (v === 'assigned' || v === 'printed' || v === 'synced' || v === 'reviewed' || v === 'picked') return 'success'
// 确认打印状态:unconfirmed | partially_confirmed | confirmed
if (v === 'unconfirmed') return 'info'
if (v === 'partially_confirmed') return 'warning'
if (v === 'confirmed') return 'success'
// 领料状态:unclaimed | claimed
if (v === 'unclaimed') return 'info'
if (v === 'claimed') return 'success'
const text = String(value ?? '')
if (text.includes('异常') || text.includes('失败') || text.includes('超时')) return 'danger'
if (text.includes('处理中')) return 'warning'
if (text.includes('未确认')) return 'info'
if (text.includes('部分确认')) return 'warning'
if (text.includes('已确认')) return 'success'
if (text.includes('未领料')) return 'info'
if (text.includes('已领料')) return 'success'
if (text.includes('已分配') || text.includes('完成') || text.includes('已打印') || text.includes('已拣货')) return 'success'
if (text.includes('部分')) return 'warning'
if (text.includes('未分配') || text.includes('未打印') || text.includes('未拣货')) return 'info'
return 'info'
}
/**
* 主工具栏按钮(action 与波次列表页内 toolbarActionMap 键一致)
*/
export const waveToolbarButtons: WaveToolbarButtonConfig[] = [
{ key: 'refresh', label: '刷新', category: 'refresh', size: 'small', loadingKey: 'loading', action: 'loadData' },
{ key: 'columnConfig', label: '字段设置', category: 'setting', size: 'small', action: 'openColumnConfigPanel' },
{
key: 'toggleDetail',
label: '显示详情',
dynamicLabelKey: 'detailToggleLabel',
category: 'setting',
size: 'small',
action: 'toggleDetailVisible'
},
{
key: 'fetchGroupOrder',
label: '抓取团购单',
category: 'action',
size: 'small',
action: 'openGroupOrderDialog',
onlyForWaveType: 1
},
{
key: 'batchPrint',
label: '批量打印',
category: 'action',
size: 'small',
disabledKey: 'batchPrintDisabled',
loadingKey: 'batchPrintLoading',
action: 'handleBatchPrint',
onlyForWaveType: 1
},
{
key: 'batchOutboundPrint',
label: '打印货单',
category: 'action',
size: 'small',
disabledKey: 'batchOutboundPrintDisabled',
loadingKey: 'batchOutboundPrintLoading',
action: 'handleBatchOutboundPrint',
onlyForWaveType: 2
},
{
key: 'batchPlatformPrint',
label: '批量打印(平台)',
category: 'action',
size: 'small',
disabledKey: 'batchPlatformPrintDisabled',
loadingKey: 'batchPlatformPrintLoading',
action: 'handleBatchPlatformPrint'
},
// {
// key: 'printerComponentConnection',
// label: '打印组件连接',
// category: 'action',
// size: 'small',
// action: 'openPrinterComponentConnectionDialog',
// onlyForWaveType: 2
// },
// {
// key: 'printerListTest',
// label: '打印机列表',
// category: 'action',
// size: 'small',
// action: 'openPrinterListTestDialog',
// onlyForWaveType: 2
// },
{
key: 'batchPrintPickingList',
label: '批量打印拣货单',
category: 'action',
size: 'small',
disabledKey: 'noSelection',
loadingKey: 'batchPrintLoading',
action: 'handleBatchPrintPickingList',
onlyForWaveType: 2
},
{
// print.confirmWavePrint:扫波次内任一面单号 → 整波次「已打印且非拦截」订单批量确认打印。
// 面单号自行定位波次,故不依赖选中行、不做 onlyForWaveType 限制(团购波次 / 散单波次都显示)。
key: 'confirmWavePrint',
label: '确认打印',
category: 'action',
size: 'small',
action: 'openConfirmWavePrintDialog'
},
{
key: 'batchAutoGrouping',
label: '批量改为自动加团',
category: 'action',
size: 'small',
disabledKey: 'noSelection',
loadingKey: 'batchAutoGroupingLoading',
action: 'handleBatchAutoGrouping'
},
{
key: 'batchFinishAutoGrouping',
label: '批量结束自动加团',
category: 'action',
size: 'small',
disabledKey: 'noSelection',
loadingKey: 'batchFinishAutoGroupingLoading',
action: 'handleBatchFinishAutoGrouping'
},
{
key: 'batchQuickRecheckByWave',
label: '批量发货',
category: 'action',
size: 'small',
disabledKey: 'noSelection',
loadingKey: 'batchQuickRecheckByWaveLoading',
action: 'handleBatchQuickRecheckByWave'
},
{
key: 'batchAllocateExpress',
label: '快速分配快递号',
category: 'action',
size: 'small',
disabledKey: 'noSelection',
loadingKey: 'batchAllocateExpressLoading',
action: 'handleBatchAllocateExpress'
},
{
key: 'batchAllocateStorage',
label: '批量分配储位',
category: 'action',
size: 'small',
disabledKey: 'noSelection',
loadingKey: 'batchAllocateStorageLoading',
action: 'handleBatchAllocateStorage'
},
{
key: 'batchCancel',
label: '批量取消波次',
category: 'cancel',
size: 'small',
disabledKey: 'noSelection',
loadingKey: 'batchCancelLoading',
action: 'handleBatchCancel'
},
{
key: 'batchRemoveExceptionOrders',
label: '批量移除异常订单',
category: 'cancel',
size: 'small',
disabledKey: 'noSelection',
loadingKey: 'batchRemoveExceptionOrdersLoading',
action: 'handleBatchRemoveExceptionOrders'
},
// {
// key: 'fetchSingleOrder',
// label: '抓取散单候选',
// type: 'warning',
// size: 'small',
// action: 'openSingleOrderDialog',
// onlyForWaveType: 2
// }
]
export function getWaveToolbarButtons(waveType: 1 | 2): WaveToolbarButtonConfig[] {
return waveToolbarButtons.filter(
(b) => b.onlyForWaveType === undefined || b.onlyForWaveType === waveType
)
}
/** 解析 order.print.getWavePlatformPrintData 响应(支持 res.data 包裹) */
export function unwrapWavePlatformPrintPayload(res: unknown): WavePlatformPrintDataPayload {
const toObject = (v: unknown): Record<string, unknown> | undefined => {
if (!v || typeof v !== 'object' || Array.isArray(v)) return undefined
return v as Record<string, unknown>
}
const toOrderList = (v: unknown): Record<string, unknown>[] => {
if (!Array.isArray(v)) return []
return v.filter((x) => x && typeof x === 'object') as Record<string, unknown>[]
}
// 兼容后端直接返回数组:[{ wave_id, wave_no, order_count, platforms: [...] }]
const normalizeWaveGroups = (list: unknown): unknown[] | undefined => {
if (!Array.isArray(list)) return undefined
const groups = list
.filter((x) => x && typeof x === 'object')
.map((wave) => {
const waveObj = wave as Record<string, unknown>
const rawPlatforms = Array.isArray(waveObj.platforms) ? waveObj.platforms : []
const platforms = rawPlatforms
.filter((p) => p && typeof p === 'object')
.map((p) => {
const platformObj = p as Record<string, unknown>
const orders = toOrderList(platformObj.orders ?? platformObj.order_list)
return {
...platformObj,
orders
}
})
return {
wave_id: waveObj.wave_id,
wave_no: waveObj.wave_no,
order_count: waveObj.order_count,
platforms
}
})
return groups
}
const r = res as Record<string, unknown> | null | undefined
// 情况1:顶层就是波次数组
if (Array.isArray(res)) {
const waveGroups = normalizeWaveGroups(res)
const wave_ids = (waveGroups || [])
.map((x) => (x && typeof x === 'object' ? (x as Record<string, unknown>).wave_id : undefined))
.filter((id) => id !== undefined && id !== null && id !== '') as Array<number | string>
return {
wave_ids: wave_ids.length ? wave_ids : undefined,
waveGroups,
platform_groups: undefined,
order_list: undefined,
summary: undefined,
ext: undefined
}
}
const inner =
r?.data !== undefined && r?.data !== null && typeof r.data === 'object' && !Array.isArray(r.data)
? (r.data as Record<string, unknown>)
: (r as Record<string, unknown>) || {}
// 情况2:res.data 是波次数组
if (Array.isArray(r?.data)) {
const waveGroups = normalizeWaveGroups(r.data)
const wave_ids = (waveGroups || [])
.map((x) => (x && typeof x === 'object' ? (x as Record<string, unknown>).wave_id : undefined))
.filter((id) => id !== undefined && id !== null && id !== '') as Array<number | string>
return {
wave_ids: wave_ids.length ? wave_ids : undefined,
waveGroups,
platform_groups: undefined,
order_list: undefined,
summary: undefined,
ext: undefined
}
}
const summaryRaw = inner?.summary
const summary = toObject(summaryRaw)
const wave_ids = Array.isArray(inner?.wave_ids) ? (inner.wave_ids as Array<number | string>) : undefined
const waveGroups = Array.isArray(inner?.waveGroups)
? inner.waveGroups
: normalizeWaveGroups((inner as Record<string, unknown>).wave_list)
const locked_wave_groups = Array.isArray(inner?.locked_wave_groups)
? normalizeWaveGroups(inner.locked_wave_groups)
: undefined
const locked_orders = toOrderList(inner?.locked_orders)
const locked_count_raw = (inner as Record<string, unknown>)?.locked_count
const locked_count =
locked_count_raw !== undefined && locked_count_raw !== null && Number.isFinite(Number(locked_count_raw))
? Number(locked_count_raw)
: undefined
const platform_groups = Array.isArray(inner?.platform_groups) ? inner.platform_groups : undefined
const order_list = toOrderList(inner?.order_list)
const extRaw = inner?.ext
const ext = toObject(extRaw)
return {
summary,
wave_ids,
waveGroups,
locked_wave_groups,
locked_orders: locked_orders.length ? locked_orders : undefined,
locked_count,
platform_groups,
order_list: order_list.length ? order_list : undefined,
ext
}
}
/** 异步任务状态文案 */
export const waveFetchTaskStatusTextMap: Record<string, string> = {
submitted: '已受理',
running: '进行中',
success: '成功',
failed: '失败',
not_found: '未找到'
}
/** 波次状态文案 */
export const waveStatusTextMap: Record<string, string> = {
'-1': '已取消',
'0': '自动加团中',
'1': '已就绪',
'2': '已打印',
'3': '拣货中',
'4': '拣货完成',
'5': '复核完成',
'6': '打包完成',
cancelled: '已取消',
pending: '自动加团中',
assigned: '已就绪'
}
/** 波次类型文案 */
export const waveTypeTextMap: Record<string, string> = {
'1': '团购',
'2': '散单'
}
/** 库位分配状态文案 */
export const waveStorageAssignmentStatusTextMap: Record<string, string> = {
none: '未分配',
no_error: '未分配',
pending: '处理中',
padding: '处理中',
processing: '处理中',
running: '处理中',
success: '已分配',
succeeded: '已分配',
fin: '已分配',
finished: '已分配',
done: '已分配',
completed: '已分配',
partial: '部分分配',
partial_failed: '部分分配',
error: '分配异常',
failed: '分配异常',
exception: '分配异常',
timeout: '处理超时',
not_found: '未找到'
}
/** 库位分配异常文案 */
export const waveStorageAssignmentErrorTextMap: Record<string, string> = {
none: '无',
no_error: '无',
no_exception: '无',
success: '无',
succeeded: '无',
fin: '无',
finished: '无',
done: '无',
completed: '无',
pending: '处理中',
padding: '处理中',
processing: '处理中',
running: '处理中',
error: '分配异常',
failed: '分配失败',
exception: '分配异常',
timeout: '处理超时',
not_found: '未找到',
partial: '部分异常',
partial_failed: '部分异常'
}
/** 库位分配异常短语翻译规则 */
export const waveStorageAssignmentErrorPhraseMap: Array<[RegExp, string]> = [
[/storage assignment/gi, '库位分配'],
[/assignment/gi, '分配'],
[/storage/gi, '库位'],
[/error/gi, '异常'],
[/failed/gi, '失败'],
[/exception/gi, '异常'],
[/timeout/gi, '超时'],
[/pending|padding|processing|running/gi, '处理中'],
[/partial/gi, '部分'],
[/not found/gi, '未找到'],
[/none|success|succeeded|finished|completed|done|fin/gi, '无']
]
/** 波次策略表单校验规则 */
export const waveStrategyFormRules = {
strategy_name: [{ required: true, message: '请输入策略名称', trigger: 'blur' }],
strategy_type: [{ required: true, message: '请输入策略类型', trigger: 'change' }],
batch_mode: [{ required: true, message: '请输入批次模式', trigger: 'change' }],
wave_prefix: [{ max: 5, message: '波次前缀最多5个字符', trigger: 'blur' }]
}
/** 新建/编辑波次策略表单源数据(与 order.wave.waveStrategyCreate / waveStrategyUpdate 入参对齐) */
export type WaveStrategyFormPayloadSource = {
strategy_name: string
strategy_type?: number
batch_mode?: number
status?: number
order_min_sku?: number | null
order_max_sku?: number | null
order_min_qty?: number | null
order_max_qty?: number | null
min_same_structure?: number | null
max_same_structure?: number | null
batch_max_orders?: number
batch_max_skus?: number
group_batch_max_orders?: number
require_same_express?: boolean
allow_cross_owner?: boolean
description?: string
wave_prefix?: string
allowed_owners?: string[]
allowed_expresses?: string[]
allowed_provinces?: string[]
allowed_platforms?: string[]
}
/** 组装 order.wave.waveStrategyCreate / waveStrategyUpdate 请求体(字段与 module order.wave 文档一致,不做客户端归一化) */
export function buildWaveStrategyMutationPayload(
model: WaveStrategyFormPayloadSource
): Partial<WaveStrategyCreateParams & WaveStrategyUpdateParams> {
const payload: Partial<WaveStrategyCreateParams & WaveStrategyUpdateParams> = {
strategy_name: model.strategy_name.trim(),
strategy_type: model.strategy_type,
batch_mode: model.batch_mode,
status: model.status,
order_min_sku: model.order_min_sku,
order_max_sku: model.order_max_sku,
order_min_qty: model.order_min_qty,
order_max_qty: model.order_max_qty,
min_same_structure: model.min_same_structure,
max_same_structure: model.max_same_structure,
batch_max_orders: model.batch_max_orders,
batch_max_skus: model.batch_max_skus,
group_batch_max_orders: model.group_batch_max_orders,
require_same_express: model.require_same_express,
allow_cross_owner: model.allow_cross_owner,
description: model.description?.trim() || undefined,
wave_prefix: model.wave_prefix?.trim() || undefined
}
if (model.allowed_owners?.length) payload.allowed_owners = model.allowed_owners
if (model.allowed_expresses?.length) payload.allowed_expresses = model.allowed_expresses
if (model.allowed_provinces?.length) payload.allowed_provinces = model.allowed_provinces
if (model.allowed_platforms?.length) payload.allowed_platforms = model.allowed_platforms
Object.keys(payload).forEach((key) => {
const field = key as keyof typeof payload
if (payload[field] === undefined) {
delete payload[field]
}
})
return payload
}
/** 波次策略状态选项 */
export const waveStrategyStatusOptions = [
{ label: '禁用', value: 0 },
{ label: '启用', value: 1 }
]
/** 通用布尔选项 */
export const waveBooleanOptions = [
{ label: '是', value: true },
{ label: '否', value: false }
]
// ---------------------------------------------------------------------------
// 拣货中任务页(pickTaskWave):ScanBox 排版对齐待处理订单;筛选字段见 pickTaskWaveAvailableFields
// ---------------------------------------------------------------------------
/** 列表与工具栏文案 */
export const pickTaskWaveListDefaults = {
toolbarHint: '当前仓库拣货任务(order.wave.wavePickTaskList)',
listTitle: '拣货任务列表',
emptyText: '暂无拣货任务',
loadingEmptyText: '加载中...',
loadFailedEmptyText: '加载失败',
noWarehouseEmptyText: '未获取到仓库ID'
}
/** 分页与详情弹窗 */
export const pickTaskWavePaginationDefaults = {
pageSizes: [20, 50, 100, 200] as const,
layout: 'total, sizes, prev, pager, next, jumper' as const,
initialPageSize: 20
}
/** 供模板 :page-sizes 绑定(避免 readonly 元组在模板中的类型问题) */
export const pickTaskWavePaginationPageSizes = [20, 50, 100, 200]
export const pickTaskWaveDetailDialogDefaults = {
title: '拣货任务详情',
width: '920px'
}
/** 拣货任务页工具栏按钮(action 与 WavePickTaskListPanel 内 toolbarActionMap 键一致) */
export const pickTaskWaveToolbarButtons: ToolbarButtonConfig[] = [
{ key: 'search', label: '查询', category: 'refresh', size: 'small', loadingKey: 'loading', action: 'loadData' },
{ key: 'columnConfig', label: '字段设置', category: 'setting', size: 'small', action: 'openColumnConfigPanel' },
{
key: 'toggleDetail',
label: '显示详情',
dynamicLabelKey: 'detailToggleLabel',
category: 'setting',
size: 'small',
action: 'toggleDetailVisible'
},
{
key: 'batchCancel',
label: '批量取消任务',
category: 'cancel',
size: 'small',
loadingKey: 'batchCancelLoading',
disabledKey: 'batchCancelDisabled',
action: 'handleBatchCancelTasks'
}
]
/** 不符合波次策略订单页工具栏按钮 */
export const fallbackOrderToolbarButtons: ToolbarButtonConfig[] = [
{ key: 'search', label: '刷新', category: 'refresh', size: 'small', loadingKey: 'loading', action: 'loadData' },
{ key: 'columnConfig', label: '字段设置', category: 'setting', size: 'small', action: 'openColumnConfigPanel' },
{
key: 'quickScan',
label: '快速扫描',
category: 'action',
size: 'small',
loadingKey: 'waveStrategyQuickScanSubmitting',
action: 'submitWaveStrategyQuickScan'
},
{
key: 'fetchByIds',
label: '按订单IDs抓取散单',
category: 'action',
size: 'small',
loadingKey: 'singleOrderSubmitting',
disabledKey: 'noSelection',
action: 'submitFallbackOrderFetchByIds'
}
]
/** 波次策略页工具栏按钮 */
export const waveStrategyToolbarButtons: ToolbarButtonConfig[] = [
{ key: 'refresh', label: '刷新', category: 'refresh', size: 'small', loadingKey: 'loading', action: 'loadData' },
{ key: 'columnConfig', label: '字段设置', category: 'setting', size: 'small', action: 'openColumnConfigPanel' },
{ key: 'create', label: '新建策略', category: 'action', size: 'small', action: 'openCreateWaveStrategyDialog' }
]
/** 拣货任务 status 枚举(与 wavePickTaskList / wavePickTaskCancel 文档一致) */
export const pickTaskStatusFilterOptions = [
{ label: '待开始', value: 0 },
{ label: '拣货中', value: 1 },
{ label: '拣货完成', value: 2 },
{ label: '已完成', value: 3 },
{ label: '已取消', value: 9 }
] as const
/**
* 左侧筛选字段:与 order.wave.wavePickTaskList 最新接口文档的参数一一对应(全部走顶层参数)。
* 文档支持:task_no / keyword / wave_no / cart_code / cart_id / pick_user_name /
* review_user_name / claim_operator / start_time_start+end / status / review_status / pick_mode / source;
* 其中 wave_no / cart_code / 人员姓名支持 { operator: 'like'|'notlike'|'eq', value }(默认 like)。
* 注意:where 仅兼容历史结构且会校验白名单(如 operator_name 会被拒绝),故不再放置筛选字段。
*/
export const pickTaskWaveAvailableFields = [
// ===== 任务信息 =====
// 任务编号 task_no:顶层纯模糊参数(不支持操作符对象)
pickTaskScanBasicField({ label: '任务编号', value: 'task_no', type: 'text', hideOperator: true, operators: ['like'], defaultOperator: 'like' }),
// 关键字 keyword:覆盖 task_no / batch_no / current_cart_code_snapshot 的模糊匹配
pickTaskScanBasicField({ label: '关键字', value: 'keyword', type: 'text', hideOperator: true, operators: ['like'], defaultOperator: 'like' }),
// 波次号 wave_no:匹配任务主表 batch_no_array;文档支持模糊匹配/模糊排除/等于
pickTaskScanBasicField({ label: '波次号', value: 'wave_no', type: 'text', operators: ['like', 'notlike', 'eq'], defaultOperator: 'like' }),
// 车编码 cart_code:匹配当前车编码快照 current_cart_code_snapshot;文档支持模糊匹配/模糊排除/等于
pickTaskScanBasicField({ label: '车编码', value: 'cart_code', type: 'text', operators: ['like', 'notlike', 'eq'], defaultOperator: 'like' }),
// 拣货车ID cart_id:顶层数字参数(纯等值)
pickTaskScanBasicField({ label: '拣货车ID', value: 'cart_id', type: 'text', hideOperator: true, operators: ['eq'], defaultOperator: 'eq' }),
// 人员姓名(拣货人/领料人/复核人):文档支持模糊匹配/模糊排除/等于,默认模糊匹配
pickTaskScanBasicField({ label: '拣货人', value: 'pick_user_name', type: 'text', operators: ['like', 'notlike', 'eq'], defaultOperator: 'like' }),
pickTaskScanBasicField({ label: '领料人', value: 'claim_operator', type: 'text', operators: ['like', 'notlike', 'eq'], defaultOperator: 'like' }),
pickTaskScanBasicField({ label: '复核人', value: 'review_user_name', type: 'text', operators: ['like', 'notlike', 'eq'], defaultOperator: 'like' }),
pickTaskScanBasicField({ label: '开始时间', value: 'start_time_range', type: 'daterange' }),
// ===== 流程状态(合并为一组,对齐波次列表 ScanBox) =====
{ ...scanWorkflowField({
label: '任务状态',
value: 'status',
type: 'multiple',
options: [...pickTaskStatusFilterOptions]
}), group: PICK_TASK_SCAN_PROCESS_STATUS_GROUP },
{ ...scanWorkflowField({
label: '复核状态',
value: 'review_status',
type: 'select',
options: [
{ label: '未就绪', value: 0 },
{ label: '待复核', value: 1 },
{ label: '复核中', value: 2 },
{ label: '复核通过', value: 3 },
{ label: '复核异常', value: 4 }
]
}), group: PICK_TASK_SCAN_PROCESS_STATUS_GROUP },
{ ...scanWorkflowField({
label: '拣货模式',
value: 'pick_mode',
type: 'select',
options: [
{ label: '小团购', value: 1 },
{ label: '单品单件', value: 2 },
{ label: '先拣后分', value: 3 },
{ label: '边拣边分', value: 4 },
{ label: '大团购', value: 5 }
]
}), group: PICK_TASK_SCAN_PROCESS_STATUS_GROUP },
{ ...scanWorkflowField({
label: '来源',
value: 'source',
type: 'select',
options: [
{ label: '默认', value: 0 },
{ label: 'PDA', value: 1 },
{ label: '后台', value: 2 }
]
}), group: PICK_TASK_SCAN_PROCESS_STATUS_GROUP },
]
/** 拣货任务列表:UpperTable 列配置(字段对齐 order.wave.wavePickTaskList 返回;wave_no 由 wave_list[].wave_no 派生) */
export const pickTaskWaveColumns = applyWaveListCopyActions([
// { prop: 'task_id', label: '任务ID', width: 90 },
{ prop: 'task_no', label: '任务编号', minWidth: 220 },
{
// 波次号:行上无 wave_no 字段,从 wave_list[].wave_no 派生;多值时折叠为「第一个 + +N」
prop: 'wave_no',
label: '波次号',
minWidth: 160,
copyAction: 'copy' as const,
copyValue: (row: any) => getPickTaskWaveNos(row)
},
{
// 批次号:点击复制;值为逗号分隔 / JSON 数组 / 数组时自动折叠为「第一个 + +N」
prop: 'batch_no',
label: '批次号',
minWidth: 160,
copyAction: 'copy' as const
},
{ prop: 'status', label: '任务状态', width: 110 },
{ prop: 'review_status', label: '复核状态', width: 100 },
{ prop: 'pick_mode', label: '拣货模式', width: 100 },
{ prop: 'source', label: '来源', width: 90 },
// { prop: 'warehouse_id', label: '仓库ID', width: 90, align: 'center' },
{ prop: 'wave_count', label: '波次数', width: 90 },
{ prop: 'order_count', label: '订单数', width: 90, sortable: true },
{ prop: 'box_count', label: '箱数', width: 110 },
{ prop: 'operator_name', label: '操作人', minWidth: 120 },
{ prop: 'pick_user_name', label: '拣货员', minWidth: 120 },
{ prop: 'review_user_name', label: '复核人', minWidth: 120 },
{ prop: 'claim_operator', label: '领料人', minWidth: 120 },
// { prop: 'current_cart_id', label: '当前车ID', width: 100 },
{ prop: 'current_cart_code_snapshot', label: '当前车编码', minWidth: 140 },
{ prop: 'cart_name', label: '拣货车', minWidth: 120 },
// { prop: 'device_id', label: '设备ID', minWidth: 140 },
{ prop: 'start_at', label: '开始时间', minWidth: 168 },
{ prop: 'finish_at', label: '完成时间', minWidth: 168 },
{ prop: 'pick_duration', label: '拣货用时', minWidth: 110, align: 'center' },
{ prop: 'review_start_time', label: '复核开始', minWidth: 168 },
{ prop: 'review_finish_time', label: '复核完成', minWidth: 168 },
{ prop: 'review_duration', label: '复核用时', minWidth: 110, align: 'center' },
{ prop: 'created_at', label: '创建时间', minWidth: 168 },
{ prop: 'update_time', label: '更新时间', minWidth: 168 },
{ prop: 'operation', label: '操作', width: 200, fixed: 'right' }
])
export function formatPickTaskStatus(value: unknown): string {
const num = Number(value)
if (num === 0) return '待开始'
if (num === 1) return '拣货中'
if (num === 2) return '拣货完成'
if (num === 3) return '已完成'
if (num === 9) return '已取消'
return value === null || value === undefined || value === '' ? '-' : String(value)
}
export function formatPickTaskReviewStatus(value: unknown): string {
const num = Number(value)
if (num === 0) return '未就绪'
if (num === 1) return '待复核'
if (num === 2) return '复核中'
if (num === 3) return '复核通过'
if (num === 4) return '复核异常'
return value === null || value === undefined || value === '' ? '-' : String(value)
}
export function formatPickTaskPickMode(value: unknown): string {
const num = Number(value)
if (num === 1) return '小团购'
if (num === 2) return '单品单件'
if (num === 3) return '先拣后分'
if (num === 4) return '边拣边分'
if (num === 5) return '大团购'
return value === null || value === undefined || value === '' ? '-' : String(value)
}
export function formatPickTaskSource(value: unknown): string {
const num = Number(value)
if (num === 0) return '默认'
if (num === 1) return 'PDA'
if (num === 2) return '后台'
return value === null || value === undefined || value === '' ? '-' : String(value)
}
/** 波次列表 order.wave.batchList 的来源文案:0 普通波次,1 管理后台策略任务,2 PDA 策略任务 */
export function formatWaveSource(value: unknown): string {
const num = Number(value)
if (num === 0) return '普通波次'
if (num === 1) return '后台策略'
if (num === 2) return 'PDA策略'
return value === null || value === undefined || value === '' ? '—' : String(value)
}
export function getWaveSourceTagType(value: unknown): 'info' | 'warning' | 'success' | 'danger' {
const num = Number(value)
if (num === 1) return 'warning'
if (num === 2) return 'success'
return 'info'
}
export function getPickTaskStatusTagType(value: unknown): 'info' | 'warning' | 'success' | 'danger' {
const num = Number(value)
if (num === 0) return 'info'
if (num === 1) return 'warning'
if (num === 2) return 'success'
if (num === 3) return 'success'
if (num === 9) return 'info'
return 'info'
}
export function getPickTaskReviewStatusTagType(value: unknown): 'info' | 'warning' | 'success' | 'danger' {
const num = Number(value)
if (num === 0) return 'info'
if (num === 1) return 'warning'
if (num === 2) return 'warning'
if (num === 3) return 'success'
if (num === 4) return 'danger'
return 'info'
}
export function getPickTaskSourceTagType(value: unknown): 'info' | 'success' {
const num = Number(value)
if (num === 1) return 'success'
return 'info'
}
export function unwrapWavePrintPayload(res: any) {
const inner =
res?.data !== undefined && res?.data !== null && typeof res.data === 'object' && !Array.isArray(res.data)
? res.data
: res
const summaryRaw = inner?.summary
const summary =
summaryRaw !== undefined && summaryRaw !== null && typeof summaryRaw === 'object' && !Array.isArray(summaryRaw)
? (summaryRaw as Record<string, unknown>)
: {}
const waveListRaw = inner?.wave_list
const wave_list = Array.isArray(waveListRaw)
? (waveListRaw.filter((x) => x && typeof x === 'object') as Record<string, unknown>[])
: []
const extRaw = inner?.ext
const ext =
extRaw !== undefined && extRaw !== null && typeof extRaw === 'object' && !Array.isArray(extRaw)
? (extRaw as Record<string, unknown>)
: undefined
return { summary, wave_list, ext }
}
export function getWaveOrders(wave: Record<string, unknown>) {
const keys = ['orders', 'order_list', 'order_details', 'items', 'print_orders', 'order_rows', 'details']
for (const key of keys) {
const value = wave[key]
if (Array.isArray(value)) return value
}
return []
}
export function getWaveOrderLineItems(order: Record<string, unknown>) {
const keys = ['items', 'order_items', 'details', 'order_details', 'sku_list', 'goods_list', 'lines']
for (const key of keys) {
const value = order[key]
if (Array.isArray(value)) return value
}
return []
}
export function resolveWaveRowKey(row: Record<string, unknown>) {
return String(row?.id ?? row?.wave_id ?? row?.batch_id ?? row?.wave_no ?? '')
}
export function resolveOutboundQueueNo(order: Record<string, unknown>, fallback = '—') {
return String(
order.delivery_order_code
?? order.delivery_no
?? order.order_sn
?? order.order_no
?? order.order_number
?? fallback
)
}
export function resolveOutboundPrintRowKey(
order: Record<string, unknown>,
waveKey: string,
index: number
) {
const orderId = order.order_id ?? order.id ?? `${waveKey}-${index}`
return `${waveKey}::${orderId}`
}
export function toOutboundPrintForm(order: Record<string, unknown>, wave: Record<string, unknown>) {
const lineItems = getWaveOrderLineItems(order) as Record<string, unknown>[]
return {
...wave,
...order,
wave_no: String(wave.wave_no ?? wave.batch_no ?? wave.wave_code ?? wave.id ?? '—'),
delivery_order_code: resolveOutboundQueueNo(order),
remark: normalizePrintEmptyLabel(order.remark ?? order.seller_message ?? order.buyer_message ?? ''),
details: mapPendingOrderItemsToPrintDetails(lineItems),
}
}
export function buildOutboundPrintQueue(
waveList: Record<string, unknown>[],
selectedWaveRows: any[]
) {
const waveByKey = new Map<string, Record<string, unknown>>()
waveList.forEach((wave) => {
const key = resolveWaveRowKey(wave)
if (key) waveByKey.set(key, wave)
})
const printRows: any[] = []
const dataMap: Record<string, any> = {}
selectedWaveRows.forEach((waveRow) => {
const waveKey = resolveWaveRowKey(waveRow || {})
const wave = (waveKey ? waveByKey.get(waveKey) : undefined) || (waveRow as Record<string, unknown>)
const orders = getWaveOrders(wave)
orders.forEach((order, index) => {
const orderRec = order && typeof order === 'object' ? (order as Record<string, unknown>) : {}
const rowKey = resolveOutboundPrintRowKey(orderRec, waveKey || 'wave', index)
const queueNo = resolveOutboundQueueNo(orderRec, rowKey)
const queueRow = {
...orderRec,
id: rowKey,
delivery_order_code: queueNo,
wave_no: String(wave.wave_no ?? waveRow?.wave_no ?? waveRow?.batch_no ?? waveRow?.wave_code ?? '—'),
wave_id: waveKey || waveRow?.id
}
printRows.push(queueRow)
dataMap[rowKey] = toOutboundPrintForm(orderRec, wave)
})
})
return { printRows, dataMap }
}
const OUTBOUND_DETAIL_FETCH_CONCURRENCY = 8
function formatOutboundPrintDateTime(date: Date): string {
const pad = (n: number) => String(n).padStart(2, '0')
return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`
}
function resolvePendingOrderDeliveryCode(order: Record<string, unknown>): string {
return String(order.delivery_order_code ?? order.order_code ?? '').trim()
}
async function runWithConcurrencyLimit<T>(
items: T[],
limit: number,
worker: (item: T) => Promise<void>,
): Promise<void> {
if (!items.length) return
let cursor = 0
const poolSize = Math.min(limit, items.length)
await Promise.all(
Array.from({ length: poolSize }, async () => {
while (cursor < items.length) {
const item = items[cursor]
cursor += 1
if (item === undefined) continue
await worker(item)
}
}),
)
}
/** 查询单个订单详情(order.pendingOrder.detail) */
async function fetchPendingOrderDetailById(orderId: number | string): Promise<Record<string, unknown> | null> {
const res: any = await orderPendingOrder.detail({
id: orderId,
ids: [orderId],
tableType: 'order',
})
if (!isOrderIndexApiSuccess(res)) return null
return parseOrderDetailPayload(res)
}
function resolveOutboundWaybillText(
detailPayload: Record<string, unknown>,
order: Record<string, unknown>,
): string {
const waybillCodes = detailPayload.waybill_codes ?? order.waybill_codes
if (Array.isArray(waybillCodes)) {
return waybillCodes.map((code) => String(code ?? '').trim()).filter(Boolean).join(', ')
}
return String(order.express_code ?? order.waybill_code ?? '').trim()
}
const SNAPSHOT_EMPTY_LABEL = '无'
function resolveItemSnapshot(item: Record<string, unknown>): Record<string, unknown> {
const raw = item.item_snapshot
if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
return raw as Record<string, unknown>
}
if (typeof raw === 'string' && raw.trim()) {
try {
const parsed = JSON.parse(raw)
if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
return parsed as Record<string, unknown>
}
} catch {
// ignore invalid snapshot json
}
}
return {}
}
function normalizePrintEmptyLabel(value: unknown): string {
if (value == null || value === '') return SNAPSHOT_EMPTY_LABEL
const text = String(value).trim()
return text || SNAPSHOT_EMPTY_LABEL
}
function snapshotField(snap: Record<string, unknown>, key: string): string {
return normalizePrintEmptyLabel(snap[key])
}
/** 订单行字段优先,其次 item_snapshot;均无则返回「无」 */
function resolvePrintLineField(
item: Record<string, unknown>,
snap: Record<string, unknown>,
...keys: string[]
): string {
for (const key of keys) {
const fromItem = item[key]
if (fromItem != null && fromItem !== '' && String(fromItem).trim() !== '') {
return String(fromItem).trim()
}
const fromSnap = snap[key]
if (fromSnap != null && fromSnap !== '' && String(fromSnap).trim() !== '') {
return String(fromSnap).trim()
}
}
return SNAPSHOT_EMPTY_LABEL
}
function orderLineQuantity(item: Record<string, unknown>): string {
const value = item.plan_qty ?? item.quantity ?? item.qty
if (value == null || value === '') return SNAPSHOT_EMPTY_LABEL
const text = String(value).trim()
return text || SNAPSHOT_EMPTY_LABEL
}
/** 商品明细:优先订单行字段,回退 item_snapshot;数量取订单行 plan_qty */
function mapPendingOrderItemsToPrintDetails(items: Record<string, unknown>[]) {
return items.map((item) => {
const snap = resolveItemSnapshot(item)
const quantity = orderLineQuantity(item)
const itemCode = resolvePrintLineField(item, snap, 'item_code')
const itemName = resolvePrintLineField(item, snap, 'item_name')
const unitPrice = resolvePrintLineField(item, snap, 'actual_price', 'retail_price', 'price', 'unit_price')
// 商品条码:模板「商品明细」条码列(field_code=barcode)取值,兼容 barcode 单值与 barcodes 数组
const barcode = resolveRowBarcode(item, snap)
return {
item_snapshot: {
...snap,
item_code: itemCode === SNAPSHOT_EMPTY_LABEL ? snap.item_code : itemCode,
item_name: itemName === SNAPSHOT_EMPTY_LABEL ? snap.item_name : itemName,
goods_code: resolvePrintLineField(item, snap, 'goods_code'),
retail_price: unitPrice === SNAPSHOT_EMPTY_LABEL ? snap.retail_price : unitPrice,
},
item_code: itemCode,
item_name: itemName,
barcode: barcode || SNAPSHOT_EMPTY_LABEL,
sku_property: resolvePrintLineField(item, snap, 'sku_property', 'ext_code'),
goods_code: resolvePrintLineField(item, snap, 'goods_code'),
brand_name: resolvePrintLineField(item, snap, 'brand_name'),
category_name: resolvePrintLineField(item, snap, 'category_name'),
stock_unit: resolvePrintLineField(item, snap, 'stock_unit'),
item_type: resolvePrintLineField(item, snap, 'item_type'),
inventory_type: resolvePrintLineField(item, snap, 'inventory_type'),
retail_price: unitPrice,
plan_qty: quantity,
quantity,
actual_price: unitPrice,
price: unitPrice,
unit_price: unitPrice,
}
})
}
/** 打印脱敏:收件人仅保留首字(姓),其余替换为 * */
export function maskPrintReceiverName(name: unknown): string {
const text = String(name ?? '').trim()
if (!text) return ''
if (text.length === 1) return text
return text.charAt(0) + '*'.repeat(text.length - 1)
}
/** 打印脱敏:电话保留前三位和最后四位,中间替换为 * */
export function maskPrintReceiverPhone(phone: unknown): string {
const text = String(phone ?? '').trim()
if (!text) return ''
if (text.length <= 7) {
if (text.length <= 3) return text
return text.slice(0, 3) + '*'.repeat(text.length - 3)
}
const prefix = text.slice(0, 3)
const suffix = text.slice(-4)
return prefix + '*'.repeat(text.length - 7) + suffix
}
/** 打印脱敏:详细地址中的阿拉伯数字替换为 * */
export function maskPrintDetailAddressDigits(address: unknown): string {
const text = String(address ?? '').trim()
if (!text) return ''
return text.replace(/[0-9]/g, '*')
}
function applySandanOutboundPrintReceiverMask(form: Record<string, unknown>): Record<string, unknown> {
const mobile = maskPrintReceiverPhone(form.mobile ?? form.tel)
const tel = maskPrintReceiverPhone(form.tel ?? form.mobile)
const detailAddress = maskPrintDetailAddressDigits(form.detail_address)
const addressParts = [form.province, form.city, form.area, form.town, detailAddress]
.map((value) => (value == null ? '' : String(value).trim()))
.filter(Boolean)
return {
...form,
name: maskPrintReceiverName(form.name),
mobile,
tel: tel || mobile,
detail_address: detailAddress,
address: addressParts.join(''),
}
}
/** 将 order.pendingOrder.detail 响应映射为出库单打印表单字段(散单波次打印货单会对收件人/电话脱敏) */
export function mapPendingOrderToOutboundPrintForm(
detailPayload: Record<string, unknown>,
wave: Record<string, unknown>,
): Record<string, unknown> {
const order = (detailPayload.order || detailPayload.detail || detailPayload) as Record<string, unknown>
const items = normalizeOrderDetailItems(detailPayload)
const waybillStr = resolveOutboundWaybillText(detailPayload, order)
const addressParts = [order.province, order.city, order.area, order.town, order.detail_address]
.map((value) => (value == null ? '' : String(value).trim()))
.filter(Boolean)
return applySandanOutboundPrintReceiverMask({
...order,
wave_no: String(wave.wave_no ?? wave.batch_no ?? wave.wave_code ?? order.wave_no ?? '—'),
delivery_order_code: resolvePendingOrderDeliveryCode(order),
create_at: order.create_at ?? order.created_at ?? '',
logistics_name: order.logistics_name ?? '',
express_code: String(order.express_code ?? waybillStr).trim(),
waybill_codes: waybillStr,
// 传播 expresses 数组,确保打印模板能从 expresses 获取运单号
expresses: Array.isArray(detailPayload.expresses) ? detailPayload.expresses : [],
name: order.name ?? '',
mobile: order.mobile ?? order.tel ?? '',
tel: order.tel ?? '',
province: order.province ?? '',
city: order.city ?? '',
area: order.area ?? '',
town: order.town ?? '',
detail_address: order.detail_address ?? '',
address: addressParts.join(''),
remark: normalizePrintEmptyLabel(order.remark ?? order.seller_message ?? order.buyer_message ?? ''),
print_time: formatOutboundPrintDateTime(new Date()),
details: mapPendingOrderItemsToPrintDetails(items),
})
}
/**
* 替换 order.print.getWavePrintData:
* 通过 order.pendingOrder.list 按 wave_id 查询订单,按波次分组后返回 waveList 结构,
* 供 buildOutboundPrintQueue / fetchOutboundPrintDataFromPendingOrders 使用。
*/
export async function fetchOutboundWaveList(wave_ids: Array<number | string>): Promise<Record<string, unknown>[]> {
if (!wave_ids.length) return []
const res: any = await orderPendingOrder.list({
pagination: { page: 1, pageSize: 9999 },
where: { wave_id: { operator: 'in', value: wave_ids, type: 'select' } },
})
if (!isOrderIndexApiSuccess(res)) return []
const { list: rawList } = parseOrderListResponse(res)
if (!rawList.length) return []
// 将列表项展开(raw.detail 合并到顶层),按 wave_id 分组
const waveGroupMap = new Map<string, Record<string, unknown>[]>()
rawList.forEach((raw: any) => {
const order = { ...(raw.detail || raw), items: raw.items || [], expresses: raw.expresses || [] }
const wid = String(order.wave_id ?? '')
if (!wid) return
if (!waveGroupMap.has(wid)) waveGroupMap.set(wid, [])
waveGroupMap.get(wid)!.push(order)
})
// 构造 waveList 格式:每个 wave 对象包含 id / wave_no / orders 等字段
const waveList: Record<string, unknown>[] = []
waveGroupMap.forEach((orders, wid) => {
const first = orders[0]
waveList.push({
id: wid,
wave_id: wid,
wave_no: String(first?.wave_no ?? ''),
orders,
})
})
return waveList
}
/**
* 从 waveList 中已加载的订单直接构建 delivery_order_code → order_id 映射,
* 避免重复调用 order.pendingOrder.list。
*/
export async function fetchOutboundPrintDataFromPendingOrders(
waveList: Record<string, unknown>[],
selectedWaveRows: any[],
): Promise<{ printRows: any[]; dataMap: Record<string, any>; missingDeliveryCodes: string[] }> {
const skeleton = buildOutboundPrintQueue(waveList, selectedWaveRows)
if (!skeleton.printRows.length) {
return { ...skeleton, missingDeliveryCodes: [] }
}
// 从 waveList 的 orders 中直接构建 code → orderId 映射(无需再调 list 接口)
const codeToOrderId = new Map<string, number | string>()
waveList.forEach((wave) => {
const orders = getWaveOrders(wave)
orders.forEach((order: any) => {
if (!order || typeof order !== 'object') return
const code = resolvePendingOrderDeliveryCode(order)
const oid = order.id ?? order.order_id
if (code && oid != null && oid !== '') {
codeToOrderId.set(code, oid as number | string)
}
})
})
const printRows: any[] = new Array(skeleton.printRows.length)
const dataMap: Record<string, any> = {}
const missingDeliveryCodes: string[] = []
await runWithConcurrencyLimit(
skeleton.printRows.map((row, index) => ({ row, index })),
OUTBOUND_DETAIL_FETCH_CONCURRENCY,
async ({ row, index }) => {
const rowKey = String(row.id)
const deliveryCode = String(row.delivery_order_code ?? '').trim()
const wave = {
wave_no: row.wave_no,
wave_id: row.wave_id,
}
const orderId = deliveryCode ? codeToOrderId.get(deliveryCode) : undefined
if (!orderId) {
if (deliveryCode) missingDeliveryCodes.push(deliveryCode)
dataMap[rowKey] = applySandanOutboundPrintReceiverMask(
(skeleton.dataMap[rowKey] || toOutboundPrintForm({}, wave)) as Record<string, unknown>,
)
printRows[index] = row
return
}
const detailPayload = await fetchPendingOrderDetailById(orderId)
if (detailPayload) {
dataMap[rowKey] = mapPendingOrderToOutboundPrintForm(detailPayload, wave)
printRows[index] = {
...row,
order_id: orderId,
}
return
}
if (deliveryCode) missingDeliveryCodes.push(deliveryCode)
dataMap[rowKey] = applySandanOutboundPrintReceiverMask(
(skeleton.dataMap[rowKey] || toOutboundPrintForm({}, wave)) as Record<string, unknown>,
)
printRows[index] = row
},
)
return {
printRows: printRows.filter(Boolean),
dataMap,
missingDeliveryCodes: [...new Set(missingDeliveryCodes)],
}
}