WEB/src/api/order.pendingorder/orderpendingOrder.ts
yin 1a51150d2c feat(b2b): 新增 B2B 备货/提货作业流程,补全乡镇地址选择与列表排序
- 新增 B2B 作业接口:startB2bPrep / cancelB2bPrep / finishB2bPrep / pickupB2b /
  setB2bUrgent / cancelB2bUrgent;待处理与配送 B2B 页签新增「开始备货、备货完成、
  取消备货、确认提货、加急/取消加急」按钮
- 新增 B2bPrepFinishForm(必填备货备注 + 总箱数校验,完成后同步扣减库存)与
  use-b2b-actions 组合式:单行操作校验、确认弹窗、统一 loading 与成功后刷新
- 配送 B2B 页面复用配送页组件,增加 B2B 专用列与 ScanBox 字段,使用独立 cache-key
- 新增 utils/chinaStreet:按 area_code 提供乡镇/街道选项,pcas 四級数据懒加载并
  按区缓存;vite 将 pcas 单独拆为 vendor-china-division-street 块,避免与
  省市区数据合成大 chunk
- 新建订单预览行的「镇」改为街道下拉(支持输入新建),行政区数据按需加载;
  预览新增「只看异常 N 行」过滤
- 快递接口配置的市/区下拉增加缓存,避免预览表逐格重复遍历
- 退货签收登记列表支持排序白名单(id/scan_date/created_at/updated_at/waybill_code),
  重复登记提示补充加急与货主备注;货主签约页新增「发起签约」弹窗与筛选,
  店铺接口配置新增「对方主体ID」筛选项
- 移除 storeWarehouse 中未使用的 storeList / queryPrintQuantityLogs 接口
2026-11-18 18:05:41 +08:00

