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 接口
This commit is contained in:
yin 2026-11-18 18:05:41 +08:00
parent 4eb0282a6a
commit 1a51150d2c
23 changed files with 1834 additions and 315 deletions

View File

@ -236,6 +236,20 @@ export function orderDeliveryOrderList(data: DeliveryOrderListParams = {}): Prom
} as any)
}
/**
* order.deliveryOrder2b.list:B2B 配送订单列表
* - 查询条件与 order.deliveryOrder.list 完全一致(dispatch 分表 + 默认 dispatch_lane=m4)
* - 额外强制 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 只决定加急/非加急各自内部次序
* (缺省 delivery_time DESC, id DESC)
*/
export function orderDeliveryOrder2bList(data: DeliveryOrderListParams = {}): Promise<any> {
return request({
url: '/system',

View File

@ -345,6 +345,20 @@ export function orderPendingOrderList(data: PendingOrderListParams = {}): Promis
} 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",
@ -458,6 +472,250 @@ export function orderPendingOrderCancelB2b(
} 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> {
@ -937,6 +1195,12 @@ 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;
@ -975,6 +1239,12 @@ 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,
@ -1011,4 +1281,10 @@ export const orderPendingOrder: OrderPendingOrderApi = {
export const orderPendingOrder2b = {
list: orderPendingOrder2bList,
setB2bUrgent: orderPendingOrderSetB2bUrgent,
cancelB2bUrgent: orderPendingOrderCancelB2bUrgent,
startB2bPrep: orderPendingOrderStartB2bPrep,
cancelB2bPrep: orderPendingOrderCancelB2bPrep,
finishB2bPrep: orderPendingOrderFinishB2bPrep,
pickupB2b: orderPendingOrderPickupB2b,
};

View File

@ -171,7 +171,7 @@ export type SettingWarehouseSubjectConfig = SettingWarehouseSenderConfig & {
big_group_pack_coefficient?: number
/**
* 散单称重是否需要打包(flag,默认 false 关闭):开启后散单称重(订单波次范围 wave_scope 非 1 大团购/3 小团购)
* 前必须已打包完成(pack_status=fin),未打包时拒绝称重并返回错误。
* 须处于**打包中或已打包**(pack_status=padding/fin),未打包或打包异常时拒绝称重并返回错误。
* 仅接受布尔/like-flag(true/1/'1'/'true' → true;false/0/'0'/'false' → false),非法值报 400
*/
single_weigh_require_pack?: boolean

View File

@ -1,25 +1,6 @@
import request from '@/utils/request'
const v = "1.0";
/** 查询当前主体可见的货主列表 */
export function storeList(data: {
keyword?: string
page?: number
page_size?: number
}) {
return request({
url: '/system',
method: 'post',
params: {
method: 'storeWarehouse.store.list',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
/** 货主侧查询签约关系列表 */
export function storeWarehouseList(data: {
keyword?: string
@ -407,32 +388,6 @@ export function saveApiConfig(data: {
} as any)
}
/** 按 store_id 分页查询面单余额变更日志 */
export function queryPrintQuantityLogs(data: {
store_id: number | string
pagination?: { page?: number; page_size?: number }
}) {
const sid = Number(data.store_id)
if (!Number.isFinite(sid)) {
return Promise.reject(new Error('storeWarehouse.store.queryPrintQuantityLogs:store_id 无效'))
}
const body: Record<string, unknown> = { store_id: sid }
if (data.pagination && typeof data.pagination === 'object') {
body.pagination = data.pagination
}
return request({
url: '/system',
method: 'post',
params: {
method: 'storeWarehouse.store.queryPrintQuantityLogs',
v,
timestamp: new Date().getTime()
},
data: body,
isSystemApi: true
} as any)
}
/** 删除签约关系上的奇门接口配置 */
export function storeWarehouseDeleteQimenConfig(data: {
id: number

56
src/utils/chinaStreet.ts Normal file
View File

@ -0,0 +1,56 @@
/**
* 中国省/市/区/街道(镇) 四级行政区划数据
*
* - 数据来源:`china-division` 的 `pcas-code.json`(约 1.9MB)
* - 只在需要「镇/街道」下拉时才动态 import,不会打进主包
* - 街道 code 与 `pca-code.json` 的区县 code 一致,可直接用 `area_code` 反查
* - 选项 value 取街道**名称**(建单接口 `town` 字段传名称字符串)
*/
export type StreetSelectOption = { label: string; value: string }
type StreetRegionNode = { code?: string; name?: string; children?: StreetRegionNode[] }
const streetOptionsByAreaCode = new Map<string, StreetSelectOption[]>()
let loadPromise: Promise<void> | null = null
/** 是否已加载完成(用于驱动视图刷新) */
export function isStreetIndexLoaded() {
return streetOptionsByAreaCode.size > 0
}
/** 同步读取已缓存的街道选项;未加载或该区县无数据时返回空数组 */
export function getStreetOptionsByAreaCode(areaCode?: string | null): StreetSelectOption[] {
const code = String(areaCode || '').trim()
if (!code) return []
return streetOptionsByAreaCode.get(code) || []
}
/** 加载街道数据(幂等,多次调用共用同一个 Promise;失败时降级为空选项) */
export function loadStreetIndex(): Promise<void> {
if (loadPromise) return loadPromise
loadPromise = import('china-division/dist/pcas-code.json')
.then((mod) => {
const raw = mod as unknown as StreetRegionNode[] | { default?: StreetRegionNode[] }
const tree = Array.isArray(raw) ? raw : raw.default
if (!Array.isArray(tree)) return
for (const province of tree) {
for (const city of province?.children || []) {
for (const area of city?.children || []) {
const areaCode = String(area?.code || '').trim()
if (!areaCode) continue
const streets = (area?.children || [])
.map((street) => String(street?.name || '').trim())
.filter(Boolean)
.map((name) => ({ label: name, value: name }))
if (streets.length) streetOptionsByAreaCode.set(areaCode, streets)
}
}
}
})
.catch((error) => {
console.warn('[chinaStreet] 街道数据加载失败,改为手工输入', error)
// 失败后清掉缓存,下次打开下拉时可重试
loadPromise = null
})
return loadPromise
}

View File

@ -76,6 +76,7 @@
:query-time="queryTime"
@page-change="handlePageChange"
@page-size-change="handlePageSizeChange"
@sort-change="handleSortChange"
@refresh="handleRefresh"
>
<template #column-is_notified="{ row }">
@ -152,8 +153,14 @@ const props = defineProps<{
}>()
const tableSize = 'small'
/** 复用退回收件登记列配置,去掉操作列(本页只读展示当前任务登记) */
const columns = computed(() => (returnReceivedColumns as any[]).filter((c) => c.prop !== 'actions'))
/** returnReceived.list 的 sortField 白名单:id / scan_date / created_at / updated_at / waybill_code */
const SORTABLE_PROPS = new Set(['id', 'scan_date', 'created_at', 'updated_at', 'waybill_code'])
/** 复用退回收件登记列配置,去掉操作列(本页只读展示当前任务登记),并开启白名单列的排序 */
const columns = computed(() =>
(returnReceivedColumns as any[])
.filter((c) => c.prop !== 'actions')
.map((c) => (SORTABLE_PROPS.has(String(c.prop)) ? { ...c, sortable: true } : c))
)
const upperTable = ref<any>(null)
const waybillInputRef = ref<any>(null)
@ -165,6 +172,8 @@ const listLoading = ref(false)
const queryTime = ref(0)
const list = ref<any[]>([])
const pagination = reactive({ currentPage: 1, pageSize: 20, total: 0 })
/** 当前排序(未排序时不传,走后端默认 created_at desc) */
const currentSort = ref<{ prop: string; order: string }>({ prop: '', order: '' })
// ==================== 工具栏(对齐「退回收件任务」页) ====================
@ -225,10 +234,17 @@ async function loadList() {
listLoading.value = true
const start = Date.now()
try {
const res: any = await returnReceivedList({
const params: Record<string, any> = {
pagination: { page: pagination.currentPage, pageSize: pagination.pageSize },
where: { return_received_task_id: taskId },
})
}
if (currentSort.value.prop) {
params.sort = {
sortField: currentSort.value.prop,
sortOrder: currentSort.value.order === 'ascending' ? 'asc' : 'desc',
}
}
const res: any = await returnReceivedList(params)
if (res && (res.code === 1 || res.code === 200 || res.code === 20000)) {
const data = res.data ?? res
list.value = data.list ?? data.items ?? []
@ -263,6 +279,12 @@ function handlePageSizeChange(size: number) {
loadList()
}
function handleSortChange({ prop, order }: any) {
currentSort.value = { prop: order ? String(prop ?? '') : '', order: order || '' }
pagination.currentPage = 1
loadList()
}
// ==================== 扫码登记 ====================
/** 只清空运单号;备注常驻,未切换前一直沿用同一备注 */
@ -293,12 +315,15 @@ async function handleRegister() {
if (res && (res.code === 1 || res.code === 200 || res.code === 20000)) {
const data = res.data ?? res
const urgentTip = data.is_urgent ? '(加急件)' : ''
// store_remark:货主合约备注(命中原单退回时才有值),对仓库识别特殊货主很有用
const storeRemark = String(data?.store_remark ?? '').trim()
const storeRemarkTip = storeRemark ? `;货主备注:${storeRemark}` : ''
if (data.duplicated) {
ElMessage.warning(`该运单号 30 日内已登记(记录ID ${data.record?.id ?? data.id}),已返回第一次登记结果${urgentTip}`)
ElMessage.warning(`该运单号 30 日内已登记(记录ID ${data.record?.id ?? data.id}),已返回第一次登记结果${urgentTip}${storeRemarkTip}`)
} else if (data.is_original_return) {
ElMessage.success(`登记成功:命中原单退回,原运单ID ${data.record?.order_express_id ?? data.order_express_id}${urgentTip}`)
ElMessage.success(`登记成功:命中原单退回,原运单ID ${data.record?.order_express_id ?? data.order_express_id}${urgentTip}${storeRemarkTip}`)
} else {
ElMessage.success(`登记成功${urgentTip}`)
ElMessage.success(`登记成功${urgentTip}${storeRemarkTip}`)
}
clearWaybill()
pagination.currentPage = 1

View File

@ -449,20 +449,8 @@ async function handleBatchDelete() {
return
}
// 前置校验:系统预设任务、已有登记的任务不可删除
const presetRows = rows.filter((r) => Number(r?.id) === 1)
const usedRows = rows.filter((r) => Number(r?.id) !== 1 && Number(r?.register_count) > 0)
if (presetRows.length || usedRows.length) {
const tips: string[] = []
if (presetRows.length) tips.push('系统预设任务「历史收件」不可删除')
if (usedRows.length) {
const names = usedRows.map((r) => r.title || r.batch_no || r.id).join('、')
tips.push(`以下任务已有登记不可删除:${names}`)
}
ElMessage.warning(tips.join(';'))
return
}
// 注意:文档明确 batchDelete 是「逐条分流」——系统预设 / 已有登记 / 非本仓库的会进 skipped_ids,
// 其余照常删除且不整体报错。因此这里不再按单条规则整批拦截,交给后端判定,前端只负责展示结果。
const ids = rows
.map((r) => Number(r?.id))
.filter((id) => Number.isInteger(id) && id > 0)
@ -495,15 +483,30 @@ async function handleBatchDelete() {
if (res && (res.code === 1 || res.code === 200 || res.code === 20000)) {
const data = res.data ?? res
const deleted = Number(data?.deleted_count ?? data?.deleted_ids?.length)
const skipped = Number(data?.skipped_count ?? data?.skipped_ids?.length)
const skippedIds: number[] = Array.isArray(data?.skipped_ids)
? data.skipped_ids.map((v: any) => Number(v)).filter((v: number) => Number.isFinite(v))
: []
const skipped = Number(data?.skipped_count ?? skippedIds.length)
// 用当前页数据把 skipped_ids 翻译成任务名,便于用户定位是哪些没删掉
const nameOfSkipped = (id: number) => {
const row = tableData.value.find((r) => Number(r?.id) === id)
return String(row?.title || row?.batch_no || `#${id}`)
}
const skippedLabel = (() => {
if (!skippedIds.length) return ''
const head = skippedIds.slice(0, 5).map(nameOfSkipped).join('、')
return skippedIds.length > 5 ? `${head} 等 ${skippedIds.length} 个` : head
})()
if (Number.isFinite(deleted) && deleted > 0) {
ElMessage.success(
Number.isFinite(skipped) && skipped > 0
? `已删除 ${deleted} 个任务,跳过 ${skipped} 个(系统预设 / 已有登记 / 非本仓库)`
? `已删除 ${deleted} 个任务;跳过 ${skipped} 个(系统预设 / 已有登记 / 非本仓库)${skippedLabel ? `:${skippedLabel}` : ''}`
: `已删除 ${deleted} 个任务`
)
} else if (Number.isFinite(skipped) && skipped > 0) {
ElMessage.warning(`${skipped} 个任务未删除(系统预设 / 已有登记 / 非本仓库)`)
ElMessage.warning(
`所选任务均未删除(系统预设 / 已有登记 / 非本仓库)${skippedLabel ? `:${skippedLabel}` : ''}`
)
} else {
ElMessage.success('批量删除完成')
}

View File

@ -574,6 +574,66 @@ export const ORDER_TOOLBAR_BUTTONS: Record<string, ToolbarButtonConfig> = {
disabledKey: 'hasNoSelection',
action: 'openCancelB2bDialog'
},
/** B2B 备货开始(order.startB2bPrep):单订单作业,必须恰好勾选 1 行 */
b2bStartPrep: {
key: 'b2bStartPrep',
label: '开始备货',
size: 'small',
category: 'action',
loadingKey: 'b2bActionLoading',
disabledKey: 'notSingleSelection',
action: 'handleB2bStartPrep'
},
/** B2B 备货完成(order.finishB2bPrep):必填备货备注 + 总箱数,完成时同步扣减库存 */
b2bFinishPrep: {
key: 'b2bFinishPrep',
label: '备货完成',
size: 'small',
category: 'action',
loadingKey: 'b2bActionLoading',
disabledKey: 'notSingleSelection',
action: 'openB2bFinishPrepDialog'
},
/** B2B 取消备货(order.cancelB2bPrep):仅备货中订单可取消,且需同一备货工号 */
b2bCancelPrep: {
key: 'b2bCancelPrep',
label: '取消备货',
size: 'small',
category: 'cancel',
loadingKey: 'b2bActionLoading',
disabledKey: 'notSingleSelection',
action: 'handleB2bCancelPrep'
},
/** B2B 提货(order.pickupB2b):单订单作业,要求备货已完成 */
b2bPickup: {
key: 'b2bPickup',
label: '确认提货',
size: 'small',
category: 'action',
loadingKey: 'b2bActionLoading',
disabledKey: 'notSingleSelection',
action: 'handleB2bPickup'
},
/** B2B 批量设为加急(order.setB2bUrgent):单次最多 200 个 */
b2bSetUrgent: {
key: 'b2bSetUrgent',
label: '设为加急',
size: 'small',
category: 'action',
loadingKey: 'b2bActionLoading',
disabledKey: 'hasNoSelection',
action: 'handleB2bSetUrgent'
},
/** B2B 批量取消加急(order.cancelB2bUrgent):服务端强制 is_urgent='N' */
b2bCancelUrgent: {
key: 'b2bCancelUrgent',
label: '取消加急',
size: 'small',
category: 'cancel',
loadingKey: 'b2bActionLoading',
disabledKey: 'hasNoSelection',
action: 'handleB2bCancelUrgent'
},
batchLock: { key: 'batchLock', label: '批量锁定', size: 'small', category: 'action', loadingKey: 'batchAsyncTaskLoading', disabledKey: 'hasNoSelection', action: 'handleBatchLock' },
batchUnlock: { key: 'batchUnlock', label: '批量解锁', size: 'small', category: 'action', loadingKey: 'batchAsyncTaskLoading', disabledKey: 'hasNoSelection', action: 'handleBatchUnlock' },
batchPrint: { key: 'batchPrint', label: '批量打印', size: 'small', category: 'action', loadingKey: 'batchPrintLoading', disabledKey: 'hasNoSelection', action: 'handleBatchPrint' },
@ -1728,6 +1788,77 @@ const SCAN_GOODS_STATS_GROUP = '商品统计'
const SCAN_PROCESS_STATUS_GROUP = '流程状态'
const SCAN_RECEIVING_INFO_GROUP = '收货信息'
const SCAN_TIME_GROUP = '时间'
const SCAN_B2B_GROUP = 'B2B作业'
/* ===== B2B 作业筛选(仅 order.pendingOrder2b.list / order.deliveryOrder2b.list 支持,普通列表不识别) ===== */
const b2bYesNoFilterOptions = [
{ label: '是', value: 'Y' },
{ label: '否', value: 'N' }
]
/** ScanBox:是否加急(wms_order_b2b.is_urgent,Y=加急 N=普通) */
export const b2bUrgentScanField = scanBasicField({ label: '是否加急', value: 'is_urgent', type: 'select', options: b2bYesNoFilterOptions })
/** ScanBox:备货状态(none=未开始 padding=备货中 fin=已完成) */
export const b2bPrepStatusScanField = scanBasicField({
label: '备货状态',
value: 'prep_status',
type: 'select',
options: [
{ label: '未开始', value: 'none' },
{ label: '备货中', value: 'padding' },
{ label: '已完成', value: 'fin' }
]
})
/** ScanBox:备货人工号(wms_order_b2b.prep_operator_id) */
export const b2bPrepOperatorScanField = scanBasicField({
label: '备货人工号',
value: 'prep_operator_id',
type: 'number',
operators: ORDER_NUMBER_SCAN_OPERATORS,
defaultOperator: 'eq'
})
/** ScanBox:备货开始时间(wms_order_b2b.prep_start_at) */
export const b2bPrepStartAtRangeScanField = scanBasicField({ label: '备货开始时间', value: 'prep_start_at', type: 'datetimerange' })
/** ScanBox:备货完成时间(wms_order_b2b.prep_at) */
export const b2bPrepAtRangeScanField = scanBasicField({ label: '备货完成时间', value: 'prep_at', type: 'datetimerange' })
/** ScanBox:提货车牌(wms_order_b2b.pickup_plate_number,模糊匹配) */
export const b2bPickupPlateScanField = scanBasicField({ label: '提货车牌', value: 'pickup_plate_number', type: 'text', defaultOperator: 'like' })
/** ScanBox:备货备注(wms_order_b2b.prep_remark,模糊匹配) */
export const b2bPrepRemarkScanField = scanBasicField({ label: '备货备注', value: 'prep_remark', type: 'text', defaultOperator: 'like' })
/** ScanBox:是否提货(wms_order_b2b.is_picked_up,Y/N) */
export const b2bPickedUpScanField = scanBasicField({ label: '是否提货', value: 'is_picked_up', type: 'select', options: b2bYesNoFilterOptions })
/** ScanBox:提货时间(wms_order_b2b.picked_up_at) */
export const b2bPickedUpAtRangeScanField = scanBasicField({ label: '提货时间', value: 'picked_up_at', type: 'datetimerange' })
/** ScanBox:总箱数(wms_order_b2b.total_box_count) */
export const b2bTotalBoxCountScanField = scanBasicField({
label: '总箱数',
value: 'total_box_count',
type: 'number',
operators: ORDER_NUMBER_SCAN_OPERATORS,
defaultOperator: 'eq'
})
/** ScanBox:备货用时(秒,wms_order_b2b.prep_duration_seconds) */
export const b2bPrepDurationScanField = scanBasicField({
label: '备货用时(秒)',
value: 'prep_duration_seconds',
type: 'number',
operators: ORDER_NUMBER_SCAN_OPERATORS,
defaultOperator: 'ge'
})
/** B2B 页签共用的作业筛选项(追加到普通筛选项之后) */
const b2bExtraScanFields = [
{ ...b2bUrgentScanField, group: SCAN_B2B_GROUP },
{ ...b2bPrepStatusScanField, group: SCAN_B2B_GROUP },
{ ...b2bPrepOperatorScanField, group: SCAN_B2B_GROUP },
{ ...b2bPrepStartAtRangeScanField, group: SCAN_B2B_GROUP },
{ ...b2bPrepAtRangeScanField, group: SCAN_B2B_GROUP },
{ ...b2bPickedUpScanField, group: SCAN_B2B_GROUP },
{ ...b2bPickedUpAtRangeScanField, group: SCAN_B2B_GROUP },
{ ...b2bPickupPlateScanField, group: SCAN_B2B_GROUP },
{ ...b2bPrepRemarkScanField, group: SCAN_B2B_GROUP },
{ ...b2bTotalBoxCountScanField, group: SCAN_B2B_GROUP },
{ ...b2bPrepDurationScanField, group: SCAN_B2B_GROUP }
]
// deliveryOrder相关配置
export const deliveryAvailableFields = [
@ -1784,6 +1915,11 @@ export const deliveryAvailableFields = [
{ ...deliveryTimeRangeScanField, group: SCAN_TIME_GROUP },
]
/** 配送 B2B 订单筛选(order.deliveryOrder2b.list:普通筛选项 + B2B 作业筛选项) */
export const deliveryB2bAvailableFields = [
...deliveryAvailableFields,
...b2bExtraScanFields
]
/** upper-table 列点击复制:`copy` 仅复制;`copyQr` 复制并弹出快递单号二维码 */
export type UpperTableCopyAction = 'copy' | 'copyQr'
@ -2182,6 +2318,12 @@ export const pendingAvailableFields = [
{ ...recheckTimeRangeScanField, group: SCAN_TIME_GROUP },
]
/** 待处理 B2B 订单筛选(order.pendingOrder2b.list:普通筛选项 + B2B 作业筛选项) */
export const pendingB2bAvailableFields = [
...pendingAvailableFields,
...b2bExtraScanFields
]
export const pendingCloums = [
{ prop: 'id', label: '订单ID', width: '80', sortable: 'custom' },
orderWaveIndexColumn,
@ -2313,7 +2455,42 @@ export function buildPendingB2bColumns() {
{ prop: 'operator_name', label: '操作人', width: '100' },
{ prop: 'delivery_time', label: '配送时间', width: '165', formatter: orderTimeFormatter },
{ prop: 'operate_time', label: '操作时间', width: '165', formatter: orderTimeFormatter },
// B2B 专属字段
// B2B 专属字段(order.pendingOrder2b.list 额外带出的 wms_order_b2b 作业字段)
{ prop: 'is_urgent', label: '是否加急', width: '90', formatter: (row: any) => (String(row?.is_urgent ?? '').trim().toUpperCase() === 'Y' ? '加急' : '普通') },
{ prop: 'prep_status', label: '备货状态', width: '100', formatter: (row: any) => translateB2bPrepStatus(row?.prep_status) },
{ prop: 'prep_operator_name', label: '备货人', width: '100' },
{ prop: 'prep_start_at', label: '备货开始时间', width: '165', formatter: orderTimeFormatter },
{ prop: 'total_box_count', label: '总箱数', width: '90' },
{ prop: 'pickup_plate_number', label: '提货车牌', width: '120', showOverflowTooltip: true },
{ prop: 'prep_remark', label: '备货备注', minWidth: '180', showOverflowTooltip: true },
{ prop: 'prep_duration_seconds', label: '备货时长(秒)', width: '110' },
{ prop: 'prep_at', label: '备货时间', width: '165', formatter: orderTimeFormatter },
{ prop: 'is_picked_up', label: '是否提货', width: '90', formatter: (row: any) => (String(row?.is_picked_up ?? '').trim().toUpperCase() === 'Y' ? '是' : '否') },
{ prop: 'picked_up_at', label: '提货时间', width: '165', formatter: orderTimeFormatter },
]
return applyOrderListCopyActions([...base, ...extras])
}
/** B2B 备货状态文案(none=未开始 / padding=备货中 / fin=已完成) */
export function translateB2bPrepStatus(value: unknown): string {
const status = String(value ?? '').trim().toLowerCase()
if (status === 'padding') return '备货中'
if (status === 'fin') return '已完成'
return '未开始'
}
/**
* 配送 B2B 订单专属列(仅「配送B2B订单」页签使用)。
* order.deliveryOrder2b.list 在配送订单列基础上额外带出 wms_order_b2b 作业字段。
*/
export function buildDeliveryB2bColumns() {
// deliveryColumns 已应用过复制动作,这里只做浅拷贝后追加 B2B 作业列
const base = [...deliveryColumns]
const extras: Array<{ prop: string; label: string; [key: string]: any }> = [
{ prop: 'is_urgent', label: '是否加急', width: '90', formatter: (row: any) => (String(row?.is_urgent ?? '').trim().toUpperCase() === 'Y' ? '加急' : '普通') },
{ prop: 'prep_status', label: '备货状态', width: '100', formatter: (row: any) => translateB2bPrepStatus(row?.prep_status) },
{ prop: 'prep_operator_name', label: '备货人', width: '100' },
{ prop: 'prep_start_at', label: '备货开始时间', width: '165', formatter: orderTimeFormatter },
{ prop: 'total_box_count', label: '总箱数', width: '90' },
{ prop: 'pickup_plate_number', label: '提货车牌', width: '120', showOverflowTooltip: true },
{ prop: 'prep_remark', label: '备货备注', minWidth: '180', showOverflowTooltip: true },
@ -2469,6 +2646,35 @@ export const pendingToolbarButtonKeys = [
/** 页面级按钮列表:pendingOrder 直接消费,避免页面内重复拼装 */
export const pendingToolbarButtons = pickToolbarButtons(pendingToolbarButtonKeys)
/**
* B2B 作业按钮(order.startB2bPrep / finishB2bPrep / cancelB2bPrep / pickupB2b / setB2bUrgent / cancelB2bUrgent)
* 仅追加到「待处理B2B订单」「配送B2B订单」两个页签,普通订单页不展示。
*/
export const b2bToolbarButtonKeys = [
'b2bStartPrep',
'b2bFinishPrep',
'b2bCancelPrep',
'b2bPickup',
'b2bSetUrgent',
'b2bCancelUrgent'
]
export const b2bToolbarButtons = pickToolbarButtons(b2bToolbarButtonKeys)
/** 把 B2B 作业按钮插到「取消B2B」之后(找不到锚点则追加到末尾) */
export function buildB2bToolbarButtons(
base: ReadonlyArray<ToolbarButtonConfig>
): ToolbarButtonConfig[] {
const list = [...base]
const anchorIndex = list.findIndex((button) => button.key === 'cancelB2b')
if (anchorIndex >= 0) {
list.splice(anchorIndex + 1, 0, ...b2bToolbarButtons)
} else {
list.push(...b2bToolbarButtons)
}
return list
}
/**

View File

@ -2,7 +2,7 @@
<div class="order-sub-container">
<scan-box
ref="scanBox"
cache-key="orderManagement:deliveryOrder"
:cache-key="b2b ? 'orderManagement:deliveryOrder2b' : 'orderManagement:deliveryOrder'"
width="220px"
:tree-props="{ children: 'children', label: 'label' }"
:auto-submit="false"
@ -333,6 +333,15 @@
@success="handleTransferByOrdersSuccess"
/>
<!-- B2B 备货完成(order.finishB2bPrep):仅「配送B2B订单」页签可用 -->
<b2b-prep-finish-form
v-if="b2b && finishPrepDialogVisible"
v-model:visible="finishPrepDialogVisible"
:loading="b2bActionLoading"
:row="finishPrepRow"
@submit="submitFinishPrep"
/>
<order-export-columns-dialog
v-if="exportColumnsDialogVisible"
v-model:visible="exportColumnsDialogVisible"
@ -369,7 +378,10 @@ import { orderPendingOrder } from '@/api/order.pendingorder/orderpendingOrder'
import {
deliveryAvailableFields,
deliveryB2bAvailableFields,
deliveryColumns,
buildDeliveryB2bColumns,
buildB2bToolbarButtons,
deliveryOrderToolbarButtons,
type ToolbarButtonConfig,
translateOrderField,
@ -395,6 +407,7 @@ import { buildOrderWhereConditions, parseOrderListResponse, resolveOrderRecheckS
import { useOrderListPageCleanup } from './utils/use-order-list-page-cleanup'
import { useOrderBatchPrint } from './utils/use-order-batch-print'
import { useDeliveryOrderSubWaybillPrint } from './utils/use-delivery-sub-waybill-print'
import { useB2bActions } from './utils/use-b2b-actions'
import { useVerticalSplitPane } from '@/composables/useVerticalSplitPane'
import OrderToolbarButtonGroup from '@/components/ToolbarButtonGroup/index.vue'
import AllocateSubOrderNumberForm from './form/AllocateSubOrderNumberForm.vue'
@ -406,9 +419,13 @@ const scanBox = ref<any>(null)
const upperTable = ref<any>(null)
const props = defineProps<{
listRequest?: typeof orderDeliveryOrder.list
/** B2B 页签复用本页:额外带出备货/提货/加急作业列与按钮 */
b2b?: boolean
}>()
const presetTree = ref<any[]>([])
const availableFieldsRef = reactive(JSON.parse(JSON.stringify(deliveryAvailableFields)))
const availableFieldsRef = reactive(
JSON.parse(JSON.stringify(props.b2b ? deliveryB2bAvailableFields : deliveryAvailableFields))
)
const activeTab = ref('detail')
const detailDisplayMode = ref<OrderDetailDisplayMode>('compact')
const list = ref<any[]>([])
@ -418,11 +435,13 @@ const queryTime = ref(0)
const pagination = reactive({ currentPage: 1, pageSize: 20, total: 0 })
const tableSize = ref('small')
const columns = ref([...deliveryColumns])
const columns = ref(props.b2b ? buildDeliveryB2bColumns() : [...deliveryColumns])
const selectionRows = ref<any[]>([])
const selectedOrderId = ref<number | string | null>(null)
const detailVisible = ref(true)
const toolbarButtons = deliveryOrderToolbarButtons
const toolbarButtons = computed(() =>
props.b2b ? buildB2bToolbarButtons(deliveryOrderToolbarButtons) : deliveryOrderToolbarButtons
)
const selectedRow = computed(() => {
return list.value.find((i: any) => i.id === selectedOrderId.value) || null
@ -698,7 +717,8 @@ const buttonLoadingMap = computed<Record<string, boolean>>(() => ({
exportSelectionLoading: exportSelectionLoading.value,
batchPrintLoading: batchPrintLoading.value,
subWaybillPrintLoading: subWaybillPrintLoading.value,
allocateSubOrderNumberLoading: allocateSubOrderNumberLoading.value
allocateSubOrderNumberLoading: allocateSubOrderNumberLoading.value,
b2bActionLoading: b2bActionLoading.value
}))
const buttonDisabledMap = computed<Record<string, boolean>>(() => ({
@ -832,6 +852,30 @@ function removeTransferByOrderRow(value: string | number) {
toolbarActionMap.openTransferByOrdersDialog = openTransferByOrdersDialog
// B2B 作业(备货开始 / 备货完成 / 取消备货 / 提货 / 加急设置):仅「配送B2B订单」页签可用
const {
b2bActionLoading,
finishPrepDialogVisible,
finishPrepRow,
submitFinishPrep,
handleStartPrep: handleB2bStartPrep,
handleCancelPrep: handleB2bCancelPrep,
openFinishPrepDialog: openB2bFinishPrepDialog,
handlePickup: handleB2bPickup,
handleSetUrgent: handleB2bSetUrgent,
handleCancelUrgent: handleB2bCancelUrgent
} = useB2bActions({
getSelectionRows: () => selectionRows.value,
onSuccess: () => loadData()
})
toolbarActionMap.handleB2bStartPrep = handleB2bStartPrep
toolbarActionMap.openB2bFinishPrepDialog = openB2bFinishPrepDialog
toolbarActionMap.handleB2bCancelPrep = handleB2bCancelPrep
toolbarActionMap.handleB2bPickup = handleB2bPickup
toolbarActionMap.handleB2bSetUrgent = handleB2bSetUrgent
toolbarActionMap.handleB2bCancelUrgent = handleB2bCancelUrgent
function resolveButtonLoading(loadingKey?: string) {
if (!loadingKey) return false
return Boolean(buttonLoadingMap.value[loadingKey])

View File

@ -4,5 +4,5 @@ import DeliveryOrder from './deliveryOrder.vue'
</script>
<template>
<DeliveryOrder :list-request="orderDeliveryOrder2b.list" />
<DeliveryOrder :list-request="orderDeliveryOrder2b.list" b2b />
</template>

View File

@ -0,0 +1,357 @@
<template>
<el-dialog
:model-value="visible"
class="b2b-prep-finish-dialog"
width="min(560px, 94vw)"
align-center
append-to-body
:show-close="false"
:close-on-click-modal="false"
:close-on-press-escape="!loading"
@update:model-value="handleVisibleChange"
@closed="resetState"
>
<div class="task-panel">
<header class="task-panel__head">
<div class="task-panel__titles">
<h2>B2B 备货完成</h2>
<p>写入备货备注与总箱数,并记录备货完成时间</p>
</div>
<button
class="task-panel__close"
type="button"
aria-label="关闭"
:disabled="loading"
@click="handleVisibleChange(false)"
>
<svg viewBox="0 0 12 12" fill="none">
<path d="M1 1L11 11M11 1L1 11" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" />
</svg>
</button>
</header>
<div class="task-panel__body">
<div class="task-panel__form">
<div class="task-panel__field">
<span class="task-panel__field-label">订单</span>
<strong class="task-panel__field-value">
{{ orderCode || '-' }}
<span class="b2b-prep-finish__id">#{{ orderId ?? '-' }}</span>
</strong>
</div>
<div class="task-panel__field task-panel__field--column">
<span class="task-panel__field-label">备货备注 <em class="b2b-prep-finish__required">*</em></span>
<el-input
v-model="form.prep_remark"
type="textarea"
:rows="3"
maxlength="500"
show-word-limit
placeholder="必填,最长 500 字符"
:disabled="loading"
/>
</div>
<div class="task-panel__field task-panel__field--column">
<span class="task-panel__field-label">总箱数 <em class="b2b-prep-finish__required">*</em></span>
<el-input-number
v-model="form.total_box_count"
:min="0"
:step="1"
step-strictly
:precision="0"
:disabled="loading"
controls-position="right"
style="width: 180px"
/>
</div>
<p class="task-panel__form-tip task-panel__form-tip--warning">
备货完成会按该订单的待拣货记录扣减库存并写入出库流水,且不可撤回;请确认箱数填写正确。
</p>
</div>
</div>
<footer class="task-panel__foot">
<span class="task-panel__hint">备货状态将置为已完成</span>
<div class="task-panel__actions">
<el-button size="small" :disabled="loading" @click="handleVisibleChange(false)">取消</el-button>
<el-button size="small" type="primary" :loading="loading" :disabled="!canSubmit" @click="submit">
确认备货完成
</el-button>
</div>
</footer>
</div>
</el-dialog>
</template>
<script setup lang="ts">
import { computed, reactive, watch } from 'vue'
import { ElMessage } from 'element-plus'
import type { B2bPrepFinishPayload } from '../utils/use-b2b-actions'
/**
* B2B 备货完成(order.finishB2bPrep)
* 单订单作业:必填 prep_remark(≤500)与 total_box_count(≥0 整数)。
*/
const props = withDefaults(
defineProps<{
visible: boolean
loading?: boolean
/** 勾选的 B2B 订单行(取 id 作为订单 ID) */
row?: any
}>(),
{ loading: false, row: null }
)
const emit = defineEmits<{
(e: 'update:visible', value: boolean): void
(e: 'submit', payload: B2bPrepFinishPayload): void
}>()
const form = reactive<B2bPrepFinishPayload>({
prep_remark: '',
total_box_count: 0
})
const orderId = computed(() => {
const id = Number(props.row?.id ?? props.row?.order_id)
return Number.isInteger(id) && id > 0 ? id : null
})
const orderCode = computed(() =>
String(props.row?.delivery_order_code ?? props.row?.order_code ?? '')
)
const canSubmit = computed(
() =>
!props.loading &&
orderId.value !== null &&
form.prep_remark.trim() !== '' &&
Number.isInteger(form.total_box_count) &&
form.total_box_count >= 0
)
// 每次打开时重置表单(按订单维度重新填写)
watch(
() => props.visible,
(visible) => {
if (visible) {
form.prep_remark = ''
form.total_box_count = 0
}
}
)
function handleVisibleChange(next: boolean) {
if (props.loading) return
emit('update:visible', next)
}
function resetState() {
form.prep_remark = ''
form.total_box_count = 0
}
function submit() {
if (props.loading) return
if (orderId.value === null) {
ElMessage.error('所选订单缺少有效订单 ID,请刷新后重试')
return
}
const remark = form.prep_remark.trim()
if (!remark) {
ElMessage.warning('请填写备货备注')
return
}
if (remark.length > 500) {
ElMessage.warning('备货备注不能超过 500 字符')
return
}
if (!Number.isInteger(form.total_box_count) || form.total_box_count < 0) {
ElMessage.warning('总箱数需为大于等于 0 的整数')
return
}
emit('submit', { prep_remark: remark, total_box_count: form.total_box_count })
}
</script>
<style scoped lang="scss">
.b2b-prep-finish__id {
margin-left: 6px;
font-weight: 400;
color: #909399;
}
.b2b-prep-finish__required {
color: #f56c6c;
font-style: normal;
}
/* 面板结构 / 尺寸对齐其它 B2B 作业弹窗 */
.task-panel {
display: flex;
flex-direction: column;
max-height: calc(100vh - 96px);
background: #fff;
color: #303133;
&__head {
display: flex;
align-items: flex-start;
gap: 12px;
padding: 16px;
flex-shrink: 0;
}
&__titles {
flex: 1;
min-width: 0;
h2 {
margin: 0;
font-size: 18px;
line-height: 24px;
font-weight: 400;
color: #303133;
}
p {
margin: 4px 0 0;
font-size: 12px;
line-height: 18px;
color: #909399;
}
}
&__close {
width: 24px;
height: 24px;
flex: none;
display: inline-flex;
align-items: center;
justify-content: center;
border: none;
border-radius: 4px;
background: transparent;
color: #909399;
cursor: pointer;
transition: color 0.2s;
svg {
width: 12px;
height: 12px;
}
&:not(:disabled):hover {
color: #409eff;
}
&:disabled {
cursor: not-allowed;
opacity: 0.5;
}
}
&__body {
padding: 12px 16px 0;
min-height: 0;
overflow-y: auto;
}
&__form {
display: flex;
flex-direction: column;
gap: 8px;
}
&__field {
display: flex;
align-items: center;
justify-content: space-between;
gap: 16px;
min-height: 40px;
padding: 8px 12px;
border: 1px solid #ebeef5;
border-radius: 4px;
background: #fafafa;
&--column {
flex-direction: column;
align-items: stretch;
gap: 6px;
}
}
&__field-label {
font-size: 12px;
line-height: 20px;
color: #606266;
flex-shrink: 0;
white-space: nowrap;
}
&__field-value {
font-size: 13px;
font-weight: 500;
color: #303133;
text-align: right;
word-break: break-all;
}
&__form-tip {
margin: 8px 0 0;
padding: 8px 12px;
border-radius: 4px;
background: #f4f4f5;
font-size: 12px;
line-height: 18px;
color: #909399;
&--warning {
background: #fdf6ec;
color: #e6a23c;
}
}
&__foot {
display: flex;
align-items: center;
justify-content: space-between;
gap: 12px;
padding: 12px 16px 16px;
flex-shrink: 0;
}
&__hint {
font-size: 12px;
color: #909399;
}
&__actions {
display: flex;
align-items: center;
gap: 6px;
:deep(.el-button) {
margin-left: 0;
margin-right: 0;
}
}
}
</style>
<style lang="scss">
/* el-dialog 会被 append 到 body:去掉默认头/内边距,统一交给面板 */
.el-dialog.b2b-prep-finish-dialog {
padding: 0;
overflow: hidden;
.el-dialog__header {
display: none;
}
.el-dialog__body {
padding: 0;
}
}
</style>

View File

@ -61,7 +61,7 @@
<script setup lang="ts">
import { ref, watch, onMounted, computed, markRaw, defineAsyncComponent } from 'vue'
import { useRoute } from 'vue-router'
import { useRoute, useRouter } from 'vue-router'
import { useSettingsStore } from '@/stores/modules/settings'
import { useExperimentalStore } from '@/stores/modules/experimental'
import { orderBadgeCount } from '@/api/order.index/orderindex'
@ -84,6 +84,7 @@ import { safeInvoke } from '@/utils/safe-invoke'
import { ORDER_PAGE_CONFIG } from './config/order-common-config'
const route = useRoute()
const router = useRouter()
const settingsStore = useSettingsStore()
const experimentalStore = useExperimentalStore()
/** tab 缓存开关(实验性设置,默认开) */
@ -235,11 +236,11 @@ function refreshBadgeCounts() {
/**
* 首屏 / 外部导航时从地址栏恢复 tab。
* 方案B:页签切换改为纯本地状态(handleTabChange 不写回路由),
* 因为布局层 AppMain 使用 route.fullPath 作为 router-view 的 key,
* 任何 URL 变化(含 ?tab=)都会触发整页销毁重建,导致切换卡顿、重复请求与显示闪烁。
* 页签切换会通过 syncTabToRoute 把 tab 写回 URL(?tab=xxx),因此刷新、收藏、分享都能定位到同一页签;
* AppMain 的 router-view key 已收窄为 route.name,query 变化不会触发整页销毁重建,
* 页面内的 KeepAlive 缓存也不受影响(切页签仍是纯缓存命中)。
* 此处仅:① 首屏按 URL 初始化;② 浏览器前进/后退等外部导航时同步本地 tab。
* 非法 / 缺失 tab 时纯本地归位到「待处理订单」,绝不写回路由。
* 非法 / 缺失 tab 时归位到「待处理订单」,随后由 ensureTabInQuery 把合法值补写回 URL。
*/
watch(
() => route.query.tab,
@ -249,19 +250,42 @@ watch(
{ immediate: true }
)
/**
* 把当前页签写回 URL(replace,不污染历史栈)。
* ⚠️ 必须展开 route.query:待处理页依赖 route.query.wave_no 做初始筛选条件。
*/
function syncTabToRoute(name: string) {
if (singlePage || !name) return
if (String(route.query.tab ?? '') === name) return
void router.replace({
path: route.path,
query: { ...route.query, tab: name },
hash: route.hash
})
}
/** 首次进入且 URL 未带合法 tab 时,补齐为当前页签(便于刷新与分享) */
function ensureTabInQuery() {
syncTabToRoute(activeTab.value)
}
onMounted(() => {
loadBadgeCounts()
ensureTabInQuery()
})
// 切换标签(使用 tab-change:在 v-model 更新之后触发,避免与 tab-click 重入)
const handleTabChange = (tabName: string | number) => {
safeInvoke(() => {
const name = String(tabName)
// 方案B:纯本地切换,不写回路由(避免改变 fullPath 触发 AppMain 整页销毁重建)
if (activeTab.value === name) {
// 同页签点击:仍确保 URL 带上 tab(例如首屏从裸链接进入后再次点击)
syncTabToRoute(name)
return
}
activeTab.value = name
// 页签写回 URL:刷新 / 分享 / 收藏都能回到同一页签
syncTabToRoute(name)
return loadBadgeCounts()
})
}

View File

@ -2,7 +2,7 @@
<div class="order-sub-container">
<scan-box
ref="scanBox"
cache-key="orderManagement:pendingOrder"
:cache-key="b2b ? 'orderManagement:pendingOrder2b' : 'orderManagement:pendingOrder'"
width="220px"
:tree-props="{ children: 'children', label: 'label' }"
:auto-submit="false"
@ -417,6 +417,15 @@
@success="handleCancelB2bSuccess"
/>
<!-- B2B 备货完成(order.finishB2bPrep):必填备货备注 + 总箱数,完成时同步扣减库存 -->
<b2b-prep-finish-form
v-if="b2b && finishPrepDialogVisible"
v-model:visible="finishPrepDialogVisible"
:loading="b2bActionLoading"
:row="finishPrepRow"
@submit="submitFinishPrep"
/>
<wave-platform-print-preview-dialog
v-if="batchPrintDialogVisible"
v-model="batchPrintDialogVisible"
@ -477,7 +486,9 @@ import { loadExpressListCached, loadPlatformListCached, loadStoresCached } from
import {
buildPendingStyleColumns,
buildPendingB2bColumns,
buildB2bToolbarButtons,
pendingAvailableFields,
pendingB2bAvailableFields,
pendingToolbarButtons,
type ToolbarButtonConfig,
translateOrderField,
@ -515,6 +526,7 @@ import { buildOrderWhereConditions, parseOrderListResponse, resolveOrderIntercep
import { useOrderListPageCleanup } from './utils/use-order-list-page-cleanup'
import { useOrderBatchPrint } from './utils/use-order-batch-print'
import { useSubWaybillPrint } from './utils/use-sub-waybill-print'
import { useB2bActions } from './utils/use-b2b-actions'
import { useVerticalSplitPane } from '@/composables/useVerticalSplitPane'
import OrderToolbarButtonGroup from '@/components/ToolbarButtonGroup/index.vue'
import { createPendingToolbarController } from '@/views/order/shared/toolbarActions'
@ -524,6 +536,7 @@ import { safeInvoke } from '@/utils/safe-invoke'
const WavePlatformPrintPreviewDialog = defineAsyncComponent(() => import('@/views/order/waveOrder/component/WavePlatformPrintPreviewDialog.vue'))
const ConvertToB2bForm = defineAsyncComponent(() => import('./form/ConvertToB2bForm.vue'))
const CancelB2bForm = defineAsyncComponent(() => import('./form/CancelB2bForm.vue'))
const B2bPrepFinishForm = defineAsyncComponent(() => import('./form/B2bPrepFinishForm.vue'))
const scanBox = ref<any>(null)
const upperTable = ref<any>(null)
@ -544,7 +557,9 @@ const upperPaneFullStyle = computed(() => ({
}))
const presetTree = ref<any[]>([])
const availableFieldsRef = reactive(JSON.parse(JSON.stringify(pendingAvailableFields)))
const availableFieldsRef = reactive(
JSON.parse(JSON.stringify(props.b2b ? pendingB2bAvailableFields : pendingAvailableFields))
)
const activeTab = ref('detail')
const detailDisplayMode = ref<OrderDetailDisplayMode>('compact')
@ -594,27 +609,49 @@ const selectedOrderIds = computed(() => getSelectedIds())
const selectedOrderId = ref<number | string | null>(null)
const detailVisible = ref(true)
const toolbarButtons = computed(() => {
// 两个 B2B 方向互斥:待处理页只能「转B2B」,B2B 页只能「取消B2B」
const hiddenKey = props.b2b ? 'convertToB2b' : 'cancelB2b'
return pendingToolbarButtons.filter((button) => button.key !== hiddenKey)
})
const initialConditions = computed(() => {
const waveNo = String(route.query.wave_no || '').trim()
if (!waveNo) return undefined
/** B2B 页签不适用的按钮:反审回待审核 / 抓取散单 / 批量发货 / 克隆订单 */
const B2B_UNSUPPORTED_TOOLBAR_KEYS = [
'reverseReview',
'waveSingleFetchByIds',
'batchQuickRecheck',
'cloneOrder'
]
return {
type: 'custom',
conditions: {
wave_no: {
field: 'wave_no',
type: 'text',
operator: 'eq',
value: waveNo
}
}
}
const toolbarButtons = computed(() => {
// 两个 B2B 方向互斥:待处理页只能「转B2B」,B2B 页只能「取消B2B」;
// 另反审/抓取散单/批量发货/克隆订单 只在普通待处理订单页有意义
const hiddenKeys = props.b2b
? ['convertToB2b', ...B2B_UNSUPPORTED_TOOLBAR_KEYS]
: ['cancelB2b']
const base = pendingToolbarButtons.filter((button) => !hiddenKeys.includes(button.key))
// B2B 页签额外追加备货 / 提货 / 加急作业按钮
return props.b2b ? buildB2bToolbarButtons(base) : base
})
/**
* 从 URL 带 `wave_no` 进入时预置筛选条件。
* ⚠️ 只在 wave_no 真正变化时才生成新对象:页签会写回 `?tab=`,若每次 query 变化都重算,
* ScanBox 的 initialConditions watcher 会把用户手动改过的筛选重置掉。
*/
const initialConditions = ref<any>(undefined)
watch(
() => String(route.query.wave_no ?? '').trim(),
(waveNo) => {
initialConditions.value = waveNo
? {
type: 'custom',
conditions: {
wave_no: {
field: 'wave_no',
type: 'text',
operator: 'eq',
value: waveNo
}
}
}
: undefined
},
{ immediate: true }
)
const expressCodeOptions = ref<Array<{ label: string; value: string }>>([])
const platformCodeOptions = ref<Array<{ label: string; value: string }>>([])
@ -936,6 +973,23 @@ function handleCancelB2bSuccess() {
loadData()
}
// B2B 作业(备货开始 / 备货完成 / 取消备货 / 提货 / 加急设置):仅 B2B 页签可用
const {
b2bActionLoading,
finishPrepDialogVisible,
finishPrepRow,
submitFinishPrep,
handleStartPrep: handleB2bStartPrep,
handleCancelPrep: handleB2bCancelPrep,
openFinishPrepDialog: openB2bFinishPrepDialog,
handlePickup: handleB2bPickup,
handleSetUrgent: handleB2bSetUrgent,
handleCancelUrgent: handleB2bCancelUrgent
} = useB2bActions({
getSelectionRows: () => selectionRows.value,
onSuccess: () => loadData()
})
/** 取消 B2B 弹窗移除某个已选订单:同步快照行并取消列表勾选 */
function removeCancelB2bRow(value: string | number) {
const target = String(value)
@ -1173,6 +1227,12 @@ function removeQuickRecheckOrder(value: string | number) {
toolbarActionMap['openResolveExceptionDialog'] = openResolveExceptionDialog
toolbarActionMap['openConvertToB2bDialog'] = openConvertToB2bDialog
toolbarActionMap['openCancelB2bDialog'] = openCancelB2bDialog
toolbarActionMap['handleB2bStartPrep'] = handleB2bStartPrep
toolbarActionMap['openB2bFinishPrepDialog'] = openB2bFinishPrepDialog
toolbarActionMap['handleB2bCancelPrep'] = handleB2bCancelPrep
toolbarActionMap['handleB2bPickup'] = handleB2bPickup
toolbarActionMap['handleB2bSetUrgent'] = handleB2bSetUrgent
toolbarActionMap['handleB2bCancelUrgent'] = handleB2bCancelUrgent
toolbarActionMap['handleBatchPrint'] = handleBatchPrint
toolbarActionMap['handleSubWaybillPrint'] = handleSubWaybillPrint
toolbarActionMap['handleConfirmInterceptBatch'] = handleConfirmInterceptBatch
@ -1195,7 +1255,8 @@ const buttonLoadingMap = computed<Record<string, boolean>>(() => ({
batchPrintLoading: batchPrintLoading.value,
allocateSubOrderNumberLoading: allocateSubOrderNumberLoading.value,
subWaybillPrintLoading: subWaybillPrintLoading.value,
confirmInterceptLoading: confirmInterceptLoading.value
confirmInterceptLoading: confirmInterceptLoading.value,
b2bActionLoading: b2bActionLoading.value
}))
const toolbarLayoutKey = computed(() =>

View File

@ -0,0 +1,304 @@
import { ref } from 'vue'
import { ElMessage, ElMessageBox } from 'element-plus'
import {
orderPendingOrderStartB2bPrep,
orderPendingOrderCancelB2bPrep,
orderPendingOrderFinishB2bPrep,
orderPendingOrderPickupB2b,
orderPendingOrderSetB2bUrgent,
orderPendingOrderCancelB2bUrgent
} from '@/api/order.pendingorder/orderpendingOrder'
/** 备货完成提交内容(order.finishB2bPrep 必填项) */
export type B2bPrepFinishPayload = {
/** 备货备注(≤500 字符) */
prep_remark: string
/** 总箱数(≥0 整数) */
total_box_count: number
}
type UseB2bActionsOptions = {
/** 当前页签勾选行 */
getSelectionRows: () => any[]
/** 操作成功后刷新列表 */
onSuccess?: () => void
}
function isOkCode(res: any) {
return Boolean(res && (res.code === 1 || res.code === 200 || res.code === 0 || res.flag === 'success'))
}
function pickData(res: any): Record<string, any> {
const data = res?.data && typeof res.data === 'object' ? res.data : res
return (data && typeof data === 'object' ? data : {}) as Record<string, any>
}
function toOrderId(value: unknown): number | null {
const n = Number(value)
return Number.isInteger(n) && n > 0 ? n : null
}
function resolveRowLabel(row: any) {
return String(row?.delivery_order_code ?? row?.order_code ?? row?.id ?? '')
}
/** 勾选行 → 去重后的正整数订单 ID(接口 warehouse_id 由服务端注入) */
function toIdList(rows: any[]): number[] {
const ids: number[] = []
const seen = new Set<number>()
for (const row of rows || []) {
const id = toOrderId(row?.id ?? row?.order_id)
if (id === null || seen.has(id)) continue
seen.add(id)
ids.push(id)
}
return ids
}
/** 加急类接口的批量结果文案(跳过 / 未找到都属于正常响应,需 warning 提示) */
function buildUrgentResultMessage(data: Record<string, any>, label: string) {
const updated = Number(data.updated_count ?? 0)
const skipped = Number(data.skipped_count ?? 0)
const notFound = Array.isArray(data.not_found_order_ids) ? data.not_found_order_ids.length : 0
const parts = [`已设置 ${updated} 条订单为${label}`]
if (skipped) parts.push(`跳过 ${skipped} 条`)
if (notFound) parts.push(`未找到 ${notFound} 条`)
const reasons = Array.isArray(data.skipped_reasons)
? Array.from(
new Set(
data.skipped_reasons
.map((item: any) => String(item?.reason ?? '').trim())
.filter((reason: string) => reason !== '')
)
)
: []
if (reasons.length) parts.push(`原因:${reasons.join(' / ')}`)
return { text: parts.join(','), warning: skipped > 0 || notFound > 0 }
}
/**
* B2B 作业动作(备货开始 / 备货完成 / 取消备货 / 提货 / 设置加急 / 取消加急)。
* 两个 B2B 页签(待处理B2B、配送B2B)共用;普通订单页签不调用。
*/
export function useB2bActions(options: UseB2bActionsOptions) {
const b2bActionLoading = ref(false)
const finishPrepDialogVisible = ref(false)
const finishPrepRow = ref<any>(null)
function requireSelection(emptyText = '请先勾选 B2B 订单') {
const rows = options.getSelectionRows() || []
if (!rows.length) {
ElMessage.warning(emptyText)
return null
}
return rows
}
/** 单订单作业:必须恰好勾选 1 行 */
function requireSingleRow(actionLabel: string) {
const rows = requireSelection(`请先勾选 1 条需要「${actionLabel}」的订单`)
if (!rows) return null
if (rows.length !== 1) {
ElMessage.warning(`「${actionLabel}」为单订单作业,请只勾选 1 条订单`)
return null
}
const id = toOrderId(rows[0]?.id ?? rows[0]?.order_id)
if (id === null) {
ElMessage.error('所选订单缺少有效订单 ID,请刷新后重试')
return null
}
return { row: rows[0], id }
}
async function confirm(message: string, title: string, type: 'warning' | 'info' = 'warning') {
try {
await ElMessageBox.confirm(message, title, {
type,
buttonSize: 'small',
distinguishCancelAndClose: true
})
return true
} catch {
return false
}
}
async function run(
request: () => Promise<any>,
buildMessage: (data: Record<string, any>) => { text: string; warning?: boolean }
) {
if (b2bActionLoading.value) return false
b2bActionLoading.value = true
try {
const res: any = await request()
if (!isOkCode(res)) {
ElMessage.error(res?.message || '操作失败')
return false
}
const { text, warning } = buildMessage(pickData(res))
if (warning) ElMessage.warning(text)
else ElMessage.success(text)
options.onSuccess?.()
return true
} catch {
// 请求层已统一提示错误
return false
} finally {
b2bActionLoading.value = false
}
}
/** order.startB2bPrep:备货开始(操作人取当前登录工号,同工号重复开始幂等) */
async function handleStartPrep() {
const target = requireSingleRow('开始备货')
if (!target) return
const ok = await confirm(
`确定为订单 ${resolveRowLabel(target.row)} 开始备货吗?\n备货人取当前登录工号;重复开始会保留首次开始时间。`,
'开始备货',
'info'
)
if (!ok) return
await run(
() => orderPendingOrderStartB2bPrep({ ids: [target.id] }),
(data) => {
const operator = String(data.prep_operator_name ?? data.prep_operator_id ?? '').trim()
const idempotent = Array.isArray(data.idempotent_order_ids) ? data.idempotent_order_ids.length : 0
const parts = [`已开始备货${operator ? `(备货人 ${operator})` : ''}`]
if (idempotent) parts.push(`其中 ${idempotent} 单为重复开始,保留首次开始时间`)
return { text: parts.join(','), warning: idempotent > 0 }
}
)
}
/** order.cancelB2bPrep:取消备货(重置状态并清空备货人 / 时间,需同一备货工号) */
async function handleCancelPrep() {
const target = requireSingleRow('取消备货')
if (!target) return
const ok = await confirm(
`确定取消订单 ${resolveRowLabel(target.row)} 的备货吗?\n备货状态将重置为未开始,并清空备货人、开始时间与备货用时。`,
'取消备货'
)
if (!ok) return
await run(
() => orderPendingOrderCancelB2bPrep({ ids: [target.id] }),
(data) => {
const count = Number(data.canceled_count ?? (Array.isArray(data.canceled_order_ids) ? data.canceled_order_ids.length : 0))
return { text: `已取消备货 ${count} 单` }
}
)
}
/** order.finishB2bPrep:备货完成(需弹窗填写备货备注与总箱数) */
function openFinishPrepDialog() {
const target = requireSingleRow('备货完成')
if (!target) return
finishPrepRow.value = target.row
finishPrepDialogVisible.value = true
}
function closeFinishPrepDialog() {
finishPrepDialogVisible.value = false
finishPrepRow.value = null
}
async function submitFinishPrep(payload: B2bPrepFinishPayload) {
const row = finishPrepRow.value
const id = toOrderId(row?.id ?? row?.order_id)
if (id === null) {
ElMessage.error('所选订单缺少有效订单 ID,请刷新后重试')
return
}
const ok = await run(
() =>
orderPendingOrderFinishB2bPrep({
ids: [id],
prep_remark: payload.prep_remark,
total_box_count: payload.total_box_count
}),
(data) => {
const boxCount = Number(data.total_box_count ?? payload.total_box_count)
const deducted = Number(data.stock_deducted_quantity ?? 0)
return {
text: `备货完成:总箱数 ${boxCount}${deducted > 0 ? `,同步扣减库存 ${deducted}` : ''}`
}
}
)
if (ok) closeFinishPrepDialog()
}
/** order.pickupB2b:提货(要求备货已完成,重复提货幂等) */
async function handlePickup() {
const target = requireSingleRow('确认提货')
if (!target) return
const ok = await confirm(
`确定订单 ${resolveRowLabel(target.row)} 已提货吗?\n要求备货已完成;提货时间记为提交时刻。`,
'确认提货',
'info'
)
if (!ok) return
await run(
() => orderPendingOrderPickupB2b({ ids: [target.id] }),
(data) => {
if (data.already_picked_up) {
return { text: `该订单已于 ${String(data.picked_up_at ?? '')} 提货(重复提交未改写时间)`, warning: true }
}
return { text: `已记录提货时间:${String(data.picked_up_at ?? '')}` }
}
)
}
/** order.setB2bUrgent:批量设为加急(单次最多 200) */
async function handleSetUrgent() {
const rows = requireSelection('请先勾选需要设置加急的 B2B 订单')
if (!rows) return
const ids = toIdList(rows)
if (!ids.length) {
ElMessage.error('所选订单缺少有效订单 ID,请刷新后重试')
return
}
const ok = await confirm(
`确定将选中的 ${ids.length} 条订单设为加急吗?\n加急订单会在 B2B 列表排到最前;非 B2B 或已取消订单会被跳过。`,
'设为加急',
'info'
)
if (!ok) return
await run(
() => orderPendingOrderSetB2bUrgent({ ids, is_urgent: 'Y' }),
(data) => buildUrgentResultMessage(data, '加急')
)
}
/** order.cancelB2bUrgent:批量取消加急(服务端强制 is_urgent='N') */
async function handleCancelUrgent() {
const rows = requireSelection('请先勾选需要取消加急的 B2B 订单')
if (!rows) return
const ids = toIdList(rows)
if (!ids.length) {
ElMessage.error('所选订单缺少有效订单 ID,请刷新后重试')
return
}
const ok = await confirm(
`确定取消选中的 ${ids.length} 条订单的加急吗?\n取消后这些订单会排回普通队列。`,
'取消加急'
)
if (!ok) return
await run(
() => orderPendingOrderCancelB2bUrgent({ ids }),
(data) => buildUrgentResultMessage(data, '普通')
)
}
return {
b2bActionLoading,
finishPrepDialogVisible,
finishPrepRow,
submitFinishPrep,
closeFinishPrepDialog,
handleStartPrep,
handleCancelPrep,
openFinishPrepDialog,
handlePickup,
handleSetUrgent,
handleCancelUrgent
}
}

View File

@ -216,6 +216,8 @@ const pagination = reactive({
total: 0
})
// immediate:父级用 v-if + 异步组件按需挂载,挂载时 visible 已是 true,
// 没有 immediate 就不会执行初始化(列表/已选商品都不会加载)
watch(visible, (opened) => {
if (!opened) return
searchMode.value = 'stock'
@ -226,7 +228,7 @@ watch(visible, (opened) => {
// 每次打开恢复默认:按货主过滤
filterByStore.value = true
void initDialog()
})
}, { immediate: true })
async function initDialog() {
syncingSelection.value = true

View File

@ -9,14 +9,6 @@
:close-on-click-modal="false"
:before-close="handleBeforeClose"
>
<!-- <el-alert
type="info"
:closable="false"
show-icon
class="import-order-tip"
title="支持 Excel 导入或手动添加明细。点击「添加商品」选择订单商品;勾选左侧订单行后,在右侧粘贴地址进行智能识别(仅填充已勾选行);相同订单号多行合并为一个订单,头信息取首行;省份、城市、区/县为必填项。"
/> -->
<div class="create-order-form-body">
<div class="batch-import-toolbar">
<input
@ -112,6 +104,16 @@
:value="opt.value"
/>
</el-select>
<el-button
v-if="issueRowsCount"
size="small"
type="danger"
:plain="previewIssueFilter !== 'issue'"
:title="previewIssueFilter === 'issue' ? '点击恢复显示全部明细' : '点击只显示异常明细'"
@click="toggleIssueOnlyFilter"
>
异常 {{ issueRowsCount }} 行
</el-button>
<span class="picker-hint">已选文件:{{ importOrderFileName || '未选择' }}</span>
</div>
</div>
@ -311,14 +313,25 @@
</div>
</template>
<template #column-town="{ row }">
<el-input
<el-select
v-model="row.town"
size="small"
filterable
clearable
placeholder="选填"
:disabled="isPreviewRowLocked(row)"
allow-create
default-first-option
:placeholder="row.area_code ? '选填' : '请先选择区/县'"
:disabled="isPreviewRowLocked(row) || !row.area_code"
@change="markPreviewRowDirty(row)"
/>
@visible-change="ensureStreetOptionsLoaded"
>
<el-option
v-for="item in getRowTownOptions(row)"
:key="item.value"
:label="item.label"
:value="item.value"
/>
</el-select>
</template>
<template #column-detail_address="{ row }">
<div :class="{ 'cell-required-empty': isRequiredFieldEmpty(row, 'detail_address') }">
@ -544,6 +557,7 @@
</div>
<SelectProductDialog
v-if="selectProductDialogVisible"
v-model="selectProductDialogVisible"
:store-id="selectProductTargetRow?.store_id"
:store-name="selectProductStoreName"
@ -552,28 +566,20 @@
@confirm="handleSelectProductConfirm"
/>
<!-- <div class="batch-import-summary">
<template v-if="importOrderResult">
待创建订单 {{ importOrderResult.total ?? 0 }} 个 · 成功 {{ importOrderResult.success_count ?? 0 }} · 失败 {{ importOrderResult.fail_count ?? 0 }}
· 明细 {{ importPreviewRows.length }} 行
</template>
<template v-else-if="importPreviewRows.length">
已维护 {{ importPreviewRows.length }} 行明细,涉及 {{ importPreviewOrderCount }} 个订单号,确认后点击「确认创建」
</template>
<template v-else>请选择 Excel 或点击「添加明细」录入订单数据</template>
</div> -->
</el-dialog>
</template>
<script setup lang="ts">
import { computed, nextTick, onBeforeUnmount, onMounted, reactive, ref, watch } from 'vue'
import { computed, defineAsyncComponent, nextTick, onBeforeUnmount, onMounted, reactive, ref, watch } from 'vue'
import { ElMessage, ElMessageBox } from 'element-plus'
import type { DialogBeforeCloseFn } from 'element-plus'
import { useCreateOrderSession, type CreateOrderDraftSnapshot } from './useCreateOrderSession'
// xlsx(约 420KB)改为按需动态加载:使用处 await import('xlsx')
import UpperTable from '@/components/UpperTable/index.vue'
import SelectProductDialog from '@/views/order/shared/component/SelectProductDialog.vue'
// 选择商品弹窗只在点「添加商品」时加载(弹窗内部有自己的商品表格与接口逻辑)
const SelectProductDialog = defineAsyncComponent(
() => import('@/views/order/shared/component/SelectProductDialog.vue')
)
import type { SelectProductItem } from '@/views/order/shared/component/SelectProductDialog.vue'
import { loadExpressListCached, loadPlatformListCached, loadStoresCached } from '@/views/order/shared/orderMetaCache'
import { settingPlatformList } from '@/api/setting.platform/platform'
@ -603,6 +609,7 @@ import {
} from '@/views/system/setting/expressinterface/express-interface-config'
import { extractStoreListFromResponse, mapStoreListToSelectOptions, resolveStoreDisplayName } from '@/utils/storeScanOptions'
import { getStatusTextClass } from '@/utils/statusText'
import { getStreetOptionsByAreaCode, isStreetIndexLoaded, loadStreetIndex } from '@/utils/chinaStreet'
const visible = defineModel<boolean>({ default: false })
@ -621,22 +628,6 @@ const {
takeCreateOrderDraft
} = useCreateOrderSession()
type ImportOrderResult = {
total: number
success_count: number
fail_count: number
success_orders: Array<{
delivery_order_code?: string
order_id?: number | string
step?: number | string
step_label?: string
}>
fail_orders: Array<{
delivery_order_code?: string
error?: string
}>
}
type PreviewSelectedItem = SelectProductItem
type ImportPreviewRow = {
@ -715,14 +706,18 @@ const importPreviewColumns = [
{ prop: 'row_action', label: '操作', width: '70', fixed: 'right', align: 'center' }
]
/** 建单预览「状态」:与待处理订单「同步状态」一致,用轻量状态文字(ut-status-text)替代 el-tag */
/**
* 建单预览「状态」:与待处理订单「同步状态」一致,用轻量状态文字(ut-status-text)替代 el-tag。
* 映射表提到模块级,避免每个状态单元格渲染都新建对象。
*/
const IMPORT_STATUS_TEXT_CLASS: Record<string, string> = {
成功: getStatusTextClass('success'),
失败: getStatusTextClass('danger'),
待创建: getStatusTextClass('info')
}
function getImportStatusTextClass(status?: string) {
const tagTypeMap: Record<string, string> = {
成功: 'success',
失败: 'danger',
待创建: 'info'
}
return getStatusTextClass(tagTypeMap[String(status ?? '').trim()] || 'info')
return IMPORT_STATUS_TEXT_CLASS[String(status ?? '').trim()] || IMPORT_STATUS_TEXT_CLASS['待创建']
}
let previewRowKeySeed = 1
@ -733,7 +728,6 @@ const parseImportFileLoading = ref(false)
const importFileInputRef = ref<HTMLInputElement | null>(null)
const importOrderFileName = ref('')
const importPreviewRows = ref<ImportPreviewRow[]>([])
const importOrderResult = ref<ImportOrderResult | null>(null)
const storeOptions = ref<Array<{ label: string; value: number | string }>>([])
const importExpressOptions = ref<Array<{ label: string; value: string }>>([])
const importSourcePlatformOptions = ref<Array<{ label: string; value: string }>>([])
@ -766,10 +760,9 @@ const issuePreviewRows = computed(() =>
const issueRowsCount = computed(() => issuePreviewRows.value.length)
const normalRowsCount = computed(() => importPreviewRows.value.length - issueRowsCount.value)
const previewIssueFilterOptions = computed(() => [
// 「全部」不加数量标识(默认选项,收起后显示更简洁)
{ label: '全部', value: 'all' as PreviewIssueFilter },
{ label: `有异常 (${issueRowsCount.value})`, value: 'issue' as PreviewIssueFilter },
{ label: `正常 (${normalRowsCount.value})`, value: 'normal' as PreviewIssueFilter }
{ label: `全部 (${importPreviewRows.value.length})`, value: 'all' as PreviewIssueFilter },
{ label: `仅看异常 (${issueRowsCount.value})`, value: 'issue' as PreviewIssueFilter },
{ label: `仅看正常 (${normalRowsCount.value})`, value: 'normal' as PreviewIssueFilter }
])
const filteredPreviewRows = computed(() => {
if (previewIssueFilter.value === 'all') return importPreviewRows.value
@ -783,6 +776,39 @@ const previewTableRows = computed(() => {
const start = (previewPagination.currentPage - 1) * previewPagination.pageSize
return rows.slice(start, start + previewPagination.pageSize)
})
/**
* 镇/街道下拉数据(省市区街道四级,约 1.9MB)按需异步加载。
* 必须在 `watch(visible, …)` 之前声明:该 watch 是 immediate,弹窗挂载即执行,
* 若变量声明在其后会被 TDZ 报错吞掉,导致街道选项永远为空。
*/
const streetOptionsVersion = ref(0)
let streetOptionsLoading = false
/** 按需加载街道数据(幂等):只影响「镇/街道」下拉,不改动已回填的值 */
function ensureStreetOptionsLoaded() {
if (streetOptionsLoading || streetOptionsVersion.value > 0) return
streetOptionsLoading = true
void loadStreetIndex()
.then(() => {
// 只有真正拿到数据才刷新选项(失败时不 bump,以便下次打开下拉重试)
if (isStreetIndexLoaded()) streetOptionsVersion.value += 1
})
.finally(() => {
streetOptionsLoading = false
})
}
/** 某行的「镇/街道」下拉选项:区/县下的街道;已填值不在数据里时补一条,避免显示为空 */
function getRowTownOptions(row: ImportPreviewRow) {
// 显式依赖版本号:街道数据加载完成后该行的下拉自动补全
void streetOptionsVersion.value
const options = getStreetOptionsByAreaCode(row.area_code)
const current = String(row.town || '').trim()
if (!current || options.some((opt) => opt.value === current)) return options
return [{ label: current, value: current }, ...options]
}
const activePreviewRowKey = ref('')
const selectedPreviewRowKeys = ref<Set<string>>(new Set())
const selectedPreviewRowCount = computed(() => selectedPreviewRowKeys.value.size)
@ -825,6 +851,8 @@ watch(visible, (opened) => {
if (opened) {
void loadStoreOptions()
void loadImportSelectOptions()
// 镇/街道下拉数据(约 1.9MB)按需异步加载,不阻塞弹窗打开
ensureStreetOptionsLoaded()
return
}
selectProductDialogVisible.value = false
@ -901,6 +929,19 @@ function handlePreviewIssueFilterChange() {
void nextTick(() => restorePreviewRowSelection())
}
/** 一键切换「只看异常 / 看全部」(工具栏红色按钮,异常清零后自动收起) */
function toggleIssueOnlyFilter() {
previewIssueFilter.value = previewIssueFilter.value === 'issue' ? 'all' : 'issue'
handlePreviewIssueFilterChange()
}
// 异常行全部修好后,避免停留在「仅看异常」的空列表里
watch(issueRowsCount, (count) => {
if (count || previewIssueFilter.value !== 'issue') return
previewIssueFilter.value = 'all'
handlePreviewIssueFilterChange()
})
function handleMinimize() {
persistCreateOrderDraft()
minimizeCreateOrderDialog()
@ -919,7 +960,6 @@ function persistCreateOrderDraft() {
const snapshot: CreateOrderDraftSnapshot = {
importPreviewRows: importPreviewRows.value.map((row) => ({ ...row, selected_items: [...row.selected_items] })),
importOrderFileName: importOrderFileName.value,
importOrderResult: importOrderResult.value,
defaultStoreId: defaultStoreId.value,
activePreviewRowKey: activePreviewRowKey.value,
selectedPreviewRowKeys: Array.from(selectedPreviewRowKeys.value),
@ -945,7 +985,6 @@ function restoreCreateOrderDraft() {
logistics_name: String(row.logistics_name ?? '')
}))
importOrderFileName.value = snapshot.importOrderFileName
importOrderResult.value = snapshot.importOrderResult as ImportOrderResult | null
defaultStoreId.value = snapshot.defaultStoreId
activePreviewRowKey.value = snapshot.activePreviewRowKey
selectedPreviewRowKeys.value = new Set(snapshot.selectedPreviewRowKeys)
@ -1228,6 +1267,8 @@ function handlePreviewAreaChange(row: ImportPreviewRow, code: string) {
row.area_code = code || ''
row.area = findRegionNameByCode(getDistrictNodes(row.province_code, row.city_code), code)
row.town = ''
// 选定区县后再保证街道数据已就绪(首次打开弹窗时也会预加载)
if (row.area_code) ensureStreetOptionsLoaded()
markPreviewRowDirty(row)
}
@ -1295,6 +1336,11 @@ function hasUnmatchedItems(row: ImportPreviewRow): boolean {
function computeRowIssues(row: ImportPreviewRow): string[] {
const issues: string[] = []
// 接口返回创建失败的行也要能被「只看异常」筛出来,不用滑列表找红字
if (row.import_status === '失败') {
const reason = String(row.import_message || '').trim()
issues.push(reason ? `创建失败:${reason}` : '创建失败')
}
if (row._orderExists) issues.push('发货单号已存在')
if (isRequiredFieldEmpty(row, 'store_id')) issues.push('货主未选择')
if (isRequiredFieldEmpty(row, 'shop_nick')) issues.push('自定义店铺未填写')
@ -1543,7 +1589,6 @@ function addImportPreviewRow(copyFrom?: ImportPreviewRow) {
refreshRowIssues(nextRow)
importPreviewRows.value.push(nextRow)
renumberPreviewRows()
importOrderResult.value = null
if (!importOrderFileName.value) {
importOrderFileName.value = '手动录入'
}
@ -1555,7 +1600,6 @@ function removeImportPreviewRow(row: ImportPreviewRow) {
selectedPreviewRowKeys.value.delete(row._rowKey)
importPreviewRows.value = importPreviewRows.value.filter((item) => item._rowKey !== row._rowKey)
renumberPreviewRows()
importOrderResult.value = null
if (activePreviewRowKey.value === row._rowKey) {
// 下一行优先从当前筛选结果里取,避免删除后筛选被重置(筛选状态保持不变)
const nextRow = filteredPreviewRows.value.find((item) => !isPreviewRowLocked(item)) || filteredPreviewRows.value[0]
@ -1592,7 +1636,6 @@ async function removeSelectedPreviewRows() {
const removedKeySet = new Set(targetRows.map((row) => row._rowKey))
importPreviewRows.value = importPreviewRows.value.filter((row) => !removedKeySet.has(row._rowKey))
renumberPreviewRows()
importOrderResult.value = null
removedKeySet.forEach((key) => selectedPreviewRowKeys.value.delete(key))
if (removedKeySet.has(activePreviewRowKey.value)) {
@ -1614,7 +1657,6 @@ function markPreviewRowDirty(row: ImportPreviewRow) {
if (row.import_status === '成功') return
row.import_status = '待创建'
row.import_message = ''
importOrderResult.value = null
refreshRowIssues(row)
}
@ -1695,18 +1737,14 @@ function chunkDeliveryOrderCodes(codes: string[], size = DELIVERY_CODE_CHECK_BAT
return chunks
}
async function runWithConcurrencyLimit<T>(
items: T[],
limit: number,
worker: (item: T) => Promise<void>
) {
async function runWithConcurrency<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]
const item = items[cursor] as T
cursor += 1
if (item === undefined) continue
await worker(item)
@ -1721,7 +1759,7 @@ async function findExistingDeliveryOrderCodes(codes: string[]) {
const uniqueCodes = [...new Set(codes.map((code) => String(code || '').trim()).filter(Boolean))]
const batches = chunkDeliveryOrderCodes(uniqueCodes)
await runWithConcurrencyLimit(batches, DELIVERY_CODE_CHECK_MAX_CONCURRENT, async (batch) => {
await runWithConcurrency(batches, DELIVERY_CODE_CHECK_MAX_CONCURRENT, async (batch) => {
const matches = await queryPendingOrdersByDeliveryCodes(batch)
for (const order of matches) {
const code = resolveExistingDeliveryOrderCode(order)
@ -1759,7 +1797,6 @@ async function handleReRecognizeAddresses() {
}
applyParsedAddressToRow(row, data)
successCount += 1
persistCreateOrderDraft()
})
if (!successCount) {
@ -1824,14 +1861,12 @@ async function handleCheckDeliveryOrderCodes() {
ElMessage.error('发货单号查重失败')
} finally {
checkDeliveryCodeLoading.value = false
persistCreateOrderDraft()
}
}
function resetImportOrderDialog() {
importOrderFileName.value = ''
importPreviewRows.value = []
importOrderResult.value = null
defaultStoreId.value = undefined
activePreviewRowKey.value = ''
previewIssueFilter.value = 'all'
@ -1846,7 +1881,6 @@ function resetImportOrderDialog() {
function clearImportData() {
importOrderFileName.value = ''
importPreviewRows.value = []
importOrderResult.value = null
activePreviewRowKey.value = ''
previewIssueFilter.value = 'all'
resetPreviewPagination()
@ -1932,18 +1966,27 @@ function normalizeImportHeaderText(text: unknown): string {
return String(text ?? '').replace(/[\s**]/g, '').toLowerCase()
}
/** 归一化表头 → 字段(模块级预构建,避免每次导出都遍历全部别名并重复归一化) */
const IMPORT_HEADER_FIELD_MAP = new Map<string, string>()
for (const [field, aliases] of Object.entries(IMPORT_FIELD_ALIASES)) {
for (const alias of aliases) {
const key = normalizeImportHeaderText(alias)
if (key && !IMPORT_HEADER_FIELD_MAP.has(key)) IMPORT_HEADER_FIELD_MAP.set(key, field)
}
}
/** 按模板表头文本反查预览行字段;返回空串表示该列不参与导出(模板里的额外列) */
function resolveImportFieldByHeader(header: unknown): string {
const norm = normalizeImportHeaderText(header)
if (!norm) return ''
for (const [field, aliases] of Object.entries(IMPORT_FIELD_ALIASES)) {
if (aliases.some((alias) => normalizeImportHeaderText(alias) === norm)) return field
}
return ''
return norm ? IMPORT_HEADER_FIELD_MAP.get(norm) || '' : ''
}
/** 建单模板布局缓存(表头 + 工作表名):同一会话多次「导出选中」不再重复下载/解析模板 */
let createTemplateLayoutCache: { header: string[]; sheetName: string } | null = null
/** 取建单模板的表头与工作表名(与「下载模板」同一个接口) */
async function fetchCreateTemplateLayout(): Promise<{ header: string[]; sheetName: string }> {
if (createTemplateLayoutCache) return createTemplateLayoutCache
try {
const res: any = await orderPendingOrder.downloadCreateTemplate()
const ok = res && (res.code === 1 || res.code === 200 || res.flag === 'success')
@ -1955,7 +1998,10 @@ async function fetchCreateTemplateLayout(): Promise<{ header: string[]; sheetNam
const sheet = workbook.Sheets[sheetName]
const matrix = (sheet ? XLSX.utils.sheet_to_json(sheet, { header: 1, blankrows: false }) : []) as unknown[][]
const headerRow = (matrix[0] || []).map((cell) => String(cell ?? '').trim()).filter(Boolean)
return { header: headerRow.length ? headerRow : FALLBACK_EXPORT_HEADER, sheetName }
if (!headerRow.length) return { header: FALLBACK_EXPORT_HEADER, sheetName }
// 只有真正解析到模板表头才缓存,接口失败时保留重试机会
createTemplateLayoutCache = { header: headerRow, sheetName }
return createTemplateLayoutCache
} catch {
return { header: FALLBACK_EXPORT_HEADER, sheetName: 'Sheet1' }
}
@ -2138,7 +2184,6 @@ async function parseImportPreviewFromFile(file: File) {
}
parseImportFileLoading.value = true
importOrderResult.value = null
clearPreviewRowSelection()
try {
const buffer = await file.arrayBuffer()
@ -2315,20 +2360,6 @@ async function handleImportFileChange(event: Event) {
await parseImportPreviewFromFile(file)
}
async function runWithConcurrency<T>(items: T[], limit: number, worker: (item: T) => Promise<void>): Promise<void> {
if (!items.length) return
let cursor = 0
const runners = Math.min(limit, items.length)
await Promise.all(
Array.from({ length: runners }, async () => {
while (cursor < items.length) {
const item = items[cursor++] as T
await worker(item)
}
})
)
}
function groupPendingRowsByOrder() {
const map = new Map<string, ImportPreviewRow[]>()
for (const row of importPreviewRows.value) {
@ -2400,6 +2431,8 @@ function validatePreviewRowsBeforeSubmit(options?: { requireItemId?: boolean })
ElMessage.warning('没有待创建的订单')
return false
}
// 货主合法性校验:预构建 Set,避免每个订单组都遍历一次货主下拉
const validStoreIds = new Set(storeOptions.value.map((item) => Number(item.value)))
for (const [groupKey, rows] of groups) {
const header = rows[0]
@ -2410,7 +2443,7 @@ function validatePreviewRowsBeforeSubmit(options?: { requireItemId?: boolean })
ElMessage.warning(`订单「${orderLabel}」:请选择货主`)
return false
}
const storeValid = storeOptions.value.some((item) => Number(item.value) === Number(header.store_id))
const storeValid = validStoreIds.has(Number(header.store_id))
if (!storeValid) {
ElMessage.warning(`订单「${orderLabel}」:货主无效,请重新选择`)
return false
@ -2484,22 +2517,34 @@ function validatePreviewRowsBeforeSubmit(options?: { requireItemId?: boolean })
return true
}
function applyOrderGroupResult(
rows: ImportPreviewRow[],
success: boolean,
options?: {
message?: string
data?: { order_id?: number | string; delivery_order_code?: string; step?: number | string; step_label?: string }
type OrderGroupResult = {
rows: ImportPreviewRow[]
success: boolean
message?: string
data?: { order_id?: number | string; delivery_order_code?: string; step?: number | string; step_label?: string }
}
/**
* 批量回写建单结果:
* 一次性重建明细数组 + 一次异常重算(原实现每组都全量 map + syncAllPreviewRowIssues,
* N 个订单 → O(N×M) 次行拷贝与 N 次整个表格重渲染)。
*/
function applyOrderGroupResults(results: OrderGroupResult[]) {
if (!results.length) return
const patchByRowKey = new Map<string, OrderGroupResult>()
for (const result of results) {
for (const row of result.rows) {
patchByRowKey.set(row._rowKey, result)
}
}
) {
const apiMessage = String(options?.message ?? '').trim()
const rowKeySet = new Set(rows.map((row) => row._rowKey))
importPreviewRows.value = importPreviewRows.value.map((row) => {
if (!rowKeySet.has(row._rowKey)) return row
if (success) {
const result = patchByRowKey.get(row._rowKey)
if (!result) return row
const apiMessage = String(result.message ?? '').trim()
if (result.success) {
return {
...row,
delivery_order_code: String(options?.data?.delivery_order_code || row.delivery_order_code || '').trim(),
delivery_order_code: String(result.data?.delivery_order_code || row.delivery_order_code || '').trim(),
import_status: '成功',
import_message: apiMessage || '创建成功'
}
@ -2615,50 +2660,37 @@ async function submitImportOrders() {
return
}
const result: ImportOrderResult = {
total: groups.size,
success_count: 0,
fail_count: 0,
success_orders: [],
fail_orders: []
}
const summary = { successCount: 0, failCount: 0 }
const groupResults: OrderGroupResult[] = []
try {
await runWithConcurrency([...groups.values()], 4, async (rows) => {
const orderLabel = String(rows[0]?.delivery_order_code || '').trim() || `第 ${rows[0]?.row_no} 行`
try {
const payload = buildCreateOrderPayload(rows)
const res = await orderPendingOrder.createOrder(payload)
const ok = res && (res.code === 1 || res.code === 200 || res.flag === 'success')
const apiMessage = String(res?.message ?? '').trim()
if (!ok) {
const message = apiMessage || '创建订单失败'
result.fail_count += 1
result.fail_orders.push({ delivery_order_code: orderLabel, error: message })
applyOrderGroupResult(rows, false, { message })
summary.failCount += 1
groupResults.push({ rows, success: false, message: apiMessage || '创建订单失败' })
return
}
const data = res?.data || {}
result.success_count += 1
result.success_orders.push({
delivery_order_code: data.delivery_order_code || orderLabel,
order_id: data.order_id,
step: data.step,
step_label: data.step_label
})
applyOrderGroupResult(rows, true, { message: apiMessage, data })
summary.successCount += 1
groupResults.push({ rows, success: true, message: apiMessage, data: res?.data || {} })
} catch (error: any) {
const message = String(error?.message ?? '').trim() || '创建订单失败'
result.fail_count += 1
result.fail_orders.push({ delivery_order_code: orderLabel, error: message })
applyOrderGroupResult(rows, false, { message })
summary.failCount += 1
groupResults.push({
rows,
success: false,
message: String(error?.message ?? '').trim() || '创建订单失败'
})
}
})
importOrderResult.value = result
ElMessage.success(`批量创建完成:成功 ${result.success_count} 个,失败 ${result.fail_count} 个`)
if (result.success_count > 0) {
// 全部请求结束后一次性回写结果:避免“每个订单组一次全量 map + 全量异常重算”
applyOrderGroupResults(groupResults)
ElMessage.success(`批量创建完成:成功 ${summary.successCount} 个,失败 ${summary.failCount} 个`)
if (summary.successCount > 0) {
emit('success')
void notifyCreateOrderSuccess()
}
@ -2781,7 +2813,6 @@ async function handleCreateOrderFromAddress() {
importPreviewRows.value.push(...createdRows)
renumberPreviewRows()
syncAllPreviewRowIssues()
importOrderResult.value = null
if (!importOrderFileName.value) {
importOrderFileName.value = '手动录入'
}
@ -2944,7 +2975,7 @@ async function handleParseAddress() {
}
.preview-issue-filter {
width: 150px;
width: 170px;
}
.issue-indicator {
@ -2976,13 +3007,6 @@ async function handleParseAddress() {
.ut-status-text--info { color: var(--el-color-info); }
.ut-status-text--danger { color: var(--el-color-danger); }
.unmatched-tip {
color: #f56c6c;
font-size: 11px;
margin-left: 2px;
white-space: nowrap;
}
:deep(.el-table__body tr.current-row > td) {
background-color: #d1e9ff !important;
}
@ -3072,10 +3096,6 @@ async function handleParseAddress() {
line-height: 1.5;
}
.address-panel-meta--empty {
color: #909399;
}
.address-paste-input {
flex: 0 0 auto;
width: 100%;

View File

@ -13,7 +13,6 @@ export type CreateOrderFloatSummary = {
export type CreateOrderDraftSnapshot = {
importPreviewRows: unknown[]
importOrderFileName: string
importOrderResult: unknown | null
defaultStoreId?: number
activePreviewRowKey: string
selectedPreviewRowKeys: string[]

View File

@ -4,7 +4,7 @@
ref="scanBox"
cache-key="shipper-signing"
width="220px"
title="货主筛选"
title="签约筛选"
:auto-submit="false"
:preset-tree="presetTree"
:available-fields="availableFields"
@ -280,14 +280,94 @@
</footer>
</div>
</el-dialog>
<!-- 发起签约(仓库侧:当前仓库作为发起方,对方主体自动识别) -->
<el-dialog
v-model="signDialogVisible"
class="sign-row-dialog"
width="min(560px, 92vw)"
align-center
append-to-body
:show-close="false"
destroy-on-close
:close-on-click-modal="false"
>
<div class="task-panel">
<header class="task-panel__head">
<div class="task-panel__titles">
<h2>发起签约</h2>
<p>仓库侧发起签约,对方主体自动识别为仓库或货主</p>
</div>
<button
class="task-panel__close"
type="button"
aria-label="关闭"
@click="signDialogVisible = false"
>
<svg viewBox="0 0 12 12" fill="none">
<path d="M1 1L11 11M11 1L1 11" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" />
</svg>
</button>
</header>
<div class="task-panel__body">
<div class="task-panel__form">
<div class="task-panel__field">
<span class="task-panel__field-label">当前仓库</span>
<strong class="task-panel__field-value">{{ currentSubject.company_name || '—' }}</strong>
</div>
<div class="task-panel__field task-panel__field--input">
<span class="task-panel__field-label">对方主体</span>
<div class="task-panel__field-control">
<el-select
v-model="signForm.counterparty_id"
filterable
allow-create
default-first-option
clearable
:loading="counterpartyLoading"
placeholder="选择或输入对方主体ID"
style="width: 100%"
>
<el-option
v-for="opt in counterpartyOptions"
:key="opt.value"
:label="opt.label"
:value="opt.value"
/>
</el-select>
</div>
</div>
</div>
<p class="task-panel__form-tip">
提交后需由对方主体在对应页面「确认签约」;对方主体 ID 兼容仓库与货主。
</p>
</div>
<footer class="task-panel__foot">
<span class="task-panel__hint">提交前请确认对方主体无误</span>
<div class="task-panel__actions">
<el-button size="small" @click="signDialogVisible = false">取消</el-button>
<el-button size="small" type="primary" :loading="signSubmitting" @click="submitSign">提交</el-button>
</div>
</footer>
</div>
</el-dialog>
</div>
</template>
<script setup lang="ts">
import { ref, reactive, onMounted, computed } from 'vue'
import { ref, reactive, nextTick, onMounted, computed } from 'vue'
import { ElMessage, ElMessageBox } from 'element-plus'
import { storeWarehouseWarehouseList } from '@/api/storewarehouse.warehouse/storeWarehouse'
import { storeWarehouseUnbind, storeWarehouseRename, storeWarehouseConfirmSign } from '@/api/storewarehouse.store/storeWarehouse'
import {
storeWarehouseWarehouseList,
storeWarehouseWarehouseSign,
storeWarehouseWarehouseConfirmSign
} from '@/api/storewarehouse.warehouse/storeWarehouse'
import { storeWarehouseUnbind, storeWarehouseRename } from '@/api/storewarehouse.store/storeWarehouse'
import { loadWarehouses } from '@/api/index/index'
import ScanBox from '@/components/ScanBox/index.vue'
import UpperTable from '@/components/UpperTable/index.vue'
import OrderToolbarButtonGroup from '@/components/ToolbarButtonGroup/index.vue'
@ -317,6 +397,7 @@ const detailVisible = ref(true)
const toolbarButtons: ToolbarButtonConfig[] = [
{ key: 'refresh', label: '刷新', category: 'refresh', size: 'small', loadingKey: 'loading', action: 'loadList' },
{ key: 'sign', label: '发起签约', category: 'action', size: 'small', action: 'openSignDialog' },
{
key: 'toggleDetail',
label: '显示详情',
@ -367,6 +448,7 @@ function toggleDetailVisible() {
const toolbarActionMap: Record<string, () => void> = {
loadList: () => { void loadList() },
openSignDialog: () => { void openSignDialog() },
toggleDetailVisible: () => toggleDetailVisible()
}
@ -377,7 +459,7 @@ function handleToolbarButtonClick(action: ToolbarButtonConfig['action']) {
}
const columns = [
{ prop: 'counterparty_name', label: '签约货主', minWidth: 140 },
{ prop: 'counterparty_name', label: '对方主体', minWidth: 140 },
{ prop: 'auth_status', label: '签约状态', width: 100 },
{ prop: 'needs_my_confirm', label: '待确认', width: 90 },
{ prop: 'use_status', label: '使用状态', width: 90 },
@ -393,7 +475,7 @@ const availableFields = [
value: 'keyword',
type: 'text',
group: '基础信息',
placeholder: '搜索货主名或备注'
placeholder: '搜索对方主体名或备注'
},
{
label: '签约状态',
@ -435,6 +517,77 @@ const activeTab = ref('details')
const pagination = reactive({ currentPage: 1, pageSize: 20, total: 0 })
const currentCondition = ref<any>({ use_status: 1 })
// ─── 发起签约(仓库侧:当前仓库在 store_id 方,对方主体自动识别) ─────────────
const signDialogVisible = ref(false)
const signSubmitting = ref(false)
const signForm = reactive<{ counterparty_id: number | string | undefined }>({ counterparty_id: undefined })
const counterpartyOptions = ref<Array<{ label: string; value: number }>>([])
const counterpartyLoading = ref(false)
/** 对方主体下拉:取 index.loadWarehouses(已是 value/label 形式),也允许直接输入主体ID */
async function loadCounterpartyOptions() {
if (counterpartyOptions.value.length) return
counterpartyLoading.value = true
try {
const res = (await loadWarehouses()) as any
const arr = res?.warehouses || res?.data?.warehouses || []
counterpartyOptions.value = (Array.isArray(arr) ? arr : [])
.map((item: any) => ({
value: Number(item?.value ?? item?.id),
label: String(item?.label ?? item?.name ?? item?.company_name ?? item?.value ?? '')
}))
.filter((opt) => Number.isFinite(opt.value) && opt.value > 0)
} catch {
counterpartyOptions.value = []
} finally {
counterpartyLoading.value = false
}
}
async function openSignDialog() {
signForm.counterparty_id = undefined
signDialogVisible.value = true
void nextTick(() => loadCounterpartyOptions())
}
async function submitSign() {
const counterpartyId = Number(signForm.counterparty_id)
if (!Number.isFinite(counterpartyId) || counterpartyId <= 0) {
ElMessage.warning('请选择或输入有效的对方主体ID')
return
}
signSubmitting.value = true
try {
const res = (await storeWarehouseWarehouseSign({ counterparty_id: counterpartyId })) as any
if (res?.flag === 'success' || res?.code === 200) {
/* 仓库侧 sign 与货主侧 store.sign 不同:入参只有 counterparty_id,没有 temp_code/预览流程,
一次调用即出结果。响应 data.mode:initiate=已新建或更新申请;
already_exists 时用 data.exists_status 区分 1=待确认 / 2=已签约(已签约时 mode 也可能是 already_confirmed) */
const data = res?.data || {}
const mode = String(data.mode || '')
const name = data?.contract?.counterparty_name || ''
const existsStatus = Number(data.exists_status ?? data?.contract?.auth_status)
if (mode === 'already_exists' || mode === 'already_confirmed') {
if (existsStatus === 2) {
ElMessage.warning(`与「${name}」已签约,无需重复发起`)
} else {
ElMessage.warning(`与「${name}」的签约申请已存在,请等待对方确认`)
}
} else {
ElMessage.success(data.action === 'update' ? '已更新签约申请' : '签约申请已提交')
}
signDialogVisible.value = false
loadList()
} else {
ElMessage.error(res?.message || '发起签约失败')
}
} catch {
ElMessage.error('发起签约失败')
} finally {
signSubmitting.value = false
}
}
async function loadList() {
loading.value = true
const startTime = Date.now()
@ -595,7 +748,8 @@ async function handleConfirmSign(row: any) {
)
} catch { return }
try {
const res = await storeWarehouseConfirmSign({ id: row.id })
// 本页为仓库视角(当前仓库在 store_id 方),确认签约走仓库侧接口
const res = (await storeWarehouseWarehouseConfirmSign({ id: row.id })) as any
if (res?.flag === 'success' || res?.code === 200 || res?.data?.mode === 'confirm') {
ElMessage.success('签约已确认')
loadList()

View File

@ -72,7 +72,7 @@
</span>
</template>
<template #column-needs_my_confirm="{ row }">
<span v-if="row.auth_status === 1" :class="getStatusTextClass('warning')">待我确认</span>
<span v-if="isNeedsMyConfirm(row)" :class="getStatusTextClass('warning')">待我确认</span>
<span v-else class="text-muted">—</span>
</template>
<template #column-use_status="{ row }">
@ -157,7 +157,7 @@
@click.stop="handleGenerateBindCode(row)"
>加群授权</el-button>
<el-button
v-if="row.current_subject_role === 'warehouse'"
v-if="currentSubjectRole === 'warehouse'"
size="small"
type="warning"
link
@ -1501,7 +1501,7 @@ import { useVerticalSplitPane } from '@/composables/useVerticalSplitPane'
import { useAsyncExportTask } from '@/composables/useAsyncExportTask'
import AsyncExportProgressDialog from '@/components/AsyncExportProgressDialog.vue'
import { safeInvoke } from '@/utils/safe-invoke'
import { columns as defaultColumns, availableFields as defaultAvailableFields, presetTree as defaultPresetTree, qimenFormDefault, qimenFormItems, qimenTableColumns, adjustBalanceDialogDefault, adjustBalanceFormDefault, adjustBalanceFormItems, openAccountDialogDefault, openAccountFormDefault, createUserDialogDefault, createUserFormDefault, storeToolbarButtons, OMS_INTERFACE_TYPE } from './store-config.ts'
import { columns as defaultColumns, availableFields as defaultAvailableFields, presetTree as defaultPresetTree, qimenFormDefault, qimenTableColumns, adjustBalanceDialogDefault, adjustBalanceFormDefault, adjustBalanceFormItems, openAccountDialogDefault, openAccountFormDefault, createUserDialogDefault, createUserFormDefault, storeToolbarButtons, OMS_INTERFACE_TYPE } from './store-config.ts'
import { inboxBindCode } from '@/api/inbox/inbox'
// ─── 列表 ───────────────────────────────────────────────────────────────────
@ -1529,6 +1529,8 @@ const loading = ref(false)
const queryTime = ref(0)
const tableSize = ref<'small' | 'default' | 'large'>('small')
const list = ref<any[]>([])
/** 当前登录主体角色(取自 list 响应 current_subject.role):warehouse=仓库方,store=货主方 */
const currentSubjectRole = ref<string>('')
const selectionRows = ref<any[]>([])
const selectedRow = ref<any>(null)
const tableRef = ref<any>(null)
@ -1757,11 +1759,15 @@ async function handleExportSelected() {
ElMessage.warning('选中的记录无有效签约ID')
return
}
// 实测(2026-11-18):export 的 id 只接受单值(传数组时任务失败:“id 参数不能为空”),
// 且 where.id in [] 会被忽略 → 多选导出无法实现,这里限制为单条,多选请用「导出全部」
if (ids.length > 1) {
ElMessage.warning(`「导出选中」仅支持 1 条记录,当前已勾选 ${ids.length} 条,请只勾选 1 条或使用「导出全部」`)
return
}
await listExportSubmit({
...(currentCondition.value || {}),
// ⚠️ 文档(storeWarehouse.store.export)的 id 只声明 number(“仅导出该签约关系”);
// 多选时传数组属前端扩展,若后端不支持可能被忽略(退化为按筛选条件全量导出)→ 待后端确认
id: ids.length === 1 ? ids[0] : ids
id: ids[0]
})
}
@ -1792,6 +1798,8 @@ async function loadList() {
if (res?.data) {
const payload = res.data
list.value = payload.list || []
// 当前登录主体角色由后端返回(warehouse=仓库方 / store=货主方),用于控制按钮与 unbind 字段
currentSubjectRole.value = String(payload.current_subject?.role || '').toLowerCase()
pagination.total = payload.pagination?.total || payload.total || 0
pagination.currentPage = payload.pagination?.page || payload.page || pagination.currentPage
pagination.pageSize = payload.pagination?.pageSize || payload.page_size || pagination.pageSize
@ -2071,6 +2079,14 @@ function handleBalanceLogSizeChange(size: number) {
}
// ─── 状态辅助 ────────────────────────────────────────────────────────────────
/** 「待我确认」判定:优先后端 needs_my_confirm(已排除自己发起的申请),旧响应回退 auth_status=1 */
function isNeedsMyConfirm(row: any): boolean {
if (row?.needs_my_confirm !== undefined && row?.needs_my_confirm !== null) {
return Boolean(row.needs_my_confirm)
}
return row?.auth_status === 1
}
function getAuthStatusType(status: number) {
const map: Record<number, string> = { 1: 'warning', 2: 'success', 3: 'danger', 4: 'info', 5: 'danger' }
return (map[status] || 'info') as any
@ -2127,10 +2143,13 @@ async function handleUnbind(row: any, targetStatus: number) {
}
try {
// 实测(2026-11-18,当前主体 role=warehouse):传 warehouse_use_status 生效,store_use_status 被忽略。
// 文档语义:仓库侧传 warehouse_use_status,货主侧传 store_use_status → 按当前主体角色选择字段
const useStatusField = currentSubjectRole.value === 'store' ? 'store_use_status' : 'warehouse_use_status'
const res = await storeWarehouseUnbind({
id: row.id,
warehouse_use_status: targetStatus
}) as any
[useStatusField]: targetStatus
} as any) as any
if (res?.flag === 'success' || res?.code === 200) {
ElMessage.success(`${actionLabel}成功`)
loadList()

View File

@ -1,22 +1,5 @@
import type { ToolbarButtonConfig } from '@/components/ToolbarButtonGroup/types'
// 签约弹窗默认配置
export const signDialogDefault = {
visible: false,
title: '发起签约',
step: 1, // 1=填写信息, 2=临时码/预览/确认
loading: false,
mode: '', // initiate / preview / confirm
tempCode: '',
contract: null as any
}
// 签约表单默认配置
export const signFormDefault = {
counterparty_id: undefined as number | undefined,
remask: ''
}
/** 前端本地定义的接口类型选项,无需依赖后端接口返回即可渲染下拉菜单 */
export const LOCAL_INTERFACE_TYPES: { interface_code: string; interface_name: string }[] = [
{ interface_code: 'QM_WMS', interface_name: '奇门仓储接口' },
@ -63,25 +46,6 @@ export const adjustBalanceFormDefault = {
reason: ''
}
// 签约表单项配置
export const signFormItems = [
{ label: '对方主体ID', prop: 'counterparty_id', type: 'number', required: true, placeholder: '请输入对方主体ID' },
{ label: '通用名备注', prop: 'remask', type: 'input', placeholder: '给对方主体的通用名称(可选)' }
]
// 接口配置(apiConfig)表单项配置(保留备用)
export const qimenFormItems = [
{ label: '应用名称', prop: 'app_name', type: 'input', required: true, placeholder: '请输入应用名称', span: 24 },
{ label: 'ERP', prop: 'qimen_app_key', type: 'input', required: true, placeholder: '请选择ERP', span: 12 },
{ label: '货主编码', prop: 'qimen_customer_id', type: 'input', required: true, placeholder: '奇门货主编码', span: 12 },
{ label: '仓库编码', prop: 'qimen_warehouse_code', type: 'input', required: true, placeholder: '奇门仓库编码', span: 12 },
{ label: 'API版本', prop: 'api_version', type: 'input', placeholder: '默认1.0', span: 12 },
{ label: '联系人', prop: 'contact_person', type: 'input', span: 12 },
{ label: '联系电话', prop: 'contact_phone', type: 'input', span: 12 },
{ label: '邮箱', prop: 'email', type: 'input', span: 12 },
{ label: '是否启用', prop: 'is_enabled', type: 'switch', activeValue: 1, inactiveValue: 0, activeText: '启用', inactiveText: '停用', span: 12 }
]
// 代开户弹窗默认配置
export const openAccountDialogDefault = {
visible: false,
@ -219,8 +183,20 @@ export const availableFields = [
label: '货主',
value: 'store_id',
type: 'select',
group: '基础信息',
options: [] as Array<{ label: string; value: number | string }>
},
{
label: '对方主体ID',
value: 'counterparty_id',
type: 'number',
group: '基础信息',
placeholder: '对方主体ID(与「货主」等价,用于不在下拉中的主体)',
// 文档口径:counterparty_id 兼容 store_id,两者传一即可;实测后端仅按等值匹配
operators: ['eq'],
defaultOperator: 'eq',
hideOperator: true
},
{
label: '签约状态',
value: 'auth_status',
@ -300,13 +276,9 @@ export default {
columns,
availableFields,
presetTree,
signDialogDefault,
signFormDefault,
qimenFormDefault,
adjustBalanceDialogDefault,
adjustBalanceFormDefault,
signFormItems,
qimenFormItems,
adjustBalanceFormItems,
qimenTableColumns,
detailPanel

View File

@ -330,7 +330,7 @@ const FALLBACK_FIELDS: NormalizedField[] = [
label: '散单称重需要打包',
type: 'boolean',
default: false,
description: '默认关闭;开启后散单称重(订单波次范围 wave_scope 非 1 大团购/3 小团购)前必须已打包完成(pack_status=fin),未打包时拒绝称重并返回错误(like-flag:true/1/\'1\'/\'true\' 为开启)'
description: '默认关闭;开启后散单称重(订单波次范围 wave_scope 非 1 大团购/3 小团购)须处于打包中或已打包(pack_status=padding/fin),未打包或打包异常时拒绝称重并返回错误(like-flag:true/1/\'1\'/\'true\' 为开启)'
},
{
key: 'big_group_pack_coefficient',

View File

@ -722,15 +722,38 @@ export function buildProvinceOptions(): RegionSelectOption[] {
return chinaRegionTree.map((item) => ({ label: item.name, value: item.code }))
}
/**
* 市 / 区县下拉选项缓存:
* 数据来自静态行政区划,结果不会变化;建单预览表里每行每个单元格渲染都会调一次,
* 缓存后避免每次渲染都遍历 + 新建数组(返回的是共享数组,调用方只读不修改)。
*/
const cityOptionsCache = new Map<string, RegionSelectOption[]>()
const districtOptionsCache = new Map<string, RegionSelectOption[]>()
const EMPTY_REGION_OPTIONS: RegionSelectOption[] = []
export function buildCityOptions(provinceCode: string): RegionSelectOption[] {
const province = chinaRegionTree.find((item) => item.code === provinceCode)
return (province?.children || []).map((item) => ({ label: item.name, value: item.code }))
const key = String(provinceCode || '')
if (!key) return EMPTY_REGION_OPTIONS
const cached = cityOptionsCache.get(key)
if (cached) return cached
const province = chinaRegionTree.find((item) => item.code === key)
const options = (province?.children || []).map((item) => ({ label: item.name, value: item.code }))
cityOptionsCache.set(key, options)
return options
}
export function buildDistrictOptions(provinceCode: string, cityCode: string): RegionSelectOption[] {
const province = chinaRegionTree.find((item) => item.code === provinceCode)
const city = (province?.children || []).find((item) => item.code === cityCode)
return (city?.children || []).map((item) => ({ label: item.name, value: item.code }))
const provinceKey = String(provinceCode || '')
const cityKey = String(cityCode || '')
if (!provinceKey || !cityKey) return EMPTY_REGION_OPTIONS
const cacheKey = `${provinceKey}|${cityKey}`
const cached = districtOptionsCache.get(cacheKey)
if (cached) return cached
const province = chinaRegionTree.find((item) => item.code === provinceKey)
const city = (province?.children || []).find((item) => item.code === cityKey)
const options = (city?.children || []).map((item) => ({ label: item.name, value: item.code }))
districtOptionsCache.set(cacheKey, options)
return options
}
function findRegionCodeByName(nodes: RegionNode[], name: string): string {

View File

@ -120,7 +120,12 @@ export default defineConfig(({ mode }) => {
if (id.includes('xlsx')) return 'vendor-xlsx'
// element-plus 不再强制合并成一个 chunk:按需引入后由 rollup 按实际使用自然拆分,
// 否则仍会把全部组件塞进同一个首屏 chunk,按需引入等于没做。
if (id.includes('china-division')) return 'vendor-china-division'
if (id.includes('china-division')) {
// pcas 为省/市/区/街道四级数据(约 1.9MB),只在「镇/街道」下拉需要时动态 import,
// 必须单独成块,否则会和 pca(省市区)合并成 2MB 同步 chunk
if (id.includes('pcas')) return 'vendor-china-division-street'
return 'vendor-china-division'
}
if (
id.includes('/vue/') ||
id.includes('/vue-') ||