WEB/src/api/order.wave/orderwave.ts
liufumingren bf9bba5059 feat(order): 波次/订单新增「确认打印状态」「领料状态」,波次页支持扫码确认打印
波次:注册全局扫码事件(src/composables/useBarcodeScan.ts),长度超过 8 位的面单号提交 order.wave.confirmPrintScan 整波确认打印,切页/失活自动摘除监听;tab 区新增「确认打印未领单 N」角标,order.wave.confirmPrintUnclaimedWaveCount 长轮询实时刷新(离开页面停止、回到页面重新轮询);列表新增确认打印状态/领料状态筛选、列与明细展示

订单:列表补齐「确认打印状态」(confirm_print_status) 与「领料状态」(claim_status) 列;ScanBox 流程状态组新增两项筛选(待处理/待出库/待处理异常/配送订单);导出字段白名单新增「领料状态」「确认打印状态」(流程状态分组,52 → 54);claim_status 文案由「认领」统一为「领料」
2026-09-20 05:01:59 +08:00

1392 lines
42 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.

import request from '@/utils/request'
const v = '1.0'
import type { WaveBatchListParams, WaveBatchListResponse, WaveBatchListSort, WaveBatchListWhere, WaveListPagination } from '@/api/order/order'
export type { WaveBatchListParams, WaveBatchListResponse, WaveBatchListSort, WaveBatchListWhere, WaveListPagination }
export { unwrapWaveBatchListResponse } from '@/api/order/order'
/** order.wave 系列 RPC 列表统一排序结构(对齐 stock.warehouse.list / order.wave.batchList) */
export type WaveListRpcSort = WaveBatchListSort
/**
* 拣货任务文本筛选支持的操作符(接口文档:like / notlike / eq,默认 like)
*/
export type WavePickTaskTextOperator = 'like' | 'notlike' | 'eq'
/**
* 拣货任务文本筛选值:顶层参数支持纯字符串,或文档约定的 { operator, value }(默认 like)
*/
export type WavePickTaskTextFilter = string | { operator?: WavePickTaskTextOperator; value: string }
export type WavePickTaskListParams = {
warehouse_id: number
pagination?: {
page?: number
pageSize?: number
current?: number
size?: number
}
page_no?: number
page_size?: number
/** 拣货任务状态:建议数组,也兼容单值/逗号分隔字符串 */
status?: number | string | Array<number | string>
review_status?: number
pick_mode?: number
/** 任务来源标识(字符串) */
source?: string
/** 拣货执行人ID(兼容旧字段) */
pick_user_id?: number
/** 拣货人姓名;支持模糊匹配,也支持 { operator: 'like'|'notlike'|'eq', value }(默认 like) */
pick_user_name?: WavePickTaskTextFilter
/** 复核人ID */
review_user_id?: number
/** 复核人姓名;支持模糊匹配,也支持 { operator, value }(默认 like) */
review_user_name?: WavePickTaskTextFilter
/** 领料人姓名;支持模糊匹配,也支持 { operator, value }(默认 like) */
claim_operator?: WavePickTaskTextFilter
/** 任务编号(模糊匹配) */
task_no?: string
/** 波次号:模糊匹配任务主表 batch_no_array,也支持 { operator, value }(默认 like) */
wave_no?: WavePickTaskTextFilter
/** 拣货车/作业车ID */
cart_id?: number
/** 拣货车编码:匹配任务主表快照 current_cart_code_snapshot,也支持 { operator, value }(默认 like) */
cart_code?: WavePickTaskTextFilter
/** 关键字搜索:task_no / batch_no / current_cart_code_snapshot 等字段的模糊匹配 */
keyword?: string
start_time_start?: string
start_time_end?: string
/** 兼容历史 where 结构(当存在顶层同名参数时顶层优先);本页仅用于承载文档未列出的 operator_name(操作人) */
where?: Record<string, any>
/** 接口文档标注:当前主表未存该字段、会被忽略,建议勿使用 */
strategy_id?: number
/** 后端排序:sortField 取列 prop(如 order_count),结构对齐 stock.warehouse.list */
sort?: WaveListRpcSort
}
/** order.wave.wavePickTaskList 列表项中的关联波次明细(wave_list) */
export type WavePickTaskWaveItem = {
wave_id?: number | string
wave_no?: string
box_no?: number | string
status?: number | string
bind_time?: string | null
pick_time?: string | null
}
/** order.wave.wavePickTaskList 列表项(与 wms_wave_pick_task 主表字段对齐) */
export type WavePickTaskListItem = {
task_id?: number | string
task_no?: string
batch_no?: string
warehouse_id?: number | string
status?: number | string
review_status?: number | string
pick_mode?: number | string
source?: number | string
wave_count?: number | string
order_count?: number | string
box_count?: number | string
operator_id?: number | string
operator_name?: string
creator_id?: number | string
creator_name?: string
pick_user_id?: number | string
pick_user_name?: string
review_user_id?: number | string
review_user_name?: string
/** 领料人:领取/认领波次的人员(order.wave.wavePickTaskList 返回) */
claim_operator_id?: number | string
claim_operator?: string
current_cart_id?: number | string
current_cart_code_snapshot?: string
/** 拣货车名(如 "拣货车40",order.wave.wavePickTaskList 返回) */
cart_name?: string
device_id?: string
start_at?: string
start_time?: string
finish_at?: string
finish_time?: string
review_start_time?: string
review_finish_time?: string
created_at?: string
create_time?: string
update_time?: string
/** 关联波次明细(列表「波次号」列由 wave_list[].wave_no 派生) */
wave_list?: WavePickTaskWaveItem[]
[key: string]: unknown
}
/** order.wave.wavePickTaskList 业务 data:list + 扁平分页字段 */
export type WavePickTaskListResponse = {
list: WavePickTaskListItem[]
total: number
page: number
page_size: number
}
type WavePickTaskListPagination = {
total?: number
page?: number
pageSize?: number
page_size?: number
}
export type WavePickTaskListApiResponse = WavePickTaskListResponse & {
code?: number
message?: string
pagination?: WavePickTaskListPagination
data?: Partial<WavePickTaskListResponse> & {
pagination?: WavePickTaskListPagination
}
}
/** 解析 order.wave.wavePickTaskList 响应(优先 data.{ list, total, page, page_size }) */
export function unwrapWavePickTaskListResponse(
res: WavePickTaskListApiResponse | null | undefined,
fallbacks?: { page?: number; page_size?: number }
): WavePickTaskListResponse {
const payload =
res?.data !== undefined && res?.data !== null && typeof res.data === 'object' && !Array.isArray(res.data)
? res.data
: res
const pagination =
payload && typeof payload === 'object' && payload.pagination && typeof payload.pagination === 'object'
? payload.pagination
: undefined
const list = Array.isArray(payload?.list)
? payload.list
: Array.isArray(res?.list)
? res.list
: []
const total = Number(payload?.total ?? pagination?.total ?? res?.total ?? 0)
const page = Number(payload?.page ?? pagination?.page ?? res?.page ?? fallbacks?.page ?? 1)
const page_size = Number(
payload?.page_size ?? pagination?.page_size ?? pagination?.pageSize ?? res?.page_size ?? fallbacks?.page_size ?? 20
)
return {
list,
total: Number.isFinite(total) ? total : 0,
page: Number.isFinite(page) && page > 0 ? page : (fallbacks?.page ?? 1),
page_size: Number.isFinite(page_size) && page_size > 0 ? page_size : (fallbacks?.page_size ?? 20)
}
}
export type WavePickTaskCancelParams = {
task_ids: Array<number | string>
}
export type WavePickTaskCancelResponse = {
cancelled_count?: number
task_ids?: Array<number | string>
task_nos?: Array<string>
task_id?: number | string
task_no?: string
}
export type WavePickTaskCancelSelfParams = {
task_id: number
}
export type WavePickTaskCancelSelfResponse = {
cancelled_count?: number
task_id?: number
task_no?: string
}
export type WaveGroupOrderFetchListParams = {
pagination?: {
page?: number
pageSize?: number
}
distinguish_express?: boolean
store_id?: number
same_order_quantity?: number
shop_name?: string
include_sku?: string
return_order_ids?: boolean
}
export type WaveGroupOrderFetchListItem = Record<string, unknown> & {
item_detail?: string
item_detail_machine?: string
item_detail_machine_snapshot?: string
item_snapshot?: string
group?: string
group_count?: number
items_total?: number
/** 总重量 g,取组内首单 items_weight */
items_weight?: number | string
store_id?: number
store_ids?: number[]
logistics_name?: string
distinguish_express?: boolean
first_order_time?: string
last_order_time?: string
status_summary?: Record<string, unknown>
order_ids?: number[]
}
export type WaveGroupOrderFetchListResponse = {
list: WaveGroupOrderFetchListItem[]
pagination: WaveListPagination
}
/** order.wave.singleOrderFetchList:参数与团购列表接口一致,语义为散单候选分组(小于同组订单阈值) */
export type WaveSingleOrderFetchListParams = WaveGroupOrderFetchListParams
export type WaveSingleOrderFetchListResponse = WaveGroupOrderFetchListResponse
export type WaveStrategyListParams = {
pagination?: {
page?: number
pageSize?: number
currentPage?: number
page_size?: number
size?: number
}
/** 仅支持 1=散单、2=团购;与 where.strategy_type 同时存在时以顶层为准 */
strategy_type?: number
/** 当前仅支持 where.strategy_type(1/2) */
where?: { strategy_type?: number } & Record<string, unknown>
/** 0-不计算(默认),1-计算并返回每条策略的 next_fetch_order_count;支持别名 calculateNextFetchOrderCount */
calculate_next_fetch_order_count?: number
calculateNextFetchOrderCount?: number
/** 0-不启用(默认),1-启用调试输出,返回每条策略的 next_fetch_order_list */
debug?: number
/** 后端排序:sortField 取列 prop(如 matched_order_count_filtered),结构对齐 stock.warehouse.list */
sort?: WaveListRpcSort
}
export type WaveStrategyRecord = Record<string, unknown> & {
id?: number
strategy_id?: number
strategyId?: number
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 | null
batch_max_skus?: number | null
group_batch_max_orders?: number | null
require_same_express?: boolean | number
allow_cross_owner?: boolean | number
description?: string
allowed_provinces?: Array<string> | string
allowed_platforms?: Array<string> | string
allowed_owners?: Array<number | string> | string
allowed_expresses?: Array<string> | string
/** 波次编号前缀,最多 5 个字符 */
wave_prefix?: string
warehouse_id?: number
create_time?: string | number
update_time?: string | number
/** 当请求 calculate_next_fetch_order_count=1 时由后端计算返回 */
next_fetch_order_count?: number
/** 当请求 debug=1 时返回结构/快递/货主 ID 等指标明细 */
next_fetch_order_list?: Array<Record<string, unknown>>
}
export type WaveStrategyListResponse = {
list: WaveStrategyRecord[]
pagination: {
page?: number
pageSize?: number
total?: number
totalPages?: number
hasPrevious?: boolean
hasNext?: boolean
}
/** 查询汇总信息对象(成功路径恒存在;含当前查询条件下全部策略命中的去重订单总数) */
info?: Record<string, unknown>
}
export type WaveStrategyCreateParams = {
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
allowed_provinces?: Array<string> | string
allowed_platforms?: Array<string> | string
allowed_owners?: Array<number | string> | string
allowed_expresses?: Array<string> | string
/** 波次编号前缀,最多 5 个字符 */
wave_prefix?: string
}
type WaveStrategyIdentityParam =
| { id: number; strategy_id?: number; strategyId?: number }
| { id?: number; strategy_id: number; strategyId?: number }
| { id?: number; strategy_id?: number; strategyId: number }
export type WaveStrategyUpdateParams = WaveStrategyIdentityParam & {
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
allowed_provinces?: Array<string> | string
allowed_platforms?: Array<string> | string
allowed_owners?: Array<number | string> | string
allowed_expresses?: Array<string> | string
/** 波次编号前缀,最多 5 个字符 */
wave_prefix?: string
}
export type WaveStrategyQuickScanParams = {
}
export type WaveStrategyQuickScanResponse = {
status: string
task_id: string
warehouse_id: number
state: string
message?: string
accepted_at?: string
}
export type WaveStrategyMutationResponse = {
data: WaveStrategyRecord
code: number
}
type WaveStrategyFetchStrategyId =
| { strategy_id: number; strategyId?: number }
| { strategy_id?: number; strategyId: number }
/** order.wave.waveStrategyFetchAdmin / waveStrategyFetchPda 入参(支持下划线/驼峰别名) */
export type WaveStrategyFetchAdminParams = WaveStrategyFetchStrategyId & {
cart_id?: string | number
cartId?: string | number
source?: string
operation_source?: string
strategy_params?: Record<string, unknown>
strategyParams?: Record<string, unknown>
}
export type WaveStrategyFetchPdaParams = WaveStrategyFetchAdminParams
/** 按策略创建抓取主流程任务后的响应(Admin / PDA 一致,见 module order.wave) */
export type WaveStrategyFetchTaskCreatedResponse = {
state?: string
/** fetch_state=2 时为 null;fetch_state=3 时可能为已有任务的 ID */
task_id?: string | null
task_no?: string | null
/** 文档描述「existing task_id/task_no」时部分实现单独字段 */
existing_task_id?: string | null
existing_task_no?: string | null
/** fetch_state=2 时后端可能返回空对象 */
plan?: Record<string, unknown>
plan_summary?: string
warehouse_id?: number
strategy_id?: number
validation_errors?: Array<{ field?: string; message?: string }>
message?: string
/**
* 1=成功创建任务(task_id/task_no)
* 2=普通失败(task_id 常为 null)
* 3=存在未完成任务(返回已有 task_id/task_no,可进入拣货流程)
*/
fetch_state?: number
tip?: string
/** fetch_state=3 时为 true,表示可直接进入拣货流程 */
can_enter_pick_flow?: boolean
}
/** @deprecated 使用 WaveStrategyFetchTaskCreatedResponse */
export type WaveStrategyFetchByStrategyResponse = WaveStrategyFetchTaskCreatedResponse
export type WaveStrategyQuickScanTaskProgressParams = {
task_id?: string
taskId?: string
}
export type WaveStrategyQuickScanTaskProgressResponse = {
task_id: string
state: 'submitted' | 'running' | 'success' | 'failed' | 'not_found' | string
warehouse_id?: number
total_order_count?: number
processed_order_count?: number
matched_order_count?: number
unmatched_order_count?: number
progress_percent?: number
submitted_at?: string
start_time?: string
end_time?: string
error_message?: string
error_code?: string
duration_ms?: number
}
/** order.wave.waveStrategyFallbackOrderList where 白名单字段 */
export type WaveStrategyFallbackOrderListWhere = {
/** 订单 ID(等值匹配) */
id?: string | number
/** 发货单号(模糊匹配),兼容 deliveryNo */
delivery_no?: string
deliveryNo?: string
/** 运单号(模糊匹配),兼容 trackingNo */
tracking_no?: string
trackingNo?: string
/** 商品种类数下限 */
items_count_min?: number
/** 商品种类数上限 */
items_count_max?: number
/** 商品总数下限 */
items_total_min?: number
/** 商品总数上限 */
items_total_max?: number
/** 系统物流名称(模糊匹配) */
sys_logistics_name?: string
/** 货主名称(模糊匹配) */
store_name?: string
/** 货主(等值匹配) */
owner_name?: string
/** 省份(模糊匹配) */
province?: string
/** 系统平台名称(模糊匹配) */
sys_platform_name?: string
/** 买家留言筛选(虚拟字段:true=有留言,false=无留言) */
buyer_message_has?: boolean
/** 禁止传入 */
warehouse_id?: never
warehouseId?: never
}
export type WaveStrategyFallbackOrderListParams = {
/** 分页参数,仅支持 page / pageSize */
pagination?: {
page?: number
pageSize?: number
}
/**
* 筛选白名单字段。
* 仅支持上述 where 类型中声明的字段,禁止传入 warehouse_id / warehouseId。
* 若传入未列出的字段或禁止字段,接口返回 400。
*/
where?: WaveStrategyFallbackOrderListWhere
}
/** 不符合波次策略订单行(回退候选订单简要列表)。
* 该接口内置固定筛选:step != 0、wave_id = 0、wave_scan_result = 2。
* - item_snapshot:商品名称*数量拼接快照(如 "商品A*2|商品B*1")
*/
export type WaveStrategyFallbackOrderListRow = Record<string, unknown> & {
id?: number | string
delivery_no?: string
tracking_no?: string
sys_logistics_name?: string
store_name?: string
owner_name?: string
province?: string
sys_platform_name?: string
items_count?: number | string
items_total?: number | string
items_weight?: number | string
weight_type?: string
buyer_message?: string
item_snapshot?: string
store_remark?: string
/** 排除原因中文标记:已锁定(lock_status 非 none)、已拦截、已打印、未匹配策略 */
excluded_reason?: '已锁定' | '已拦截' | '已打印' | '未匹配策略' | string
}
export type WaveStrategyFallbackOrderListPagination = {
page?: number
pageSize?: number
total?: number
totalPages?: number
hasPrevious?: boolean
hasNext?: boolean
}
export type WaveStrategyFallbackOrderListResponse = {
list: WaveStrategyFallbackOrderListRow[]
pagination: WaveStrategyFallbackOrderListPagination
}
export type WaveFetchParams = {
structure_list: Array<{
item_detail_machine: string
quantity?: number
}>
}
/** order.wave.singleFetch:每项须含 max_fetch_quantity(上限订单数) */
export type WaveSingleFetchParams = {
structure_list: Array<{
item_detail_machine: string
max_fetch_quantity: number
quantity?: number
}>
}
export type WaveFetchResponse = {
task_id: string
warehouse_id: number
structure_count: number
default_quantity: number
auto_fetch_disabled_marker: string
fetch_mode?: string
max_fetch_quantity?: number
message?: string
}
export type WaveFetchTaskProgressParams = {
task_id?: string
taskId?: string
}
export type WaveFetchTaskProgressResponse = {
task_id: string
status: 'submitted' | 'running' | 'success' | 'failed' | 'not_found'
warehouse_id?: number
structure_count?: number
finished_structure_count?: number
progress_percent?: number
total_fetched_quantity?: number
duration_ms?: number
error?: string
update_time?: string
message?: string
fetch_mode?: string
max_fetch_quantity?: number
limit_reached?: boolean
stop_reason?: string
}
export type WaveBatchAllocateExpressParams = {
wave_ids: Array<string | number> | string | number
task_id?: string
taskId?: string
}
export type WaveBatchAllocateExpressResponse = {
status: string
task_id: string
warehouse_id: number
accepted_at: string
message?: string
}
export type WaveBatchAllocateExpressTaskProgressParams = {
task_id?: string
taskId?: string
}
export type WaveBatchAllocateExpressTaskProgressResponse = {
task_id: string
state: 'submitted' | 'running' | 'success' | 'failed' | 'not_found' | string
warehouse_id?: number
total_wave_count?: number
total_order_count?: number
processed_order_count?: number
success_order_count?: number
failed_order_count?: number
/** 因已锁定(lock_status 非 none)被跳过、未参与快递号分配的订单 ID 列表(任务进度与 result 中均返回) */
skipped_locked_order_ids?: Array<number | string>
progress_percent?: number
duration_ms?: number
error_message?: string
error_code?: string
// Backward-compatible fields
status?: 'submitted' | 'running' | 'success' | 'failed' | 'not_found' | string
total_count?: number
success_count?: number
failed_count?: number
allocated_order_count?: number
update_time?: string
error?: string
message?: string
}
export type WaveBatchAllocateStorageParams = {
wave_ids: Array<string | number> | string | number
task_id?: string
taskId?: string
}
export type WaveBatchAllocateStorageResponse = {
status: string
task_id: string
warehouse_id: number
accepted_at: string
message?: string
}
export type WaveBatchAllocateStorageTaskProgressParams = {
task_id?: string
taskId?: string
}
export type WaveBatchAllocateStorageTaskProgressResponse = {
task_id: string
state: 'submitted' | 'running' | 'success' | 'failed' | 'not_found' | string
warehouse_id?: number
total_wave_count?: number
total_order_count?: number
processed_order_count?: number
success_order_count?: number
failed_order_count?: number
progress_percent?: number
duration_ms?: number
error_message?: string
error_code?: string
// Backward-compatible fields
status?: 'submitted' | 'running' | 'success' | 'failed' | 'not_found' | string
total_count?: number
success_count?: number
failed_count?: number
allocated_order_count?: number
update_time?: string
error?: string
message?: string
}
export type WaveBatchRemoveExceptionOrdersParams = {
wave_ids: Array<string | number> | string | number
task_id?: string
taskId?: string
}
export type WaveBatchRemoveExceptionOrdersResponse = {
status: string
task_id: string
warehouse_id: number
accepted_at: string
message?: string
}
export type WaveBatchRemoveExceptionOrdersTaskProgressParams = {
task_id?: string
taskId?: string
}
export type WaveBatchRemoveExceptionOrdersTaskProgressResponse = {
task_id: string
state: 'submitted' | 'running' | 'success' | 'failed' | 'not_found' | string
warehouse_id?: number
total_wave_count?: number
total_order_count?: number
processed_order_count?: number
removed_order_count?: number
failed_order_count?: number
progress_percent?: number
duration_ms?: number
error_message?: string
error_code?: string
// Backward-compatible fields
status?: 'submitted' | 'running' | 'success' | 'failed' | 'not_found' | string
total_count?: number
success_count?: number
failed_count?: number
update_time?: string
error?: string
message?: string
}
export type WaveBatchCancelParams = {
ids?: Array<string | number> | string | number
wave_ids?: Array<string | number> | string | number
waveIds?: Array<string | number> | string | number
task_id?: string
taskId?: string
}
export type WaveBatchCancelResponse = {
status: string
task_id: string
warehouse_id: number
accepted_at: string
message?: string
}
export type WaveBatchCancelTaskProgressParams = {
task_id?: string
taskId?: string
}
export type WaveBatchCancelTaskProgressResponse = {
task_id: string
state: 'submitted' | 'running' | 'success' | 'failed' | 'not_found' | string
progress_percent?: number
total_wave_count?: number
processed_wave_count?: number
duration_ms?: number
error_message?: string
error_code?: string
result?: Record<string, unknown>
// Backward-compatible fields
status?: 'submitted' | 'running' | 'success' | 'failed' | 'not_found' | string
total_count?: number
success_count?: number
failed_count?: number
total_order_count?: number
processed_order_count?: number
update_time?: string
error?: string
message?: string
}
export type WaveBatchAutoGroupingParams = {
ids: Array<string | number> | string | number
}
export type WaveBatchAutoGroupingResponse = {
ids?: Array<number | string>
affected_wave_ids?: Array<number | string>
updated_wave_count?: number
skipped_wave_ids?: Array<number | string>
skipped_wave_count?: number
skipped_details?: Array<{ wave_id?: number | string; reason?: string }>
}
export type WaveBatchFinishAutoGroupingParams = {
ids: Array<string | number> | string | number
}
export type WaveBatchFinishAutoGroupingResponse = {
ids?: Array<number | string>
affected_wave_ids?: Array<number | string>
updated_wave_ids?: Array<number | string>
updated_wave_count?: number
}
export type WaveBatchRemoveOrdersParams = {
ids?: Array<string | number> | string | number
order_ids?: Array<string | number> | string | number
orderIds?: Array<string | number> | string | number
order_id?: string | number
orderId?: string | number
id?: string | number
}
export type WaveBatchRemoveOrdersResponse = {
ids: Array<number | string>
removed_order_ids: Array<number | string>
removed_order_count: number
affected_wave_ids: Array<number | string>
updated_wave_ids: Array<number | string>
emptied_wave_ids: Array<number | string>
}
export function orderWaveWavePickTaskList(
data: WavePickTaskListParams
): Promise<WavePickTaskListApiResponse> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.wavePickTaskList',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveWavePickTaskCancel(
data: WavePickTaskCancelParams
): Promise<WavePickTaskCancelResponse & { code?: number; message?: string; data?: Partial<WavePickTaskCancelResponse> }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.wavePickTaskCancel',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveWavePickTaskCancelSelf(
data: WavePickTaskCancelSelfParams
): Promise<WavePickTaskCancelSelfResponse & { code?: number; message?: string; data?: Partial<WavePickTaskCancelSelfResponse> }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.wavePickTaskCancelSelf',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveGroupOrderFetchList(
data: WaveGroupOrderFetchListParams = {}
): Promise<WaveGroupOrderFetchListResponse & { code?: number; message?: string; data?: Partial<WaveGroupOrderFetchListResponse> }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.groupOrderFetchList',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveSingleOrderFetchList(
data: WaveSingleOrderFetchListParams = {}
): Promise<WaveSingleOrderFetchListResponse & { code?: number; message?: string; data?: Partial<WaveSingleOrderFetchListResponse> }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.singleOrderFetchList',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveWaveStrategyList(
data: WaveStrategyListParams = {}
): Promise<WaveStrategyListResponse & { code?: number; message?: string; data?: Partial<WaveStrategyListResponse> }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.waveStrategyList',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveWaveStrategyCreate(
data: WaveStrategyCreateParams
): Promise<WaveStrategyMutationResponse & { code?: number; message?: string; data?: WaveStrategyRecord }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.waveStrategyCreate',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveWaveStrategyUpdate(
data: WaveStrategyUpdateParams
): Promise<WaveStrategyMutationResponse & { code?: number; message?: string; data?: WaveStrategyRecord }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.waveStrategyUpdate',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveWaveStrategyQuickScan(
data: WaveStrategyQuickScanParams = {}
): Promise<WaveStrategyQuickScanResponse & { code?: number; message?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.waveStrategyQuickScan',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveWaveStrategyFetchAdmin(
data: WaveStrategyFetchAdminParams
): Promise<WaveStrategyFetchTaskCreatedResponse & { code?: number; message?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.waveStrategyFetchAdmin',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveWaveStrategyFetchPda(
data: WaveStrategyFetchPdaParams
): Promise<WaveStrategyFetchTaskCreatedResponse & { code?: number; message?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.waveStrategyFetchPda',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveWaveStrategyQuickScanTaskProgress(
data: WaveStrategyQuickScanTaskProgressParams
): Promise<WaveStrategyQuickScanTaskProgressResponse & { code?: number; message?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.waveStrategyQuickScanTaskProgress',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveWaveStrategyFallbackOrderList(
data: WaveStrategyFallbackOrderListParams = {}
): Promise<WaveStrategyFallbackOrderListResponse & { code?: number; message?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.waveStrategyFallbackOrderList',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export type WaveSingleFetchByIdsParams = {
ids?: Array<string | number> | string | number
order_ids?: Array<string | number> | string | number
orderIds?: Array<string | number> | string | number
}
export type WaveSingleFetchByIdsResponse = {
ids: Array<number>
wave_id: number
wave_no: string
fetched_order_ids: Array<number>
fetched_order_count: number
excluded_existing_wave_order_ids?: Array<number>
/** 因已锁定(lock_status 非 none)被排除、不会被抓取波次的订单 ID 列表(成功与无可抓取订单两个返回分支均返回) */
excluded_locked_order_ids?: Array<number>
skipped_order_ids?: Array<number>
not_found_order_ids?: Array<number>
}
export function orderWaveSingleFetchByIds(
data: WaveSingleFetchByIdsParams
): Promise<WaveSingleFetchByIdsResponse & { code?: number; message?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.singleFetchByIds',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveFetch(data: WaveFetchParams): Promise<WaveFetchResponse & { code?: number; message?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.fetch',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveGroupFetch(data: WaveFetchParams): Promise<WaveFetchResponse & { code?: number; message?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.groupFetch',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveSingleFetch(data: WaveSingleFetchParams): Promise<WaveFetchResponse & { code?: number; message?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.singleFetch',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveFetchTaskProgress(data: WaveFetchTaskProgressParams): Promise<WaveFetchTaskProgressResponse & { code?: number; message?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.fetchTaskProgress',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveBatchAllocateExpress(data: WaveBatchAllocateExpressParams): Promise<WaveBatchAllocateExpressResponse & { code?: number; message?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.batchAllocateExpress',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveBatchAllocateExpressTaskProgress(data: WaveBatchAllocateExpressTaskProgressParams): Promise<WaveBatchAllocateExpressTaskProgressResponse & { code?: number; message?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.batchAllocateExpressTaskProgress',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveBatchAllocateStorage(data: WaveBatchAllocateStorageParams): Promise<WaveBatchAllocateStorageResponse & { code?: number; message?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.batchAllocateStorage',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveBatchAllocateStorageTaskProgress(data: WaveBatchAllocateStorageTaskProgressParams): Promise<WaveBatchAllocateStorageTaskProgressResponse & { code?: number; message?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.batchAllocateStorageTaskProgress',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveBatchRemoveExceptionOrders(data: WaveBatchRemoveExceptionOrdersParams): Promise<WaveBatchRemoveExceptionOrdersResponse & { code?: number; message?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.batchRemoveExceptionOrders',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveBatchRemoveExceptionOrdersTaskProgress(data: WaveBatchRemoveExceptionOrdersTaskProgressParams): Promise<WaveBatchRemoveExceptionOrdersTaskProgressResponse & { code?: number; message?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.batchRemoveExceptionOrdersTaskProgress',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveBatchCancel(
data: WaveBatchCancelParams
): Promise<WaveBatchCancelResponse & { code?: number; message?: string; data?: Record<string, unknown>; flag?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.batchCancel',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveBatchCancelTaskProgress(data: WaveBatchCancelTaskProgressParams): Promise<WaveBatchCancelTaskProgressResponse & { code?: number; message?: string; flag?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.batchCancelTaskProgress',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveBatchAutoGrouping(
data: WaveBatchAutoGroupingParams
): Promise<WaveBatchAutoGroupingResponse & { code?: number; message?: string; data?: Record<string, unknown> }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.batchAutoGrouping',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveBatchFinishAutoGrouping(
data: WaveBatchFinishAutoGroupingParams
): Promise<WaveBatchFinishAutoGroupingResponse & { code?: number; message?: string; data?: Record<string, unknown> }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.batchFinishAutoGrouping',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function orderWaveBatchRemoveOrders(
data: WaveBatchRemoveOrdersParams
): Promise<WaveBatchRemoveOrdersResponse & { code?: number; message?: string; data?: Partial<WaveBatchRemoveOrdersResponse>; flag?: string }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.batchRemoveOrders',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
/** order.wave.confirmPrintScan 入参:扫描波次内任一订单的面单号确认打印 */
export type WaveConfirmPrintScanParams = {
/** 面单号/运单号(必填,用于定位订单及所属波次) */
waybill_no: string
}
/** order.wave.confirmPrintScan 业务 data */
export type WaveConfirmPrintScanResponse = {
/** 扫描的面单号 */
waybill_no?: string
/** 面单号匹配到的订单ID */
matched_order_id?: number
/** 波次ID */
wave_id?: number
/** 波次编码 */
wave_no?: string
/** 波次下总订单数 */
total_order_count?: number
/** 波次下拦截订单数(跳过确认) */
intercepted_order_count?: number
/** 已确认打印订单数(confirm_print_status='fin') */
confirmed_order_count?: number
/** 本次新增确认订单数(仅 status=confirmed 时返回) */
newly_confirmed_order_count?: number
/** confirmed=本次完成确认 / already_confirmed=已全部确认 */
status: 'confirmed' | 'already_confirmed' | string
}
/**
* order.wave.confirmPrintScan:扫描波次内任一订单的面单号,将该波次下全部已打印(print_status='fin')
* 且非拦截订单批量置 confirm_print_status='fin',并写订单操作日志(ORDER_CONFIRM_PRINT)。
* - 拦截订单跳过(不确认、不阻断);
* - 波次下存在未打印订单(print_status != 'fin')时阻断:返回 unprinted_order_count;
* - 全部已确认时重复扫描返回 status=already_confirmed。
*/
export function orderWaveConfirmPrintScan(
data: WaveConfirmPrintScanParams
): Promise<WaveConfirmPrintScanResponse & { code?: number; message?: string; data?: Partial<WaveConfirmPrintScanResponse>; unprinted_order_count?: number }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.confirmPrintScan',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
/** order.wave.confirmPrintUnclaimedWaveCount 入参:长轮询上次数量 */
export type WaveConfirmPrintUnclaimedWaveCountParams = {
/**
* 上次返回的数量(长轮询游标):
* 不传 → 立即返回当前值(status=current);传入且与当前值不同 → 立即返回新值(status=changed);
* 相同 → 挂起等待,最长 60 秒(期间变化立即返回 changed,超时重查后返回 timeout)。
*/
last_count?: number
}
/** order.wave.confirmPrintUnclaimedWaveCount 业务 data */
export type WaveConfirmPrintUnclaimedWaveCountResponse = {
/** 已确认打印(confirm_print_status='fin')但未领单(claim_status != 'fin')订单涉及的波次数量 */
count: number
/** current=直接返回当前值 / changed=数量已变化 / timeout=等待超时后返回当前值 */
status: 'current' | 'changed' | 'timeout' | string
}
/**
* order.wave.confirmPrintUnclaimedWaveCount:查询「已确认打印但未领单」波次数量,支持长轮询。
* 注意:长轮询最长挂起 60 秒,超过请求层默认 10 秒超时,故单独放开 timeout。
*/
export function orderWaveConfirmPrintUnclaimedWaveCount(
data: WaveConfirmPrintUnclaimedWaveCountParams = {}
): Promise<WaveConfirmPrintUnclaimedWaveCountResponse & { code?: number; message?: string; data?: Partial<WaveConfirmPrintUnclaimedWaveCountResponse> }> {
return request({
url: '/system',
method: 'post',
params: {
method: 'order.wave.confirmPrintUnclaimedWaveCount',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true,
// 长轮询最长等待 60 秒(请求层默认 10 秒会提前中断)
timeout: 70000
} as any)
}
export const orderWave = {
confirmPrintScan: orderWaveConfirmPrintScan,
confirmPrintUnclaimedWaveCount: orderWaveConfirmPrintUnclaimedWaveCount,
wavePickTaskList: orderWaveWavePickTaskList,
wavePickTaskCancel: orderWaveWavePickTaskCancel,
wavePickTaskCancelSelf: orderWaveWavePickTaskCancelSelf,
groupOrderFetchList: orderWaveGroupOrderFetchList,
singleOrderFetchList: orderWaveSingleOrderFetchList,
waveStrategyList: orderWaveWaveStrategyList,
waveStrategyCreate: orderWaveWaveStrategyCreate,
waveStrategyUpdate: orderWaveWaveStrategyUpdate,
waveStrategyQuickScan: orderWaveWaveStrategyQuickScan,
waveStrategyFetchAdmin: orderWaveWaveStrategyFetchAdmin,
waveStrategyFetchPda: orderWaveWaveStrategyFetchPda,
waveStrategyQuickScanTaskProgress: orderWaveWaveStrategyQuickScanTaskProgress,
waveStrategyFallbackOrderList: orderWaveWaveStrategyFallbackOrderList,
singleFetchByIds: orderWaveSingleFetchByIds,
groupFetch: orderWaveGroupFetch,
singleFetch: orderWaveSingleFetch,
fetch: orderWaveFetch,
fetchTaskProgress: orderWaveFetchTaskProgress,
batchAllocateExpress: orderWaveBatchAllocateExpress,
batchAllocateExpressTaskProgress: orderWaveBatchAllocateExpressTaskProgress,
batchAllocateStorage: orderWaveBatchAllocateStorage,
batchAllocateStorageTaskProgress: orderWaveBatchAllocateStorageTaskProgress,
batchRemoveExceptionOrders: orderWaveBatchRemoveExceptionOrders,
batchRemoveExceptionOrdersTaskProgress: orderWaveBatchRemoveExceptionOrdersTaskProgress,
batchCancel: orderWaveBatchCancel,
batchCancelTaskProgress: orderWaveBatchCancelTaskProgress,
batchAutoGrouping: orderWaveBatchAutoGrouping,
batchFinishAutoGrouping: orderWaveBatchFinishAutoGrouping,
batchRemoveOrders: orderWaveBatchRemoveOrders
}