1291 lines
41 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";
import {
orderModulePendingOrderDownloadCreateTemplate,
orderModulePendingOrderManualWaybill,
orderModulePendingOrderAllocateSubOrderNumber,
orderModulePendingOrderAllocateSubOrderNumberProgress,
} from "@/api/order/order";
const v = "1.0";
export type { OrderWorkbenchListResponse, OrderListPagination } from '@/api/order.index/orderindex'
import type { OrderWorkbenchListResponse as PendingOrderWorkbenchListResponse } from '@/api/order.index/orderindex'
export type {
PendingOrderDownloadCreateTemplateResponse,
PendingOrderManualWaybillParams,
PendingOrderManualWaybillResponse,
PendingOrderAllocateSubOrderNumberParams,
PendingOrderAllocateSubOrderNumberData,
PendingOrderAllocateSubOrderNumberProgressParams,
PendingOrderAllocateSubOrderNumberProgressData,
} from '@/api/order/order'
export const orderPendingOrderDownloadCreateTemplate = orderModulePendingOrderDownloadCreateTemplate;
export const orderPendingOrderManualWaybill = orderModulePendingOrderManualWaybill;
export const orderPendingOrderAllocateSubOrderNumber = orderModulePendingOrderAllocateSubOrderNumber;
export const orderPendingOrderAllocateSubOrderNumberProgress = orderModulePendingOrderAllocateSubOrderNumberProgress;
export type OrderWhere = Record<string, any>;
export type OrderSort = {
sortField?: string;
sortOrder?: "asc" | "desc" | "ASC" | "DESC";
field?: string;
order?: "asc" | "desc" | "ASC" | "DESC";
};
export type OrderPagination = {
page?: number;
pageSize?: number;
};
export type PendingOrderListParams = {
pagination?: OrderPagination;
/**
* 统一 where 条件对象;禁止传入 warehouse_id / warehouseId。where 无字段白名单,可直接传订单表列名。
* lock_status 锁定状态筛选(筛选值用数据库原始枚举 none/warehouse/store,不是响应中的 Y/N;ne 表示不等于;条件值为空自动忽略):
* 未锁定 {"lock_status":"none"};已锁定(所有非 none){"lock_status":{"operator":"ne","value":"none"}}
* create_channel 订单来源渠道筛选(按订单表 create_channel 列过滤;枚举:MANUAL=手工单、API=接口、QM=奇门、STOCKOUT=出库转单):
* {"create_channel":"MANUAL"} 单值精确;{"create_channel":["QM","API"]} 裸数组按 in 多选;
* {"create_channel":{"operator":"in","value":["QM","API"]}} 标准结构多选;{"create_channel":{"operator":"ne","value":"MANUAL"}} 排除指定渠道。
* 注意:列表响应中的 create_channel 已格式化为中文标签,查询条件须传英文枚举值。
* confirm_print_status 确认打印状态筛选(按订单表列过滤;枚举:none=未确认打印、fin=已确认打印):
* {"confirm_print_status":"fin"} 单值精确,也支持裸数组按 in 与 {operator,value} 标准结构(同 create_channel 示例)。
* claim_status 领料状态筛选(按订单表列过滤;枚举:none=未领料、padding=领料中、fin=已领料、error=异常):
* 例 {"claim_status":{"operator":"ne","value":"fin"}} 查未完成领料的订单。
* is_sn_order 是否含 SN(序列号)商品筛选(按 has_sn_item 归一化):{"is_sn_order":"Y"} 仅 SN 订单、"N" 仅非 SN 订单。
* sn_code / snCode / sn_codes / snCodes 按 SN 码反查订单(先查 wms_order_item_sn 回填,支持单值/分隔字符串/数组,完整码精确匹配)。
* 默认排除 B2B 订单(is_b2b='Y',NULL 存量行视为非 B2B)——服务端固定条件,前端无法通过 where 覆盖;
* 需要查询 B2B 订单请使用 order.pendingOrder2b.list / order.deliveryOrder2b.list。
*/
where?: OrderWhere;
sort?: OrderSort;
};
/**
* 待处理订单列表响应 data(与 order.pendingOrder.list module.json 对齐)。
* - list 每项含 store_remark(货主备注)、wave_index(波次内序号,无记录时为 0)。
* - list 每项 lock_status 统一输出为 Y/N:none(含空值)→ 'N',其余值(如 warehouse/store)→ 'Y'。
*/
export type PendingOrderListResponse = PendingOrderWorkbenchListResponse;
export type PendingOrderDetailParams = {
ids?: Array<number | string> | string | number;
id?: number | string;
order_id?: number | string;
orderId?: number | string;
tableType?: string;
tablePosition?: string;
type?: string;
moduleName?: string;
};
/** markPendingOutboundOrder / cancelOrder:文档要求订单 ID 正整数数组,不支持单 id 或逗号字符串 */
export type PendingOrderIdsParams = {
ids: number[];
};
export type PendingOrderReverseReviewParams = {
ids: number[];
};
export type PendingOrderAllocateExpressCodeParams = {
/** 订单 ID 数组,sys_platform_code / logistics_code 等字段由后端从数据库读取 */
ids: number[];
};
export type PendingOrderUpdateOrderPlatformParams = {
order_ids: number[];
code: string;
};
export type PendingOrderUpdateOrderExpressParams = {
order_ids: number[];
express_code: string;
};
export type PendingOrderUpdateAddressParams = {
ids: number[];
name?: string;
mobile?: string;
tel?: string;
zip_code?: string;
province?: string;
city?: string;
area?: string;
town?: string;
detail_address?: string;
/** 订单留言/备注,对应列表字段 remark */
remark?: string;
};
export type PendingOrderCloneOrderParams = {
order_id: number;
};
export type PendingOrderCreateOrderItem = {
item_id: number;
plan_qty: number;
item_name?: string;
order_line_no?: string;
actual_price?: number;
};
export type PendingOrderCreateOrderParams = {
store_id: number;
name: string;
mobile?: string;
tel?: string;
detail_address: string;
province: string;
city: string;
area: string;
town?: string;
zip_code?: string;
items: PendingOrderCreateOrderItem[];
delivery_order_code?: string;
logistics_code?: string;
logistics_name?: string;
sys_platform_code?: string;
shop_nick?: string;
remark?: string;
source_platform_code?: string;
source_order_codes?: string;
order_type?: string;
is_urgency?: string;
invoice_flag?: string;
};
export type PendingOrderImportOrdersFromExcelParams = {
file_base64: string;
};
/** 批量拦截提交参数 */
export type PendingOrderBatchInterceptParams = {
order_ids?: number[]
orderIds?: number[]
ids?: number[]
task_id?: string
taskId?: string
};
/** 批量拦截任务进度查询参数 */
export type PendingOrderBatchInterceptProgressParams = {
task_id?: string
taskId?: string
};
export type PendingOrderParseAddressParams = {
/** 单条地址解析(与 addresses 二选一) */
address?: string;
/** 批量地址解析(单次最多 50 条) */
addresses?: string[];
};
export type PendingOrderParseAddressData = {
province?: string
city?: string
area?: string
town?: string
detailAddress?: string
name?: string
mobile?: string
};
/** 批量解析结果项(按输入顺序返回) */
export type PendingOrderParseAddressItem = PendingOrderParseAddressData & {
address?: string
flag?: string
message?: string
};
export type PendingOrderParseAddressResponse = {
flag?: string;
code: number;
message: string;
timestamp?: number;
data?: PendingOrderParseAddressData & { list?: PendingOrderParseAddressItem[] };
/** 批量解析结果数组(实际响应中位于顶层,兼容 data.list) */
list?: PendingOrderParseAddressItem[];
} & PendingOrderParseAddressData;
export function extractPendingOrderParseAddressData(
res?: PendingOrderParseAddressResponse | null,
): PendingOrderParseAddressData {
const nested = res?.data;
if (
nested &&
(nested.province ||
nested.city ||
nested.area ||
nested.town ||
nested.detailAddress ||
nested.name ||
nested.mobile)
) {
return nested;
}
return {
province: res?.province,
city: res?.city,
area: res?.area,
town: res?.town,
detailAddress: res?.detailAddress,
name: res?.name,
mobile: res?.mobile,
};
}
/** 提取批量解析结果列表,未返回时为空数组(兼容顶层 list 与 data.list) */
export function extractPendingOrderParseAddressList(
res?: PendingOrderParseAddressResponse | null,
): PendingOrderParseAddressItem[] {
const nestedList = res?.data?.list;
if (Array.isArray(nestedList)) return nestedList;
const topList = res?.list;
return Array.isArray(topList) ? topList : [];
}
/** 与文档 Params 别名对齐;不再传 warehouse_id(由登录上下文决定仓库) */
export type PendingOrderAllocateStorageParams = {
allow_storage_location?: boolean;
allowStorageLocation?: boolean;
is_allow_storage?: boolean;
isAllowStorage?: boolean;
order_ids?: Array<number | string> | string | number;
orderIds?: Array<number | string> | string | number;
ids?: Array<number | string> | string | number;
order_id?: number | string;
orderId?: number | string;
id?: number | string;
};
/** allocateStorage 异步受理响应(与文档一致) */
export type PendingOrderAllocateStorageResponse = {
request_id: string;
warehouse_id: number;
message: string;
};
export type PendingOrderAllocateStorageProgressParams = {
request_id?: string;
requestId?: string;
};
export type PendingOrderAllocateStorageProgressResponse = {
request_id: string;
status: "submitted" | "running" | "success" | "failed" | "not_found";
result?: Record<string, unknown>;
error?: string;
warehouse_id?: number;
update_time?: string;
message?: string;
};
/** syncOrderIds:订单 ID 列表(必填,支持多种别名) */
export type PendingOrderSyncOrderIdsParams = {
/** 订单 ID 列表,支持数组、逗号分隔字符串或单个 ID */
order_ids?: Array<number | string> | string | number;
orderIds?: Array<number | string> | string | number;
ids?: Array<number | string> | string | number;
order_id?: number | string;
orderId?: number | string;
id?: number | string;
};
/** syncOrderIds 响应:异步模式,返回 request_id 供 syncOrderIdsProgress 轮询 */
export type PendingOrderSyncOrderIdsResponse = {
flag: string;
code: number;
message: string;
request_id: string;
warehouse_id: number;
data?: {
order_ids?: Array<number | string>;
[key: string]: unknown;
};
};
/** syncOrderIdsProgress 查询参数 */
export type PendingOrderSyncOrderIdsProgressParams = {
request_id?: string;
requestId?: string;
};
/** syncOrderIdsProgress 进度响应 */
export type PendingOrderSyncOrderIdsProgressResponse = {
flag: string;
code: number;
message: string;
request_id: string;
status: 'submitted' | 'running' | 'success' | 'failed' | 'not_found';
progress: number;
total_count?: number;
processed_count?: number;
warehouse_id?: number;
result?: {
success_count?: number;
failed_count?: number;
dispatch_results?: Record<string, unknown>;
[key: string]: unknown;
};
error?: string;
update_time?: number;
};
export function orderPendingOrderList(data: PendingOrderListParams = {}): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.list",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
/**
* order.pendingOrder2b.list:B2B 待处理订单列表
* - 查询条件与 order.pendingOrder.list 完全一致(current 分表 + 默认 outbound_status != padding 且 step in [1,2,3])
* - 额外强制 is_b2b='Y'(与请求 where 取 AND,传 is_b2b='N' 只会得到空列表)
* - 行内额外带出 wms_order_b2b 作业字段(无作业明细行时占位:数值 0 / is_picked_up=N / 时间为 null):
* total_box_count、pickup_plate_number、prep_remark、prep_duration_seconds、is_urgent(Y/N)、prep_at、
* is_picked_up(Y/N)、picked_up_at、created_at(作业明细创建时间,与订单 create_at 不同)、
* prep_status(none/padding/fin)、prep_operator_id、prep_operator_name、prep_start_at
* - where 额外支持(仅 B2B 列表开放,普通列表不识别):total_box_count / pickup_plate_number / prep_remark /
* prep_duration_seconds / is_picked_up / picked_up_at / created_at / prep_at / is_urgent /
* prep_status / prep_operator_id / prep_start_at(支持简写与 {operator,value} 标准结构,prep_at 支持 between)
* - 排序固定「加急优先」(is_urgent='Y' 在前、无作业明细行排最后),sort 只决定加急/非加急各自内部次序
* (缺省 updated_at DESC, id DESC)
*/
export function orderPendingOrder2bList(data: PendingOrderListParams = {}): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder2b.list",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
/**
* order.convertToB2b:待处理订单批量转 B2B 订单
* - 仅查当前仓库 current 分表(wms_order_delivery_{warehouseId}),仓库取自登录上下文,禁止前端传入
* - ids / order_ids / orderIds / id / order_id / orderId 均可,服务端转数组、仅保留正整数、去重,单次上限 200
* - 不符合准入条件的订单静默跳过(不报错),原因见 skipped_reasons
*/
export type PendingOrderConvertToB2bParams = {
/** 订单ID集合(单值或数组均可,服务端统一转数组) */
ids?: number[] | number;
order_ids?: number[] | number;
orderIds?: number[] | number;
id?: number;
order_id?: number;
orderId?: number;
};
/** order.convertToB2b 跳过原因项 */
export type PendingOrderConvertToB2bSkippedReason = {
order_id: number;
delivery_order_code?: string;
/** 订单待审核 / 已复核 / 已拣货 / 已锁定 / 已拦截 / 已是B2B订单(已打印不拦截转换) */
reason: string;
};
/** order.convertToB2b 响应 */
export type PendingOrderConvertToB2bResponse = {
converted_order_ids: number[];
converted_count: number;
skipped_order_ids: number[];
skipped_count: number;
skipped_reasons: PendingOrderConvertToB2bSkippedReason[];
/** 当前仓库 current 分表中查不到的订单 ID(已进配送/历史/外仓表,或不属于本仓) */
not_found_order_ids: number[];
};
export function orderPendingOrderConvertToB2b(
data: PendingOrderConvertToB2bParams,
): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.convertToB2b",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
/**
* order.cancelB2b:取消 B2B,把 B2B 订单流转回正常订单(order.convertToB2b 的反向操作)
* - 仅查当前仓库 current 分表(wms_order_delivery_{warehouseId}),仓库取自登录上下文,禁止前端传入
* - 准入:is_b2b=Y、step != 0(非待审核)、未锁定、未拦截;打印状态不限制(已打印同样可取消)
* - 事务内 is_b2b 置回 'N',并按 warehouse_id + order_id 物理删除 wms_order_b2b 作业明细(不保留历史)
* - 入参同 convertToB2b:ids / order_ids / orderIds / id / order_id / orderId 均可,单次上限 200;
* 不符合条件的订单只跳过、不报错,原因见 skipped_reasons
* - ⚠️ 文档归属模块为 order.index(folder order.index),此处与 convertToB2b 成对维护
*/
export type PendingOrderCancelB2bParams = PendingOrderConvertToB2bParams;
/** order.cancelB2b 跳过原因项 */
export type PendingOrderCancelB2bSkippedReason = {
order_id: number;
delivery_order_code?: string;
/** 订单待审核,不允许取消B2B / 订单不是B2B订单 / 订单已锁定,不允许取消B2B / 订单已拦截,不允许取消B2B */
reason: string;
};
/** order.cancelB2b 响应 */
export type PendingOrderCancelB2bResponse = {
/** 取消成功的订单 ID(已去重) */
canceled_order_ids: number[];
canceled_count: number;
/** 命中但不满足取消条件被跳过的订单 ID */
skipped_order_ids: number[];
skipped_count: number;
skipped_reasons: PendingOrderCancelB2bSkippedReason[];
/** 当前仓库 current 分表中查不到的订单 ID(已进配送/历史/外仓表,或不属于本仓) */
not_found_order_ids: number[];
};
export function orderPendingOrderCancelB2b(
data: PendingOrderCancelB2bParams,
): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.cancelB2b",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
/**
* B2B 作业入参(ids / order_ids / orderIds / id / order_id / orderId 均可,单值或数组)
* - 服务端取值优先级:ids > order_ids > orderIds > id > order_id > orderId
* - 加急类接口单次最多 200 个订单;备货/提货为**单订单作业**,传多个订单返回 400
* - warehouse_id 由服务端从登录上下文注入(ctx.user.store_id),前端禁止传入
*/
export type PendingOrderB2bOrderIdParams = {
ids?: number[] | number;
order_ids?: number[] | number;
orderIds?: number[] | number;
id?: number;
order_id?: number;
orderId?: number;
};
/**
* order.startB2bPrep:备货开始(仅 B2B 订单,单订单作业)
* - 操作人取当前登录工号写入 prep_operator_id / prep_operator_name,prep_status 置 padding,prep_start_at 记开始时间
* - 同工号重复调用幂等成功(保留首次开始时间,见 idempotent_order_ids);已被其他工号开始或已备货完成则返回失败
*/
export type PendingOrderStartB2bPrepResponse = {
/** 固定 padding */
prep_status: string;
/** 本次备货人工号 ID */
prep_operator_id: number;
/** 备货人姓名 */
prep_operator_name?: string;
/** 备货开始成功的订单 ID(含幂等命中) */
started_order_ids: number[];
started_count: number;
/** 同工号重复开始、未重置开始时间的订单 ID */
idempotent_order_ids: number[];
};
export function orderPendingOrderStartB2bPrep(
data: PendingOrderB2bOrderIdParams,
): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.startB2bPrep",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
/**
* order.cancelB2bPrep:取消备货(仅 B2B 订单,单订单作业)
* - prep_status 重置 none,并清空 prep_operator_id / prep_operator_name / prep_start_at / prep_at,prep_duration_seconds 置 0
* - 仅 prep_status=padding(备货中)可取消,且必须由记录在案的同一工号操作(备货人与当前工号不一致返回失败)
*/
export type PendingOrderCancelB2bPrepResponse = {
/** 固定 none */
prep_status: string;
canceled_order_ids: number[];
canceled_count: number;
};
export function orderPendingOrderCancelB2bPrep(
data: PendingOrderB2bOrderIdParams,
): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.cancelB2bPrep",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
/**
* order.finishB2bPrep:备货完成(仅 B2B 订单,单订单作业)
* - 必传 prep_remark(≤500 字符)与 total_box_count(≥0 整数)
* - 写入 prep_remark / total_box_count / prep_at(提交时刻)/ prep_duration_seconds,prep_status 置 fin
* - 仅 prep_status=padding 可提交,且必须由同一备货工号提交
* - ⚠️ 完成时**同步扣减库存**(口径同拣货完成:扣 wms_storage 锁定+可用、写 OUTBOUND/PICK_OUTBOUND 流水、wms_picking 置 fin)
*/
export type PendingOrderFinishB2bPrepParams = PendingOrderB2bOrderIdParams & {
/** 备货备注,必填,最长 500 字符 */
prep_remark: string;
prepRemark?: string;
/** 总箱数,必填,大于等于 0 的整数 */
total_box_count: number;
totalBoxCount?: number;
};
/** order.finishB2bPrep 响应 */
export type PendingOrderFinishB2bPrepResponse = {
/** 固定 fin */
prep_status: string;
prep_remark: string;
total_box_count: number;
/** 备货完成时间(提交时刻) */
prep_at: string;
/** 备货用时(秒)= 提交时刻 - 备货开始时间 */
prep_duration_seconds: number;
finished_order_ids: number[];
finished_count: number;
/** 本次扣减的库存记录(wms_storage.id),无扣减时为空数组 */
stock_deducted_storage_ids: number[];
/** 本次扣减的库存总量合计,无扣减时为 0 */
stock_deducted_quantity: number;
};
export function orderPendingOrderFinishB2bPrep(
data: PendingOrderFinishB2bPrepParams,
): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.finishB2bPrep",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
/**
* order.pickupB2b:B2B 提货(仅 B2B 订单,单订单作业)
* - is_picked_up 置 Y、picked_up_at 记提交时刻;要求 is_b2b=Y、未取消、prep_status=fin
* - 已提货重复调用幂等成功并返回首次提货时间(already_picked_up=true)
* - 订单先在 current 分表查,未命中兜底 dispatch 分表
*/
export type PendingOrderPickupB2bResponse = {
/** 固定 Y */
is_picked_up: string;
/** 提货时间(幂等命中时为首次提货时间) */
picked_up_at: string;
/** 提货订单 ID(恒为单元素数组) */
picked_up_order_ids: number[];
/** 固定 1 */
picked_up_count: number;
/** true=已提货幂等命中(未改写提货时间与操作日志) */
already_picked_up: boolean;
};
export function orderPendingOrderPickupB2b(
data: PendingOrderB2bOrderIdParams,
): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pickupB2b",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
/**
* order.setB2bUrgent:批量设置 B2B 订单是否加急(单次最多 200 个)
* - 订单先查 current 分表,未命中兜底 dispatch 分表(覆盖配送域 B2B 订单)
* - 非 B2B 订单(is_b2b != 'Y')与已取消订单(status=cancel)逐条跳过,原因见 skipped_reasons
* - 设置后 order.pendingOrder2b.list / order.deliveryOrder2b.list 的「加急优先」排序立即生效
*/
export type PendingOrderSetB2bUrgentParams = PendingOrderB2bOrderIdParams & {
/**
* 是否加急,缺省 Y(调用即设为加急);支持 Y/N(大小写与首尾空格不敏感)、true/false、1/0、是/否;
* 传 N/false/0 表示取消加急;取值非法返回 400
*/
is_urgent?: string;
isUrgent?: string;
urgent?: string;
};
/** order.setB2bUrgent / cancelB2bUrgent 跳过原因项 */
export type PendingOrderSetB2bUrgentSkipReason = {
order_id: number;
delivery_order_code?: string;
/** 订单不是B2B订单 / 订单已取消,不允许设置加急 */
reason: string;
};
/** order.setB2bUrgent 响应 */
export type PendingOrderSetB2bUrgentResponse = {
/** 本次设置的加急标记(Y/N),与入参归一化结果一致 */
is_urgent: string;
updated_order_ids: number[];
updated_count: number;
skipped_order_ids: number[];
skipped_count: number;
skipped_reasons: PendingOrderSetB2bUrgentSkipReason[];
/** current 与 dispatch 分表都查不到的订单 ID(不属于本仓、已归档/外仓或 ID 不存在) */
not_found_order_ids: number[];
};
export function orderPendingOrderSetB2bUrgent(
data: PendingOrderSetB2bUrgentParams,
): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.setB2bUrgent",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
/**
* order.cancelB2bUrgent:取消 B2B 订单加急(等价 setB2bUrgent 传 is_urgent='N',本接口强制覆盖为 N)
* - 入参只有订单 ID(不需传 is_urgent),单次最多 200 个
*/
export type PendingOrderCancelB2bUrgentResponse = Omit<
PendingOrderSetB2bUrgentResponse,
"is_urgent"
> & {
/** 固定 N */
is_urgent: string;
};
export function orderPendingOrderCancelB2bUrgent(
data: PendingOrderB2bOrderIdParams,
): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.cancelB2bUrgent",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export function orderPendingOrderReverseReviewOrder(
data: PendingOrderReverseReviewParams,
): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.reverseReviewOrder",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export function orderPendingOrderDetail(data: PendingOrderDetailParams): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.detail",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export function orderPendingOrderMarkPendingOutboundOrder(
data: PendingOrderIdsParams,
): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.markPendingOutboundOrder",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export function orderPendingOrderCancelOrder(data: PendingOrderIdsParams): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.cancelOrder",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export function orderPendingOrderAllocateExpressCode(
data: PendingOrderAllocateExpressCodeParams,
): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.allocateExpressCode",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
/** 查询分配快递号任务进度 */
export function orderPendingOrderAllocateExpressCodeTaskProgress(
data: { task_id: string },
): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.allocateExpressCodeTaskProgress",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export function orderPendingOrderAllocateStorage(
data: PendingOrderAllocateStorageParams,
): Promise<PendingOrderAllocateStorageResponse & { code?: number; message?: string; flag?: string; data?: unknown }> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.allocateStorage",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export function orderPendingOrderCancelAllocateStorage(
data: PendingOrderAllocateStorageParams,
): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.cancelAllocateStorage",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export function orderPendingOrderAllocateStorageProgress(
data: PendingOrderAllocateStorageProgressParams,
): Promise<PendingOrderAllocateStorageProgressResponse & { code?: number; message?: string; flag?: string; data?: unknown }> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.allocateStorageProgress",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export function orderPendingOrderSyncOrderIds(
data: PendingOrderSyncOrderIdsParams,
): Promise<PendingOrderSyncOrderIdsResponse & { code?: number; message?: string; flag?: string; data?: PendingOrderSyncOrderIdsResponse['data'] }> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.syncOrderIds",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export function orderPendingOrderSyncOrderIdsProgress(
data: PendingOrderSyncOrderIdsProgressParams,
): Promise<PendingOrderSyncOrderIdsProgressResponse & { code?: number; message?: string; flag?: string }> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.syncOrderIdsProgress",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export function orderPendingOrderUpdateOrderPlatform(
data: PendingOrderUpdateOrderPlatformParams,
): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.updateOrderPlatform",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export function orderPendingOrderUpdateOrderExpress(
data: PendingOrderUpdateOrderExpressParams,
): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.updateOrderExpress",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export function orderPendingOrderUpdateAddress(
data: PendingOrderUpdateAddressParams,
): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.updateAddress",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export function orderPendingOrderCloneOrder(data: PendingOrderCloneOrderParams): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.cloneOrder",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export function orderPendingOrderCreateOrder(data: PendingOrderCreateOrderParams): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.createOrder",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export function orderPendingOrderImportOrdersFromExcel(
data: PendingOrderImportOrdersFromExcelParams,
): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.importOrdersFromExcel",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export function orderPendingOrderParseAddress(
data: PendingOrderParseAddressParams,
): Promise<PendingOrderParseAddressResponse> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.parseAddress",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
// 地址解析可能调用外部服务,超时时间延长至 10 分钟
timeout: 600000,
} as any);
}
/** order.pendingOrder.parseAddressLocal 入参(可选;两者均不传时后端用内置示例地址数据) */
export type PendingOrderParseAddressLocalParams = {
/** 单条地址解析;也支持传字符串数组批量解析(与 addresses 二选一) */
address?: string | string[];
/** 批量地址解析(单次最多 50 条) */
addresses?: string[];
};
/** order.pendingOrder.parseAddressLocal 响应(结构同 parseAddress,额外含 data.source) */
export type PendingOrderParseAddressLocalResponse = PendingOrderParseAddressResponse & {
data?: PendingOrderParseAddressData & {
list?: PendingOrderParseAddressItem[];
/** 未传 address/addresses 时为 sample,表示结果来自内置示例地址数据 */
source?: string;
};
};
/**
* order.pendingOrder.parseAddressLocal:本地地址解析(不调 AI,内置省市区字典遍历识别)。
* 与 parseAddress 解析逻辑等价;区别是可完全无参调用(返回内置示例地址数据的识别结果)。
*/
export function orderPendingOrderParseAddressLocal(
data: PendingOrderParseAddressLocalParams = {},
): Promise<PendingOrderParseAddressLocalResponse> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.parseAddressLocal",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
// 批量解析(最多 50 条)耗时较长,超时时间延长至 10 分钟
timeout: 600000,
} as any);
}
/** order.pendingOrder.batchIntercept:批量提交订单拦截请求 */
export function orderPendingOrderBatchIntercept(data: PendingOrderBatchInterceptParams): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.batchIntercept",
v,
timestamp: Date.now()
},
data,
isSystemApi: true
} as any)
}
/** order.pendingOrder.batchInterceptTaskProgress:查询批量拦截任务进度 */
export function orderPendingOrderBatchInterceptTaskProgress(data: PendingOrderBatchInterceptProgressParams): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.batchInterceptTaskProgress",
v,
timestamp: Date.now()
},
data,
isSystemApi: true
} as any)
}
/** order.pendingOrder.batchUnintercept:批量解除拦截 */
export function orderPendingOrderBatchUnintercept(data: PendingOrderBatchInterceptParams): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.batchUnintercept",
v,
timestamp: Date.now()
},
data,
isSystemApi: true
} as any)
}
/** order.pendingOrder.batchUninterceptTaskProgress:查询批量解除拦截进度 */
export function orderPendingOrderBatchUninterceptTaskProgress(data: PendingOrderBatchInterceptProgressParams): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.batchUninterceptTaskProgress",
v,
timestamp: Date.now()
},
data,
isSystemApi: true
} as any)
}
/** order.pendingOrder.batchLock:批量锁定 */
export function orderPendingOrderBatchLock(data: PendingOrderBatchInterceptParams): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.batchLock",
v,
timestamp: Date.now()
},
data,
isSystemApi: true
} as any)
}
/** order.pendingOrder.batchLockTaskProgress:查询批量锁定进度 */
export function orderPendingOrderBatchLockTaskProgress(data: PendingOrderBatchInterceptProgressParams): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.batchLockTaskProgress",
v,
timestamp: Date.now()
},
data,
isSystemApi: true
} as any)
}
/** order.pendingOrder.batchUnlock:批量解锁 */
export function orderPendingOrderBatchUnlock(data: PendingOrderBatchInterceptParams): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.batchUnlock",
v,
timestamp: Date.now()
},
data,
isSystemApi: true
} as any)
}
/** order.pendingOrder.batchUnlockTaskProgress:查询批量解锁进度 */
export function orderPendingOrderBatchUnlockTaskProgress(data: PendingOrderBatchInterceptProgressParams): Promise<any> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.batchUnlockTaskProgress",
v,
timestamp: Date.now()
},
data,
isSystemApi: true
} as any)
}
export type PendingOrderUpdateRemarkParams = {
ids: number[]
remark: string
}
export type PendingOrderUpdateRemarkResponse = {
code?: number
message?: string
updated_count?: number
ids?: number[]
data?: {
updated_count?: number
ids?: number[]
}
}
/** order.pendingOrder.updateRemark:批量修改待处理订单备注 */
export function orderPendingOrderUpdateRemark(
data: PendingOrderUpdateRemarkParams,
): Promise<PendingOrderUpdateRemarkResponse> {
return request({
url: "/system",
method: "post",
params: {
method: "order.pendingOrder.updateRemark",
v,
timestamp: Date.now(),
},
data,
isSystemApi: true,
} as any);
}
export type OrderPendingOrderApi = {
list: typeof orderPendingOrderList;
convertToB2b: typeof orderPendingOrderConvertToB2b;
cancelB2b: typeof orderPendingOrderCancelB2b;
setB2bUrgent: typeof orderPendingOrderSetB2bUrgent;
cancelB2bUrgent: typeof orderPendingOrderCancelB2bUrgent;
startB2bPrep: typeof orderPendingOrderStartB2bPrep;
cancelB2bPrep: typeof orderPendingOrderCancelB2bPrep;
finishB2bPrep: typeof orderPendingOrderFinishB2bPrep;
pickupB2b: typeof orderPendingOrderPickupB2b;
detail: typeof orderPendingOrderDetail;
reverseReviewOrder: typeof orderPendingOrderReverseReviewOrder;
markPendingOutboundOrder: typeof orderPendingOrderMarkPendingOutboundOrder;
cancelOrder: typeof orderPendingOrderCancelOrder;
allocateExpressCode: typeof orderPendingOrderAllocateExpressCode;
allocateExpressCodeTaskProgress: typeof orderPendingOrderAllocateExpressCodeTaskProgress;
allocateStorage: typeof orderPendingOrderAllocateStorage;
allocateStorageProgress: typeof orderPendingOrderAllocateStorageProgress;
cancelAllocateStorage: typeof orderPendingOrderCancelAllocateStorage;
syncOrderIds: typeof orderPendingOrderSyncOrderIds;
syncOrderIdsProgress: typeof orderPendingOrderSyncOrderIdsProgress;
updateOrderPlatform: typeof orderPendingOrderUpdateOrderPlatform;
updateOrderExpress: typeof orderPendingOrderUpdateOrderExpress;
updateAddress: typeof orderPendingOrderUpdateAddress;
updateRemark: typeof orderPendingOrderUpdateRemark;
cloneOrder: typeof orderPendingOrderCloneOrder;
manualWaybill: typeof orderPendingOrderManualWaybill;
createOrder: typeof orderPendingOrderCreateOrder;
importOrdersFromExcel: typeof orderPendingOrderImportOrdersFromExcel;
downloadCreateTemplate: typeof orderPendingOrderDownloadCreateTemplate;
parseAddress: typeof orderPendingOrderParseAddress;
parseAddressLocal: typeof orderPendingOrderParseAddressLocal;
batchIntercept: typeof orderPendingOrderBatchIntercept;
batchInterceptTaskProgress: typeof orderPendingOrderBatchInterceptTaskProgress;
batchUnintercept: typeof orderPendingOrderBatchUnintercept;
batchUninterceptTaskProgress: typeof orderPendingOrderBatchUninterceptTaskProgress;
batchLock: typeof orderPendingOrderBatchLock;
batchLockTaskProgress: typeof orderPendingOrderBatchLockTaskProgress;
batchUnlock: typeof orderPendingOrderBatchUnlock;
batchUnlockTaskProgress: typeof orderPendingOrderBatchUnlockTaskProgress;
allocateSubOrderNumber: typeof orderPendingOrderAllocateSubOrderNumber;
allocateSubOrderNumberProgress: typeof orderPendingOrderAllocateSubOrderNumberProgress;
};
export const orderPendingOrder: OrderPendingOrderApi = {
list: orderPendingOrderList,
convertToB2b: orderPendingOrderConvertToB2b,
cancelB2b: orderPendingOrderCancelB2b,
setB2bUrgent: orderPendingOrderSetB2bUrgent,
cancelB2bUrgent: orderPendingOrderCancelB2bUrgent,
startB2bPrep: orderPendingOrderStartB2bPrep,
cancelB2bPrep: orderPendingOrderCancelB2bPrep,
finishB2bPrep: orderPendingOrderFinishB2bPrep,
pickupB2b: orderPendingOrderPickupB2b,
detail: orderPendingOrderDetail,
reverseReviewOrder: orderPendingOrderReverseReviewOrder,
markPendingOutboundOrder: orderPendingOrderMarkPendingOutboundOrder,
cancelOrder: orderPendingOrderCancelOrder,
allocateExpressCode: orderPendingOrderAllocateExpressCode,
allocateExpressCodeTaskProgress: orderPendingOrderAllocateExpressCodeTaskProgress,
allocateStorage: orderPendingOrderAllocateStorage,
allocateStorageProgress: orderPendingOrderAllocateStorageProgress,
cancelAllocateStorage: orderPendingOrderCancelAllocateStorage,
syncOrderIds: orderPendingOrderSyncOrderIds,
syncOrderIdsProgress: orderPendingOrderSyncOrderIdsProgress,
updateOrderPlatform: orderPendingOrderUpdateOrderPlatform,
updateOrderExpress: orderPendingOrderUpdateOrderExpress,
updateAddress: orderPendingOrderUpdateAddress,
updateRemark: orderPendingOrderUpdateRemark,
cloneOrder: orderPendingOrderCloneOrder,
manualWaybill: orderPendingOrderManualWaybill,
createOrder: orderPendingOrderCreateOrder,
importOrdersFromExcel: orderPendingOrderImportOrdersFromExcel,
downloadCreateTemplate: orderPendingOrderDownloadCreateTemplate,
parseAddress: orderPendingOrderParseAddress,
parseAddressLocal: orderPendingOrderParseAddressLocal,
batchIntercept: orderPendingOrderBatchIntercept,
batchInterceptTaskProgress: orderPendingOrderBatchInterceptTaskProgress,
batchUnintercept: orderPendingOrderBatchUnintercept,
batchUninterceptTaskProgress: orderPendingOrderBatchUninterceptTaskProgress,
batchLock: orderPendingOrderBatchLock,
batchLockTaskProgress: orderPendingOrderBatchLockTaskProgress,
batchUnlock: orderPendingOrderBatchUnlock,
batchUnlockTaskProgress: orderPendingOrderBatchUnlockTaskProgress,
allocateSubOrderNumber: orderPendingOrderAllocateSubOrderNumber,
allocateSubOrderNumberProgress: orderPendingOrderAllocateSubOrderNumberProgress,
};
export const orderPendingOrder2b = {
list: orderPendingOrder2bList,
setB2bUrgent: orderPendingOrderSetB2bUrgent,
cancelB2bUrgent: orderPendingOrderCancelB2bUrgent,
startB2bPrep: orderPendingOrderStartB2bPrep,
cancelB2bPrep: orderPendingOrderCancelB2bPrep,
finishB2bPrep: orderPendingOrderFinishB2bPrep,
pickupB2b: orderPendingOrderPickupB2b,
};