优化

src/modules/overseas-master-data/PROTOTYPE_MATRIX.md

@@ -2,16 +2,16 @@
 
 ## 自有业务准备核对（2026-10-20，主规则已确认）
 
-用户当前要求逐页处理，先看自有业务；HTTP 扩展由既有排车后端对话独立负责。本节仅记录原型初审及待确认项，不授权外配页面改造，也不表示正式页面、接口或菜单已实现。视觉沿当前 Admin 高密度规范，业务与操作承载依据用户提供的 `C:/Users/BY-OY/Documents/WXWork/1688854456873012/Cache/File/2026-10/悦/悦/新版.html` 及本轮截图。
+用户当前要求逐页处理，先看自有业务；HTTP 扩展由既有排车后端对话独立负责。本节记录原型与已确认规则的映射，不授权外配页面改造。自有与外配均为原排车装车后的车辆归属视图，不另建任务或履约流程；自有车增加运营细项，外配管理细度后续确认。视觉沿当前 Admin 高密度规范，业务与操作承载依据用户提供的 `C:/Users/BY-OY/Documents/WXWork/1688854456873012/Cache/File/2026-10/悦/悦/新版.html` 及本轮截图。
 
 | 页面 | 操作 | 原型证据 | 承载与字段 | 当前实现及待处理 |
 |---|---|---|---|---|
-| 自有业务列表 | 统计、筛选、查询/重置 | `page-vehicle-own-business`，8772行；`renderVehicleBusiness` 22794行、`resetVehicleBusiness` 22827行 | 独立页面；四项统计为今日排车、装车完成、派送中、派送完成；日期范围、排车单号/车牌/FBA仓、状态、仓库筛选 | 正式菜单与路由未注册；原型用内存数组，今日统计实际取筛选行数，默认日期写死，真实统计口径待业务冻结 |
-| 自有业务列表 | 任务明细 | 同页面表头及渲染函数 | 预约号、排车单号、车牌、司机、提货仓、目的仓、派送仓、油耗、托数、总价/单价、最晚/实际装车完成时间、预约/实际到达时间、状态；正式业务操作列按全局规则放第一列 | 原型动态改表头造成重复托数及仓库列错位，不作为正式字段定义；金额含义、分类和可见阶段尚未确认 |
+| 自有业务列表 | 统计、筛选、查询/重置 | `page-vehicle-own-business`，8772行；`renderVehicleBusiness` 22794行、`resetVehicleBusiness` 22827行 | 独立页面；四项统计为排车数、装车完成、派送中、派送完成；计划发车日期范围、排车单号/车牌/FBA仓、状态、仓库筛选 | 已注册源码菜单和列表/详情路由；统计跟随同一全部筛选结果，不用当前页行数；不保留原型写死日期。页面实现和环境验收分别核对 |
+| 自有业务列表 | 任务明细 | 同页面表头及渲染函数 | 预约号、排车单号、车牌、司机、提货仓、目的仓、派送仓、油耗、托数、总价/单价、最晚/实际装车完成时间、预约/实际到达时间、状态；正式业务操作列按全局规则放第一列 | 原型动态改表头造成重复托数及仓库列错位，不作为正式字段定义；按我们自己的车辆归类，装车完成后三阶段可见；整车总金额除实际物理托数得单价，同车多仓及预约行内展开 |
 | 自有业务 | 查看明细 | `page-vehicle-own-business-detail` 8779行；`openOwnBusinessDetail` 22836行 | 独立详情页及返回入口；任务与车辆信息、路线货物与凭证、操作记录三个页签 | 不是排车详情四页签；不能直接复用旧车次八页签替代；原型驾驶证、路线、GPS/ETA、时间线等含固定演示值，须逐项映射真实来源，缺失不得伪造 |
 | 自有业务 | 上传照片、填写实际迈数 | `modal-own-business-images` 8791行；最终生效的 `openOwnBusinessImages` 23082行覆盖22842行同名函数；`switchOwnBusinessImageTab` 23080行、`saveOwnBusinessMileage` 23083行 | 760px居中弹窗；装车完成、油耗图片两页签，逐框JPG/PNG；油耗页包含实际迈数；底部关闭 | 原型仅内存/FileReader保存，存在示例图片占位；真实文件归属、资料版本、保存语义及迈数单位需沿正式提供者核对，不能把关闭或上传文件本身当作确认装车 |
 
-用户已明确：按我们自己的车辆归类；装车完成后展示三个阶段；后台登记一次整车总金额，单价为总金额除实际物理托数；一张排车单一行，多仓及预约行内展开；实到时间、里程和油耗由后台补录，照片按原型上传。共同业务及三方写入边界唯一见工作区 `docs/海外仓业务/自有业务首版开发契约.md`，金额不擅自改称收入或成本。统计日期口径及新增补录操作的承载在原型中未完整定义，待总控补齐；不因原型已有演示值而自行新增业务事实。
+用户已明确：按我们自己的车辆归类；装车完成后展示三个阶段；后台登记一次整车总金额，单价为总金额除实际物理托数；一张排车单一行，多仓及预约行内展开；实到时间、里程和油耗由后台补录，照片按原型上传。计划发车日期作为查询口径，统计随筛选变化；新增“登记运营信息”居中弹窗，照片仍独立弹窗。共同业务及三方写入边界唯一见工作区 `docs/海外仓业务/自有业务首版开发契约.md`，金额不擅自改称收入或成本，不因原型演示值自行新增业务事实。当前源码和自动检查不代表真实页面已验收。
 
 ## 运输路线地图
 

src/modules/overseas-master-data/api/ownedBusiness.test.ts

@@ -0,0 +1,65 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { http } from '@/shared/api/http'
+import { getOwnedBusiness, listOwnedBusiness, listOwnedBusinessHistory, saveOwnedBusinessOperations, uploadOwnedBusinessPhoto, bindOwnedBusinessPhoto, getOwnedBusinessPhotoContent } from './ownedBusiness'
+import { ownedBusinessFixture } from '../components/OwnedBusinessFixtures'
+import type { OwnedBusinessPhoto, OwnedBusinessSave } from '../ownedBusinessTypes'
+
+vi.mock('@/shared/api/http', async importOriginal => {
+  const actual = await importOriginal<typeof import('@/shared/api/http')>()
+  return { ...actual, http: { get: vi.fn(), put: vi.fn(), post: vi.fn() }, unwrapApiResponse: (value: { data: unknown }) => value.data }
+})
+beforeEach(() => vi.clearAllMocks())
+const base = '/platform/v1/last-leg/fleet/owned-business'
+const photo: OwnedBusinessPhoto = { slot: 'FUEL_START', category: 'FUEL', fileId: '9007199254740993', fileName: 'fuel.png', contentType: 'image/png', sizeBytes: '10', uploadedAt: '2026-10-20T10:00:00Z', savedAt: null }
+describe('owned business HTTP contract', () => {
+  it('uses one list response for matched statistics and keeps physical count independent of cargo rows', async () => {
+    const detail = ownedBusinessFixture()
+    vi.mocked(http.get).mockResolvedValue({ data: { records: [detail.row], page: '1', size: '20', total: '41', summary: { dispatchCount: '41', afterLoadingCount: '40', deliveringCount: '1', deliveredCount: '0' } } })
+    const query = { page: 1, size: 20, plannedDepartureFrom: '2026-10-20T00:00:00Z', plannedDepartureTo: '2026-10-21T00:00:00Z', keyword: 'FBA-1' }
+    const value = await listOwnedBusiness(query)
+    expect(http.get).toHaveBeenCalledExactlyOnceWith(base, { params: query })
+    expect(value.summary.dispatchCount).toBe(41); expect(value.records).toHaveLength(1); expect(value.records[0]!.actualPalletCount).toBe(1)
+  })
+  it('encodes the dispatch business number and preserves auxiliary/main versions independently', async () => {
+    const detail = ownedBusinessFixture(); detail.row.recordVersion = '0'; detail.row.dispatchRecordVersion = '9007199254740993'
+    detail.row.dispatchNo = 'DS/1'; detail.dispatch.dispatchNo = 'DS/1'
+    vi.mocked(http.get).mockResolvedValue({ data: detail })
+    expect((await getOwnedBusiness('DS/1')).row.dispatchRecordVersion).toBe('9007199254740993')
+    expect(http.get).toHaveBeenCalledWith(`${base}/DS%2F1`, { params: undefined })
+    detail.dispatch.dispatchNo = 'another'; await expect(getOwnedBusiness('DS/1')).rejects.toThrow('不一致')
+  })
+  it('does not convert money text, calculate a client unit price or submit a dispatch version', async () => {
+    const body: OwnedBusinessSave = { recordVersion: '0', idempotencyKey: 'original-key', operations: { ...ownedBusinessFixture().row.operations, money: { currency: 'USD', amount: '9999999999999999.99' }, fuelConsumptionLitresPer100Km: '18.600' }, reason: null }
+    const detail = ownedBusinessFixture(); detail.row.operations.money = body.operations.money
+    vi.mocked(http.put).mockResolvedValue({ data: detail })
+    const saved = await saveOwnedBusinessOperations('DS-OWN-1', body)
+    expect(http.put).toHaveBeenCalledExactlyOnceWith(`${base}/DS-OWN-1/operations`, body)
+    expect(body.operations.money!.amount).toBe('9999999999999999.99'); expect('dispatchRecordVersion' in body).toBe(false)
+    expect(saved.row.operations.money!.amount).toBe('9999999999999999.99')
+  })
+  it('keeps upload and versioned file binding separate with the same prepared file identity', async () => {
+    vi.mocked(http.post).mockResolvedValue({ data: photo })
+    const file = new File(['image'], 'fuel.png', { type: 'image/png' })
+    await uploadOwnedBusinessPhoto('DS/1', 'FUEL_START', file, 'upload-key')
+    const [url, form] = vi.mocked(http.post).mock.calls[0]!
+    expect(url).toBe(`${base}/DS%2F1/photos/FUEL_START/uploads`); expect((form as FormData).get('file')).toBe(file); expect((form as FormData).get('idempotencyKey')).toBe('upload-key')
+    const detail = ownedBusinessFixture(); detail.row.dispatchNo = 'DS/1'; detail.dispatch.dispatchNo = 'DS/1'
+    vi.mocked(http.put).mockResolvedValue({ data: detail })
+    await bindOwnedBusinessPhoto('DS/1', 'FUEL_START', { recordVersion: '0', idempotencyKey: 'bind-key', fileId: photo.fileId })
+    expect(http.put).toHaveBeenCalledExactlyOnceWith(`${base}/DS%2F1/photos/FUEL_START`, { recordVersion: '0', idempotencyKey: 'bind-key', fileId: photo.fileId })
+  })
+  it('retains the two history streams and reads historical files only at their explicit revision', async () => {
+    vi.mocked(http.get).mockResolvedValue({ data: { records: [{ eventSource: 'DISPATCH', recordVersion: null, dispatchRecordVersion: '9', operations: null, photos: [] }, { eventSource: 'OPERATIONS', recordVersion: '1', dispatchRecordVersion: null, operations: ownedBusinessFixture().row.operations, photos: [] }], page: '1', size: '20', total: '2' } })
+    const value = await listOwnedBusinessHistory('DS/1', 1, 20)
+    expect(value.records.map(record => [record.eventSource, record.recordVersion, record.dispatchRecordVersion])).toEqual([['DISPATCH',null,'9'],['OPERATIONS','1',null]])
+    vi.mocked(http.get).mockResolvedValue(new Blob(['image'], { type: 'image/png' }))
+    await getOwnedBusinessPhotoContent('DS/1', photo, '1')
+    expect(http.get).toHaveBeenLastCalledWith(`${base}/DS%2F1/photos/FUEL_START/files/${photo.fileId}/content`, { responseType: 'blob', params: { revisionVersion: '1' } })
+  })
+  it('never renders JSON errors or empty bytes as a photo', async () => {
+    vi.mocked(http.get).mockResolvedValue(new Blob([JSON.stringify({ code: 'A0403', message: '拒绝读取', requestId: 'request', traceId: 'trace' })], { type: 'application/json' }))
+    await expect(getOwnedBusinessPhotoContent('DS-OWN-1', photo)).rejects.toMatchObject({ code: 'A0403', requestId: 'request', traceId: 'trace' })
+    vi.mocked(http.get).mockResolvedValue(new Blob([], { type: 'image/png' })); await expect(getOwnedBusinessPhotoContent('DS-OWN-1', photo)).rejects.toThrow('为空')
+    await expect(uploadOwnedBusinessPhoto('DS-OWN-1','FUEL_START',new File(['text'],'bad.txt',{type:'text/plain'}),'key')).rejects.toThrow('JPG')
+  })
+})

src/modules/overseas-master-data/api/ownedBusiness.ts

@@ -0,0 +1,66 @@
+import axios from 'axios'
+import { http, unwrapApiResponse, ApiResponseError, type ApiEnvelope } from '@/shared/api/http'
+import { ownedBusinessDecimal, ownedBusinessVersion, type OwnedBusinessOperations, type OwnedBusinessRow, type OwnedBusinessDetail, type OwnedBusinessList, type OwnedBusinessQuery, type OwnedBusinessSave, type OwnedBusinessBind, type OwnedBusinessPhoto, type OwnedBusinessPhotoSlot, type OwnedBusinessCommand, type OwnedBusinessHistory, type OwnedBusinessPage } from '../ownedBusinessTypes'
+
+const base = '/platform/v1/last-leg/fleet/owned-business'
+const path = (no: string) => `${base}/${encodeURIComponent(no)}`
+async function get<T>(url: string, params?: object): Promise<T> { return unwrapApiResponse(await http.get<ApiEnvelope<T>, ApiEnvelope<T>>(url, { params })) }
+function count(value: unknown): number { const text = ownedBusinessVersion(value); const result = Number(text); if (!Number.isSafeInteger(result)) throw new Error('运营记录数量超出精确范围'); return result }
+function decimal(value: string | null, scale: number, precision: number): string | null {
+  if (value == null) return null
+  if (typeof value !== 'string' || ownedBusinessDecimal(value, scale, precision) !== value) throw new Error('运营金额或测量必须使用精确十进制字符串')
+  return value
+}
+function operations(value: OwnedBusinessOperations): OwnedBusinessOperations {
+  if (value.money && !['CNY','USD'].includes(value.money.currency)) throw new Error('运营金额币种无效')
+  return { ...value, money: value.money ? { ...value.money, amount: decimal(value.money.amount, 2, 18)! } : null, actualDistanceMiles: decimal(value.actualDistanceMiles,3,12), fuelConsumptionLitresPer100Km: decimal(value.fuelConsumptionLitresPer100Km,3,12) }
+}
+function row(value: OwnedBusinessRow): OwnedBusinessRow {
+  if (!value.dispatchNo || !['AFTER_LOADING','DELIVERING','DELIVERED'].includes(value.stage) || value.vehicle?.ownership !== 'OWNED') throw new Error('自有排车来源或阶段不完整，请重新读取')
+  return { ...value, operations: operations(value.operations), unitPrice: decimal(value.unitPrice,2,18), recordVersion: ownedBusinessVersion(value.recordVersion), dispatchRecordVersion: ownedBusinessVersion(value.dispatchRecordVersion), actualPalletCount: value.actualPalletCount == null ? null : count(value.actualPalletCount), photoSummary: { loadingCount: count(value.photoSummary.loadingCount), fuelCount: count(value.photoSummary.fuelCount) } }
+}
+function detail(value: OwnedBusinessDetail): OwnedBusinessDetail { if (value.row.dispatchNo !== value.dispatch.dispatchNo) throw new Error('运营资料与原排车单不一致'); return { ...value, row: row(value.row) } }
+function command(value: OwnedBusinessCommand): OwnedBusinessCommand { return { ...value, recordVersion: value.recordVersion == null ? null : ownedBusinessVersion(value.recordVersion) } }
+export async function listOwnedBusiness(query: OwnedBusinessQuery): Promise<OwnedBusinessList> {
+  const value = await get<OwnedBusinessList>(base, query)
+  return { ...value, records: value.records.map(row), page: count(value.page), size: count(value.size), total: count(value.total), summary: { dispatchCount: count(value.summary.dispatchCount), afterLoadingCount: count(value.summary.afterLoadingCount), deliveringCount: count(value.summary.deliveringCount), deliveredCount: count(value.summary.deliveredCount) } }
+}
+export async function getOwnedBusiness(no: string) { const value = detail(await get<OwnedBusinessDetail>(path(no))); if (value.row.dispatchNo !== no) throw new Error('运营资料与当前排车业务号不一致'); return value }
+export async function listOwnedBusinessHistory(no: string, page: number, size: number): Promise<OwnedBusinessPage<OwnedBusinessHistory>> {
+  const value = await get<OwnedBusinessPage<OwnedBusinessHistory>>(`${path(no)}/history`, { page, size })
+  return { ...value, records: value.records.map(record => ({ ...record, operations: record.operations ? operations(record.operations) : null, recordVersion: record.recordVersion == null ? null : ownedBusinessVersion(record.recordVersion), dispatchRecordVersion: record.dispatchRecordVersion == null ? null : ownedBusinessVersion(record.dispatchRecordVersion) })), page: count(value.page), size: count(value.size), total: count(value.total) }
+}
+export const getOwnedBusinessCommand = (no: string, key: string) => get<OwnedBusinessCommand>(`${path(no)}/commands/${encodeURIComponent(key)}`).then(command)
+export async function saveOwnedBusinessOperations(no: string, body: OwnedBusinessSave) {
+  ownedBusinessVersion(body.recordVersion)
+  const value = detail(unwrapApiResponse(await http.put<ApiEnvelope<OwnedBusinessDetail>, ApiEnvelope<OwnedBusinessDetail>>(`${path(no)}/operations`, body)))
+  if (value.row.dispatchNo !== no) throw new Error('运营保存结果与原排车单不一致')
+  return value
+}
+export async function uploadOwnedBusinessPhoto(no: string, slot: OwnedBusinessPhotoSlot, file: File, key: string) {
+  if (!['image/jpeg','image/png'].includes(file.type) || file.size <= 0) throw new Error('请选择有效的JPG或PNG图片')
+  const form = new FormData(); form.append('file', file); form.append('idempotencyKey', key)
+  const value = unwrapApiResponse(await http.post<ApiEnvelope<OwnedBusinessPhoto>, ApiEnvelope<OwnedBusinessPhoto>>(`${path(no)}/photos/${slot}/uploads`, form))
+  if (value.slot !== slot || !value.fileId) throw new Error('上传文件与原照片分类不一致')
+  return value
+}
+export async function bindOwnedBusinessPhoto(no: string, slot: OwnedBusinessPhotoSlot, body: OwnedBusinessBind) {
+  ownedBusinessVersion(body.recordVersion)
+  const value = detail(unwrapApiResponse(await http.put<ApiEnvelope<OwnedBusinessDetail>, ApiEnvelope<OwnedBusinessDetail>>(`${path(no)}/photos/${slot}`, body)))
+  if (value.row.dispatchNo !== no) throw new Error('照片绑定结果与原排车单不一致')
+  return value
+}
+async function downloadError(payload: unknown, status: number) {
+  let value = payload
+  if (payload instanceof Blob && payload.type.includes('json')) { try { value = JSON.parse(await payload.text()) as unknown } catch { throw new Error('图片接口返回了无法识别的错误') } }
+  if (value && typeof value === 'object' && 'code' in value) { const error = value as ApiEnvelope<unknown>; throw new ApiResponseError(error.message || '图片读取失败', error.code, status, error.data, error.requestId, error.traceId) }
+}
+export async function getOwnedBusinessPhotoContent(no: string, photo: OwnedBusinessPhoto, revisionVersion?: string): Promise<Blob> {
+  if (revisionVersion != null && BigInt(ownedBusinessVersion(revisionVersion)) < 1n) throw new Error('历史图片版本必须大于零')
+  try {
+    const blob = await http.get<Blob, Blob>(`${path(no)}/photos/${photo.slot}/files/${encodeURIComponent(photo.fileId)}/content`, { responseType: 'blob', params: revisionVersion == null ? undefined : { revisionVersion: ownedBusinessVersion(revisionVersion) } })
+    await downloadError(blob, 200)
+    if (!(blob instanceof Blob) || !['image/jpeg','image/png'].includes(blob.type) || !blob.size) throw new Error('图片内容为空或格式无效')
+    return blob
+  } catch (cause) { if (axios.isAxiosError(cause)) await downloadError(cause.response?.data, cause.response?.status || 0); throw cause }
+}

src/modules/overseas-master-data/components/CapacityInquiryDialog.vue

@@ -113,12 +113,12 @@ onBeforeUnmount(() => { generation++; customerSequence++; quoteSequence++; clear
       <strong>本目的站可接余位</strong>
       <p v-if="selectedCapacity">{{ selectedCapacity.palletSpaces }} 托位 · {{ selectedCapacity.weightKg }} kg · {{ selectedCapacity.volumeCbm }} m³</p>
       <p v-else>待调度核对，当前没有可靠的可接余位。</p>
-      
+
     </section>
     <p v-if="pending" role="status">上次提交结果尚未确定，请保留原内容重试或核对。</p>
     <p v-if="offer">{{ offer.offerNo }} · {{ offer.warehouseName }} · {{ offer.blockReason || '询价不占位，调度确认承运后占位。' }}</p>
     <section v-if="inquiry" aria-label="本票处理进度"><strong>{{ inquiry.customerName }} · {{ inquiry.destinationLabel }}</strong><p>车次：{{ inquiry.tripNo }} · 登记：{{ inquiry.bookingNo }}</p><strong>{{ inquiry.progress.label }} · {{ inquiry.progress.reservation }}</strong><p>下一步负责人：{{ inquiry.progress.owner }} · {{ inquiry.progress.message }}</p></section>
-    
+
     <p v-if="!inquiry">业务类型：{{ form.businessType === 'US_TRUCK' ? '本土卡车' : '本土散板' }}，可在“确认承运前待补资料”中调整。</p>
     <p v-if="offer">计划发车：{{ offerTime(offer.plannedDepartureAt) }} · 最晚送仓：{{ offerTime(offer.cutoffAt) }}</p>
     <p v-if="inquiry?.actions.blockReason">{{ inquiry.actions.blockReason }}</p>

src/modules/overseas-master-data/components/CapacityOfferSettingsDialog.vue

@@ -122,7 +122,7 @@ onBeforeUnmount(() => { generation++ })
   <p>{{ trip.tripNo }} · {{ offer ? `${offer.offerNo} · ${offerStatusLabels[offer.status]}` : '尚未建立发布' }}</p><p v-if="offer?.blockReason && offer.status !== 'DRAFT'">{{ offer.blockReason }}</p><p v-if="pending">上次结果尚未确定，原请求已保留，请重试核对。</p>
   <template v-if="loaded && open && (!offer || offer.actions.canEdit)">
     <h3>本车货物与余位<InlineHelp title="容量发布说明"><p>卸货站已按货物匹配。核对下方数据，确认发布时一并保存容量；多个目的地的先后顺序请在车次计划中确认。</p></InlineHelp></h3>
-    
+
     <el-button v-if="canPlan && planner?.destinationIssue" :disabled="busy || !!pending" @click="matchExistingStops">按货物补齐卸货站</el-button>
     <TripLoadingPanel ref="planner" :trip="currentTrip" :editable="canPlan && !busy && !pending" planning embedded @changed="planChanged" />
   </template>

src/modules/overseas-master-data/components/FleetQuoteEditor.vue

@@ -80,7 +80,7 @@ async function save() {
       </tbody></table>
     </section>
   </el-form>
-  
+
   <template #footer="{close}"><div class="density-actions density-actions--footer"><el-button :disabled="saving" @click="close">关闭</el-button><el-button v-if="!readonly" type="primary" :loading="saving" @click="save">{{ uncertain ? '按原请求重试' : '保存报价' }}</el-button></div></template>
 </AppDialog></template>
 <style scoped>

src/modules/overseas-master-data/components/OwnedBusinessCommandRecovery.test.ts

@@ -0,0 +1,72 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { ApiResponseError } from '@/shared/api/http'
+import * as api from '../api/ownedBusiness'
+import { ownedBusinessFixture, ownedBusinessCommandFixture } from './OwnedBusinessFixtures'
+import { acceptOwnedBusinessCommand, newOwnedBusinessPending, persistOwnedBusinessPending, restoreOwnedBusinessPending, recoverOwnedBusinessCommand, ownedBusinessPendingKey } from './OwnedBusinessCommandRecovery'
+import type { OwnedBusinessPhoto, OwnedBusinessSave } from '../ownedBusinessTypes'
+
+beforeEach(() => sessionStorage.clear())
+const no = 'DS-OWN-1'
+function operation() : OwnedBusinessSave { return { recordVersion: '0', idempotencyKey: 'original-key', operations: { ...ownedBusinessFixture().row.operations, money: { currency: 'USD', amount: '9999999999999999.99' } }, reason: null } }
+function client() {
+  const current = ownedBusinessFixture(); current.row.recordVersion = '1'
+  const photo: OwnedBusinessPhoto = { slot:'FUEL_START',category:'FUEL',fileId:'9007199254740993',fileName:'fuel.png',contentType:'image/png',sizeBytes:'5',uploadedAt:'2026-10-20T10:00:00Z',savedAt:null }
+  return { ...api, getOwnedBusiness: vi.fn(async () => current), getOwnedBusinessCommand: vi.fn(async () => ownedBusinessCommandFixture()), saveOwnedBusinessOperations: vi.fn(async () => current), bindOwnedBusinessPhoto: vi.fn(async () => current), uploadOwnedBusinessPhoto: vi.fn(async () => photo) }
+}
+describe('owned business exact command recovery', () => {
+  it('persists the complete original payload, actor and zero auxiliary version', () => {
+    const pending = newOwnedBusinessPending('actor', no, 'SAVE_OPERATIONS', operation())
+    persistOwnedBusinessPending('actor', no, 'operations', pending)
+    expect(restoreOwnedBusinessPending('actor', no, 'operations')).toEqual(pending)
+    expect(restoreOwnedBusinessPending('another', no, 'operations')).toBeNull()
+    const raw = JSON.parse(sessionStorage.getItem(ownedBusinessPendingKey('actor',no,'operations'))!)
+    raw.actor = 'another'; sessionStorage.setItem(ownedBusinessPendingKey('actor',no,'operations'),JSON.stringify(raw))
+    expect(() => restoreOwnedBusinessPending('actor',no,'operations')).toThrow('损坏')
+  })
+  it('looks up an unknown write first and retries only the unchanged original body on explicit not-found', async () => {
+    const pending = newOwnedBusinessPending('actor', no, 'SAVE_OPERATIONS', operation()); pending.attempted = true
+    const service = client(), persist = vi.fn()
+    service.getOwnedBusinessCommand.mockRejectedValue(new ApiResponseError('not found','A0404',404))
+    await recoverOwnedBusinessCommand(pending,persist,() => {},service)
+    expect(service.getOwnedBusinessCommand).toHaveBeenCalledWith(no,'original-key')
+    expect(service.saveOwnedBusinessOperations).toHaveBeenCalledExactlyOnceWith(no,operation())
+    expect(pending.body).toEqual(operation()); expect(pending.body?.recordVersion).toBe('0')
+  })
+  it('retains a proven success through failed fresh reads without writing it a second time', async () => {
+    const pending = newOwnedBusinessPending('actor', no, 'SAVE_OPERATIONS', operation()), service = client()
+    service.getOwnedBusiness.mockRejectedValueOnce(new Error('read offline'))
+    await expect(recoverOwnedBusinessCommand(pending,() => {},() => {},service)).rejects.toThrow('read offline')
+    expect(pending.confirmed?.recordVersion).toBe('1')
+    await recoverOwnedBusinessCommand(pending,() => {},() => {},service)
+    expect(service.saveOwnedBusinessOperations).toHaveBeenCalledTimes(1); expect(service.getOwnedBusinessCommand).not.toHaveBeenCalled()
+  })
+  it('never retransmits a file for an unknown upload, including command not-found', async () => {
+    const pending = newOwnedBusinessPending('actor',no,'UPLOAD_PHOTO',null,'FUEL_START'); pending.attempted = true
+    const service = client(); service.getOwnedBusinessCommand.mockRejectedValue(new ApiResponseError('not found','A0404',404))
+    await expect(recoverOwnedBusinessCommand(pending,() => {},() => {},service)).rejects.toThrow('禁止重复上传')
+    expect(service.uploadOwnedBusinessPhoto).not.toHaveBeenCalled(); expect(service.bindOwnedBusinessPhoto).not.toHaveBeenCalled(); expect(pending.key).toBeTruthy()
+  })
+  it('keeps the prepared file and exact binding key through unknown binding and later replacement', async () => {
+    const photo: OwnedBusinessPhoto = { slot:'FUEL_START',category:'FUEL',fileId:'9007199254740993',fileName:'fuel.png',contentType:'image/png',sizeBytes:'5',uploadedAt:'2026-10-20T10:00:00Z',savedAt:'2026-10-20T10:01:00Z' }
+    const pending = newOwnedBusinessPending('actor',no,'BIND_PHOTO',{recordVersion:'0',idempotencyKey:'bind-key',fileId:photo.fileId},photo.slot)
+    pending.attempted = true
+    const service = client(); const bound = ownedBusinessFixture(); bound.row.recordVersion='1'; bound.photos=[photo]
+    const original = ownedBusinessCommandFixture({action:'BIND_PHOTO',idempotencyKey:'bind-key',result:bound})
+    service.getOwnedBusinessCommand.mockResolvedValue(original)
+    const current = ownedBusinessFixture();current.row.recordVersion='2';current.photos=[{...photo,fileId:'9007199254740994'}]
+    service.getOwnedBusiness.mockResolvedValue(current)
+    const result = await recoverOwnedBusinessCommand(pending,() => {},() => {},service)
+    expect(result.detail?.photos[0]?.fileId).toBe('9007199254740994')
+    expect(pending.body).toEqual({recordVersion:'0',idempotencyKey:'bind-key',fileId:photo.fileId})
+    expect(service.uploadOwnedBusinessPhoto).not.toHaveBeenCalled();expect(service.bindOwnedBusinessPhoto).not.toHaveBeenCalled()
+  })
+  it('refuses wrong command identities, stale reads, definite rejection retries and scope changes', async () => {
+    const pending = newOwnedBusinessPending('actor',no,'SAVE_OPERATIONS',operation()), service=client()
+    expect(() => acceptOwnedBusinessCommand(pending,ownedBusinessCommandFixture({dispatchNo:'another'}))).toThrow('不一致')
+    pending.command=ownedBusinessCommandFixture({recordVersion:'9007199254740993'})
+    await expect(recoverOwnedBusinessCommand(pending,() => {},() => {},service)).rejects.toThrow('早于')
+    pending.rejected=true;await expect(recoverOwnedBusinessCommand(pending,() => {},() => {},service)).rejects.toThrow('明确拒绝')
+    pending.rejected=false;await expect(recoverOwnedBusinessCommand(pending,() => {},() => {throw new Error('scope changed')},service)).rejects.toThrow('scope changed')
+    expect(service.saveOwnedBusinessOperations).not.toHaveBeenCalled()
+  })
+})

src/modules/overseas-master-data/components/OwnedBusinessCommandRecovery.ts

@@ -0,0 +1,89 @@
+import { ApiResponseError } from '@/shared/api/http'
+import * as api from '../api/ownedBusiness'
+import { ownedBusinessPhotoRoles, ownedBusinessVersion, type OwnedBusinessAction, type OwnedBusinessBind, type OwnedBusinessCommand, type OwnedBusinessDetail, type OwnedBusinessPhoto, type OwnedBusinessPhotoSlot, type OwnedBusinessSave } from '../ownedBusinessTypes'
+
+export interface OwnedBusinessPending {
+  actor: string; dispatchNo: string; action: OwnedBusinessAction; key: string; slot?: OwnedBusinessPhotoSlot
+  body: OwnedBusinessSave | OwnedBusinessBind | null; attempted: boolean; command: OwnedBusinessCommand | null; confirmed: { recordVersion: string | null; result: OwnedBusinessDetail | OwnedBusinessPhoto } | null; rejected: boolean
+}
+export const ownedBusinessPendingKey = (actor: string, no: string, area: string) => `owned-business:${encodeURIComponent(actor)}:${encodeURIComponent(no)}:${area}`
+export function restoreOwnedBusinessPending(actor: string, no: string, area: string): OwnedBusinessPending | null {
+  const raw = sessionStorage.getItem(ownedBusinessPendingKey(actor, no, area))
+  if (!raw) return null
+  const pending = JSON.parse(raw) as OwnedBusinessPending
+  if (pending.actor !== actor || pending.dispatchNo !== no || !pending.key || !['SAVE_OPERATIONS','UPLOAD_PHOTO','BIND_PHOTO'].includes(pending.action)) throw new Error('原运营请求记录损坏，请保留现场核对')
+  if (pending.action !== 'SAVE_OPERATIONS' && !ownedBusinessPhotoRoles.some(role => role.slot === pending.slot) || pending.action !== 'UPLOAD_PHOTO' && (!pending.body || pending.body.idempotencyKey !== pending.key)) throw new Error('原运营请求内容不完整，请保留现场核对')
+  return pending
+}
+export function persistOwnedBusinessPending(actor: string, no: string, area: string, pending: OwnedBusinessPending | null) {
+  if (!actor || !no || pending && (pending.actor !== actor || pending.dispatchNo !== no)) throw new Error('运营请求身份已变化')
+  const key = ownedBusinessPendingKey(actor, no, area)
+  if (pending) sessionStorage.setItem(key, JSON.stringify(pending)); else sessionStorage.removeItem(key)
+}
+export function newOwnedBusinessPending(actor: string, no: string, action: OwnedBusinessAction, body: OwnedBusinessPending['body'], slot?: OwnedBusinessPhotoSlot): OwnedBusinessPending {
+  if (!actor || !no) throw new Error('当前运营作业身份缺失')
+  const key = body?.idempotencyKey || crypto.randomUUID()
+  return { actor, dispatchNo: no, action, key, slot, body: body ? structuredClone(body) : null, attempted: false, command: null, confirmed: null, rejected: false }
+}
+export function acceptOwnedBusinessResult(pending: OwnedBusinessPending, result: OwnedBusinessDetail | OwnedBusinessPhoto) {
+  if (pending.action === 'UPLOAD_PHOTO') {
+    if (!('fileId' in result) || result.slot !== pending.slot || typeof result.fileId !== 'string' || !/^[1-9]\d*$/.test(result.fileId) || !['image/jpeg','image/png'].includes(result.contentType)) throw new Error('原上传尚未返回本分类的真实文件')
+    pending.confirmed = { recordVersion: null, result }
+  } else {
+    if (!('row' in result) || result.row.dispatchNo !== pending.dispatchNo) throw new Error('运营保存结果与原排车单不一致')
+    pending.confirmed = { recordVersion: ownedBusinessVersion(result.row.recordVersion), result }
+  }
+}
+export function acceptOwnedBusinessCommand(pending: OwnedBusinessPending, command: OwnedBusinessCommand) {
+  if (command.dispatchNo !== pending.dispatchNo || command.action !== pending.action || command.idempotencyKey !== pending.key) throw new Error('返回结果与原运营请求不一致，请保留原请求核对')
+  pending.command = command
+  if (command.state === 'REJECTED') pending.rejected = true
+  if (command.state !== 'SUCCEEDED') throw new Error(command.state === 'REJECTED' ? '原请求已明确拒绝，请核对原因后重新登记' : '原请求结果尚未确定，请保留原请求继续核对')
+  if (!command.result) throw new Error('原运营命令的成功结果不完整，请继续核对')
+  acceptOwnedBusinessResult(pending, command.result)
+  if (pending.action !== 'UPLOAD_PHOTO' && (command.recordVersion == null || command.recordVersion !== pending.confirmed!.recordVersion)) throw new Error('原运营命令版本与结果不一致')
+}
+export async function recoverOwnedBusinessCommand(pending: OwnedBusinessPending, persist: () => void, ensureScope: () => void, client = api): Promise<{ detail?: OwnedBusinessDetail; photo?: OwnedBusinessPhoto }> {
+  ensureScope()
+  if (pending.rejected) throw new Error('原请求已明确拒绝，请先按明确拒绝结果重新核对')
+  if (pending.command?.state === 'SUCCEEDED') acceptOwnedBusinessCommand(pending, pending.command)
+  const previous = pending.attempted
+  if (!pending.confirmed) {
+    let original: OwnedBusinessCommand | null = null
+    if (previous) {
+      try { original = await client.getOwnedBusinessCommand(pending.dispatchNo, pending.key) }
+      catch (cause) { if (!(cause instanceof ApiResponseError) || !['404','A0404','HTTP_404'].includes(cause.code)) throw cause }
+      ensureScope()
+    }
+    if (original) { try { acceptOwnedBusinessCommand(pending, original) } finally { persist() } }
+    else {
+      if (pending.action === 'UPLOAD_PHOTO') throw new Error('图片上传结果未知，禁止重复上传；请继续核对原上传请求')
+      pending.attempted = true; persist()
+      try {
+        const result = pending.action === 'SAVE_OPERATIONS'
+          ? await client.saveOwnedBusinessOperations(pending.dispatchNo, pending.body as OwnedBusinessSave)
+          : await client.bindOwnedBusinessPhoto(pending.dispatchNo, pending.slot!, pending.body as OwnedBusinessBind)
+        ensureScope(); acceptOwnedBusinessResult(pending, result); persist()
+      } catch (cause) {
+        ensureScope()
+        if (!previous && cause instanceof ApiResponseError && ['A0400','A0403','A0404','A0409','400','403','404','409','422'].includes(cause.code)) { pending.rejected = true; persist() }
+        throw cause
+      }
+    }
+  }
+  const confirmed = pending.confirmed!
+  if (pending.action === 'UPLOAD_PHOTO') {
+    const photo = confirmed.result as OwnedBusinessPhoto | null
+    if (!photo || photo.slot !== pending.slot || typeof photo.fileId !== 'string' || !/^[1-9]\d*$/.test(photo.fileId) || !['image/jpeg','image/png'].includes(photo.contentType)) throw new Error('原上传尚未返回本分类的真实文件')
+    return { photo }
+  }
+  const current = await client.getOwnedBusiness(pending.dispatchNo); ensureScope()
+  if (current.row.dispatchNo !== pending.dispatchNo || confirmed.recordVersion == null || BigInt(ownedBusinessVersion(current.row.recordVersion)) < BigInt(ownedBusinessVersion(confirmed.recordVersion))) throw new Error('当前运营版本早于原操作结果，请继续核对')
+  if (pending.action === 'BIND_PHOTO') {
+    const matches = (photo: OwnedBusinessPhoto) => photo.slot === pending.slot && photo.fileId === (pending.body as OwnedBusinessBind).fileId && Boolean(photo.savedAt)
+    const original = confirmed.result
+    const originalPhotos = original && 'row' in original ? original.photos : original && 'fileId' in original ? [original] : []
+    if (!current.photos.some(matches) && !originalPhotos.some(matches)) throw new Error('图片绑定结果尚未确认，请保留原文件和请求')
+  }
+  return { detail: current }
+}

src/modules/overseas-master-data/components/OwnedBusinessDetailLayout.vue

@@ -0,0 +1,36 @@
+<script setup lang="ts">
+import '@/styles/adminDensity.css'
+import AdminPage from '@/shared/components/AdminPage.vue'
+import DetailPageLayout from '@/shared/components/DetailPageLayout.vue'
+
+defineProps<{ dispatchNo?: string; statusText?: string; loading?: boolean }>()
+const activeTab = defineModel<'task' | 'route' | 'history'>('activeTab', { default: 'task' })
+const emit = defineEmits<{ back: [] }>()
+</script>
+
+<template>
+  <AdminPage class="admin-density" spacing="compact">
+    <DetailPageLayout aria-label="自有业务详情">
+      <template #header>
+        <div class="owned-business-detail-heading">
+          <div><strong>自有业务</strong><span class="owned-business-reference">{{ dispatchNo || '—' }}</span><span v-if="statusText">{{ statusText }}</span></div>
+          <div class="density-actions"><slot name="actions" /><el-button class="density-action" @click="emit('back')">返回自有业务</el-button></div>
+        </div>
+      </template>
+      <slot name="state" />
+      <div v-loading="loading" :aria-busy="loading">
+        <el-tabs v-model="activeTab" class="density-element-tabs density-contained-tabs">
+          <el-tab-pane name="task" label="任务与车辆信息"><slot v-if="activeTab === 'task'" name="task" /></el-tab-pane>
+          <el-tab-pane name="route" label="路线货物与凭证"><slot v-if="activeTab === 'route'" name="route" /></el-tab-pane>
+          <el-tab-pane name="history" label="操作记录"><slot v-if="activeTab === 'history'" name="history" /></el-tab-pane>
+        </el-tabs>
+      </div>
+    </DetailPageLayout>
+  </AdminPage>
+</template>
+
+<style scoped>
+.owned-business-detail-heading { display: flex; align-items: center; justify-content: space-between; gap: var(--admin-space-4); }
+.owned-business-detail-heading > div { display: flex; min-width: 0; align-items: center; flex-wrap: wrap; gap: var(--admin-space-4); }
+.owned-business-reference { overflow-wrap: anywhere; }
+</style>

src/modules/overseas-master-data/components/OwnedBusinessFixtures.ts

@@ -0,0 +1,20 @@
+import type { OwnedBusinessCommand, OwnedBusinessDetail } from '../ownedBusinessTypes'
+
+export function ownedBusinessFixture(): OwnedBusinessDetail {
+  const review = { status: 'APPROVED' as const, reason: null, reviewerId: null, reviewedAt: '2026-10-20T10:00:00Z', reviewRound: '1', basisHash: null, invalidatedReason: null }
+  return {
+    row: {
+      dispatchNo: 'DS-OWN-1', stage: 'AFTER_LOADING', plannedDepartureAt: '2026-10-20T10:00:00Z', loadingCompletedAt: '2026-10-20T09:00:00Z', departedAt: null, deliveryCompletedAt: null,
+      origin: { warehouseId: '1', warehouseCode: 'WH-1', warehouseName: '起运仓' }, vehicle: { vehicleId: '2', plate: 'OWN-1', ownership: 'OWNED' }, driver: { name: null, phone: null },
+      destinations: [{ destinationKey: 'destination-1', warehouseCode: 'FBA-1', warehouseName: '目的仓', address: null, appointments: [{ appointmentNo: 'AP-1', confirmationNo: null, scheduledAt: null, allocatedPackages: '2' }], actualArrivedAt: null }],
+      actualPalletCount: 1, operations: { money: null, actualDistanceMiles: null, fuelConsumptionLitresPer100Km: null, arrivals: [{ destinationKey: 'destination-1', actualArrivedAt: null }] }, unitPrice: null, recordVersion: '0', dispatchRecordVersion: '8',
+      photoSummary: { loadingCount: 0, fuelCount: 0 }, actions: { edit: { allowed: true, blockReason: null }, upload: { allowed: true, blockReason: null } }, sourceIssues: [],
+    },
+    dispatch: { dispatchNo: 'DS-OWN-1', stage: 'AFTER_LOADING', status: 'ACTIVE', recordVersion: '8', reviewState: 'APPROVED', reviews: { dispatchReview: { ...review }, loadingReview: { ...review } }, counts: { itemCount: 2, palletCount: 1, packageCount: 2, pickedPackageCount: 2, shippedPackageCount: 0 }, pickingReconciled: true, actions: {}, vehicleInfo: { vehicle: null, driver: null }, dispatchInfo: { route: null, plannedDepartureAt: '2026-10-20T10:00:00Z', departedAt: null, estimatedArrivalAt: null, fbaAppointments: [], appointmentBatches: [] }, documents: { dispatchNo: 'DS-OWN-1', outbounds: [], deliveries: [], createdAt: '2026-10-20T08:00:00Z', updatedAt: '2026-10-20T09:00:00Z', remark: null }, orderDetails: [] },
+    cargo: ['A','B'].map(customer => ({ sourceKey: `source-${customer}`, customerId: customer, customerName: `客户${customer}`, orderNo: `ORDER-${customer}`, inboundCode: `IN-${customer}`, palletNo: 'ONE-PHYSICAL-PALLET', destinationKey: 'destination-1', packages: '1' })), photos: [],
+  }
+}
+export function ownedBusinessCommandFixture(overrides: Partial<OwnedBusinessCommand> = {}): OwnedBusinessCommand {
+  const detail = ownedBusinessFixture(); detail.row.recordVersion = overrides.recordVersion ?? '1'
+  return { dispatchNo: 'DS-OWN-1', action: 'SAVE_OPERATIONS', idempotencyKey: 'original-key', state: 'SUCCEEDED', recordVersion: '1', replayed: false, result: detail, errorCode: null, retryAllowed: false, ...overrides }
+}

src/modules/overseas-master-data/components/OwnedBusinessLayouts.test.ts

@@ -0,0 +1,48 @@
+import { defineComponent } from 'vue'
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import OwnedBusinessDetailLayout from './OwnedBusinessDetailLayout.vue'
+import OwnedBusinessPhotosDialog from './OwnedBusinessPhotosDialog.vue'
+import OwnedBusinessOperationsDialog from './OwnedBusinessOperationsDialog.vue'
+
+const Surface = defineComponent({ template: '<section><slot name="header" /><slot /></section>' })
+const Tabs = defineComponent({ props: ['modelValue'], emits: ['update:modelValue'], template: '<div><slot /></div>' })
+const Pane = defineComponent({ props: ['name', 'label'], template: '<article><slot /></article>' })
+const Dialog = defineComponent({ props: ['width', 'showConfirm', 'beforeClose'], template: '<div><slot /></div>' })
+const global = { stubs: { AdminPage: Surface, DetailPageLayout: Surface, AppDialog: Dialog, ElTabs: Tabs, ElTabPane: Pane, ElButton: Surface }, directives: { loading: () => {} } }
+
+describe('OwnedBusiness presentation boundaries', () => {
+  it('mounts only the selected one of the three independent detail regions', async () => {
+    const wrapper = mount(OwnedBusinessDetailLayout, { global, props: { dispatchNo: 'DS-OWN-1' }, slots: { task: '<p>task-facts</p>', route: '<p>route-facts</p>', history: '<p>history-facts</p>' } })
+    expect(wrapper.findAllComponents(Pane).map(pane => pane.props('label'))).toEqual(['任务与车辆信息', '路线货物与凭证', '操作记录'])
+    expect(wrapper.text()).toContain('task-facts'); expect(wrapper.text()).not.toContain('history-facts')
+    wrapper.findComponent(Tabs).vm.$emit('update:modelValue', 'history'); await wrapper.vm.$nextTick()
+    expect(wrapper.text()).toContain('history-facts'); expect(wrapper.text()).not.toContain('task-facts')
+  })
+
+  it('preserves seven real prototype photo roles without demo images or uploaded claims', () => {
+    const wrapper = mount(OwnedBusinessPhotosDialog, { global, props: { modelValue: true } })
+    expect(wrapper.findComponent(Dialog).props('width')).toBe('760px')
+    expect(wrapper.findComponent(Dialog).props('showConfirm')).toBe(false)
+    expect(wrapper.findAll('section[aria-label]').map(section => section.attributes('aria-label'))).toEqual(['装车现场', '装车清单', '出车前检查', '驾驶证附件', '签收凭证', '起始油耗表盘', '结束油耗表盘'])
+    expect(wrapper.findAll('img')).toHaveLength(0); expect(wrapper.text()).not.toContain('已上传')
+  })
+
+  it('blocks a close while busy and delegates unsaved-result decisions to the owner', async () => {
+    const guard = vi.fn(), done = vi.fn()
+    const wrapper = mount(OwnedBusinessPhotosDialog, { global, props: { modelValue: true, busy: true, beforeClose: guard } })
+    const close = wrapper.findComponent(Dialog).props('beforeClose') as (done: () => void) => void
+    close(done); expect(guard).not.toHaveBeenCalled(); expect(done).not.toHaveBeenCalled()
+    await wrapper.setProps({ busy: false }); close(done)
+    expect(guard).toHaveBeenCalledWith(done); expect(done).not.toHaveBeenCalled()
+  })
+
+  it('keeps an unknown operations request until its owner explicitly handles closing', async () => {
+    const done = vi.fn(), guard = vi.fn()
+    const wrapper = mount(OwnedBusinessOperationsDialog, { global, props: { modelValue: true, pending: true } })
+    const close = wrapper.findComponent(Dialog).props('beforeClose') as (done: () => void) => void
+    close(done); expect(done).not.toHaveBeenCalled()
+    await wrapper.setProps({ beforeClose: guard }); close(done)
+    expect(guard).toHaveBeenCalledWith(done); expect(done).not.toHaveBeenCalled()
+  })
+})

src/modules/overseas-master-data/components/OwnedBusinessListLayout.vue

@@ -0,0 +1,16 @@
+<script setup lang="ts">
+import '@/styles/adminDensity.css'
+import AdminPage from '@/shared/components/AdminPage.vue'
+import ListPageLayout from '@/shared/components/ListPageLayout.vue'
+</script>
+
+<template>
+  <AdminPage class="admin-density" spacing="compact">
+    <slot name="statistics" />
+    <ListPageLayout aria-label="自有业务任务列表">
+      <template v-if="$slots.filters" #toolbar><slot name="filters" /></template>
+      <template v-if="$slots.state" #state><slot name="state" /></template>
+      <slot />
+    </ListPageLayout>
+  </AdminPage>
+</template>

src/modules/overseas-master-data/components/OwnedBusinessOperationsDialog.vue

@@ -0,0 +1,35 @@
+<script setup lang="ts">
+import AppDialog from '@/shared/components/AppDialog.vue'
+
+const props = defineProps<{
+  dispatchNo?: string
+  busy?: boolean
+  saveDisabled?: boolean
+  pending?: boolean
+  beforeClose?: (done: () => void) => void | Promise<void>
+}>()
+const open = defineModel<boolean>({ default: false })
+const emit = defineEmits<{ save: [] }>()
+function close(done: () => void) {
+  if (props.busy) return
+  if (props.beforeClose) return props.beforeClose(done)
+  if (!props.pending) done()
+}
+</script>
+
+<template>
+  <AppDialog v-model="open" class="admin-density-dialog admin-density" title="登记运营信息" width="1080px" :confirm-loading="busy" :confirm-disabled="saveDisabled" :confirm-text="pending ? '核对并重试原请求' : '保存登记'" :before-close="close" :close-on-press-escape="!busy" @confirm="emit('save')">
+    <p class="owned-business-operation-reference">排车单号 {{ dispatchNo || '—' }}</p>
+    <slot name="state" />
+    <fieldset class="owned-business-operation-section"><legend>整车金额</legend><slot name="amount" /><p>整车只登记一次；单价采用系统返回的总金额与实际物理托数计算结果。</p></fieldset>
+    <fieldset class="owned-business-operation-section"><legend>逐目的地实际到达时间</legend><slot name="arrivals" /></fieldset>
+    <fieldset class="owned-business-operation-section"><legend>实际里程与油耗</legend><slot name="measurements" /></fieldset>
+    <p>登记运营信息不推进排车或派送状态；照片在独立上传照片窗口中处理。</p>
+  </AppDialog>
+</template>
+
+<style scoped>
+.owned-business-operation-reference { overflow-wrap: anywhere; }
+.owned-business-operation-section { min-width: 0; margin: 0 0 var(--admin-space-4); padding: var(--admin-space-4); border: 1px solid var(--admin-table-border); }
+.owned-business-operation-section legend { padding: 0 var(--admin-space-2); font-weight: 600; }
+</style>

src/modules/overseas-master-data/components/OwnedBusinessOperationsEditor.vue

@@ -0,0 +1,92 @@
+<script setup lang="ts">
+import { computed, getCurrentInstance, nextTick, reactive, ref, watch } from 'vue'
+import { ElMessage, ElMessageBox } from 'element-plus'
+import { useAuthStore } from '@/core/auth/auth'
+import { useAccessPreviewStore } from '@/core/access/accessPreview'
+import { useUnsavedWorkRegistration } from '@/core/unsaved-work/useUnsavedWorkRegistration'
+import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
+import ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
+import LoadErrorState from '@/shared/components/LoadErrorState.vue'
+import OwnedBusinessOperationsDialog from './OwnedBusinessOperationsDialog.vue'
+import { newOwnedBusinessPending, persistOwnedBusinessPending, restoreOwnedBusinessPending, recoverOwnedBusinessCommand, type OwnedBusinessPending } from './OwnedBusinessCommandRecovery'
+import { ownedBusinessDecimal, ownedBusinessVersion, type OwnedBusinessDetail, type OwnedBusinessMoney, type OwnedBusinessSave } from '../ownedBusinessTypes'
+import { overseasMasterDataPermissions as permission } from '../permissions'
+import { getOwnedBusiness } from '../api/ownedBusiness'
+
+const open = defineModel<boolean>({ default: false })
+const props = defineProps<{ detail: OwnedBusinessDetail | null }>()
+const emit = defineEmits<{ saved: [value: OwnedBusinessDetail]; busy: [value: boolean] }>()
+const auth = useAuthStore(), access = useAccessPreviewStore(), busy = ref(false), pending = ref<OwnedBusinessPending | null>(null), error = ref<ApiErrorDetails | null>(null), corrupted = ref(false)
+const form = reactive({ currency: '', amount: '', actualDistanceMiles: '', fuelConsumptionLitresPer100Km: '', reason: '', arrivals: {} as Record<string,string> })
+const active = computed(() => open.value || Boolean(pending.value))
+const registration = useUnsavedWorkRegistration({ key: `owned-business-operations:${getCurrentInstance()?.uid}`, label: computed(() => '自有业务运营登记'), isOpen: active, model: reactive({ form, pending }), requiredPermission: computed(() => permission.ownedBusinessEdit) })
+let actor = '', number = '', baseline = ''
+const writable = computed(() => !corrupted.value && access.can(permission.ownedBusinessEdit) && props.detail?.row.actions.edit.allowed === true)
+const locked = computed(() => busy.value || Boolean(pending.value))
+function persist() { persistOwnedBusinessPending(actor, number, 'operations', pending.value) }
+function ensureScope() { if (auth.user?.id !== actor || props.detail?.row.dispatchNo !== number) throw new Error('操作身份或排车单已变化，请重新打开') }
+watch(busy, value => emit('busy', value))
+watch(open, async value => {
+  if (!value || !props.detail) return
+  actor = auth.user?.id || ''; number = props.detail.row.dispatchNo; error.value = null; corrupted.value = false
+  try {
+    pending.value = restoreOwnedBusinessPending(actor, number, 'operations')
+    const operations = pending.value?.action === 'SAVE_OPERATIONS' ? (pending.value.body as OwnedBusinessSave).operations : props.detail.row.operations
+    Object.assign(form, { currency: operations.money?.currency || '', amount: operations.money?.amount ?? '', actualDistanceMiles: operations.actualDistanceMiles ?? '', fuelConsumptionLitresPer100Km: operations.fuelConsumptionLitresPer100Km ?? '', reason: pending.value ? (pending.value.body as OwnedBusinessSave).reason || '' : '', arrivals: Object.fromEntries(props.detail.row.destinations.map(destination => [destination.destinationKey, operations.arrivals.find(arrival => arrival.destinationKey === destination.destinationKey)?.actualArrivedAt || ''])) })
+    baseline = JSON.stringify(form); await nextTick(); if (!pending.value) registration.captureBaseline()
+  } catch (cause) { corrupted.value = true; error.value = getApiErrorDetails(cause, '运营资料恢复失败') }
+}, { immediate: true })
+function payload(): OwnedBusinessSave {
+  const amount = ownedBusinessDecimal(form.amount, 2, 18)
+  let money: OwnedBusinessMoney | null = null
+  if (amount != null) { if (!['CNY','USD'].includes(form.currency)) throw new Error('请选择金额币种'); money = { currency: form.currency as OwnedBusinessMoney['currency'], amount } }
+  else if (form.currency) throw new Error('金额和币种请成对填写，清空时同时清空两项')
+  const arrivals = props.detail!.row.destinations.map(destination => {
+    const value = form.arrivals[destination.destinationKey] || null
+    if (value && (!/(?:Z|[+-]\d{2}:\d{2})$/.test(value) || !Number.isFinite(Date.parse(value)))) throw new Error('实际到达时间必须包含有效时区')
+    return { destinationKey: destination.destinationKey, actualArrivedAt: value }
+  })
+  return { recordVersion: ownedBusinessVersion(props.detail!.row.recordVersion), idempotencyKey: crypto.randomUUID(), operations: { money, actualDistanceMiles: ownedBusinessDecimal(form.actualDistanceMiles, 3, 12), fuelConsumptionLitresPer100Km: ownedBusinessDecimal(form.fuelConsumptionLitresPer100Km, 3, 12), arrivals }, reason: form.reason.trim() || null }
+}
+async function save() {
+  if (busy.value || !writable.value || !props.detail) return
+  busy.value = true; error.value = null
+  try {
+    ensureScope()
+    if (!pending.value) { if (JSON.stringify(form) === baseline) { open.value = false; return }; pending.value = newOwnedBusinessPending(actor, number, 'SAVE_OPERATIONS', payload()); persist() }
+    const result = await recoverOwnedBusinessCommand(pending.value, persist, ensureScope)
+    if (!result.detail) throw new Error('运营登记结果未确认')
+    pending.value = null; persist(); registration.captureBaseline(); emit('saved', result.detail); open.value = false; ElMessage.success('运营信息已保存')
+  } catch (cause) { error.value = getApiErrorDetails(cause, cause instanceof Error ? cause.message : '运营登记结果尚未确认') }
+  finally { busy.value = false }
+}
+async function beforeClose(done: () => void) {
+  if (busy.value) return
+  if (pending.value || JSON.stringify(form) !== baseline) {
+    try { await ElMessageBox.confirm(pending.value ? '原请求将保留，重新打开后可核对原结果。是否关闭？' : '放弃尚未保存的运营信息？', '关闭运营登记', { customClass: 'admin-density-confirm', confirmButtonText: pending.value ? '保留请求并关闭' : '放弃修改', cancelButtonText: '继续编辑' }) } catch { return }
+  }
+  done()
+}
+async function discardRejected() {
+  if (!pending.value?.rejected || busy.value) return
+  busy.value = true
+  try { const current = await getOwnedBusiness(number); ensureScope(); pending.value = null; persist(); emit('saved', current); error.value = null }
+  catch (cause) { error.value = getApiErrorDetails(cause, '当前运营版本核对失败') }
+  finally { busy.value = false }
+}
+</script>
+
+<template>
+  <OwnedBusinessOperationsDialog v-model="open" :dispatch-no="detail?.row.dispatchNo" :busy="busy" :pending="Boolean(pending)" :save-disabled="!writable" :before-close="beforeClose" @save="save">
+    <template #state><LoadErrorState v-if="error" title="运营登记未完成" :message="error.message" :show-retry="false"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState><p v-if="pending">原请求已保留，字段锁定；核对结果前不会建立新请求。</p><el-button v-if="pending?.rejected" :disabled="busy" @click="discardRejected">按明确拒绝结果重新编辑</el-button><p v-if="!writable">{{ detail?.row.actions.edit.blockReason || '没有运营登记权限' }}</p></template>
+    <template #amount><el-form label-position="top" class="owned-business-form"><el-form-item label="币种"><el-select v-model="form.currency" clearable :disabled="locked"><el-option label="CNY" value="CNY" /><el-option label="USD" value="USD" /></el-select></el-form-item><el-form-item label="整车总金额"><el-input v-model="form.amount" :disabled="locked" placeholder="未登记；允许明确填写0" /></el-form-item><el-form-item label="更正说明"><el-input v-model="form.reason" :disabled="locked" maxlength="1000" /></el-form-item></el-form></template>
+    <template #arrivals><div v-for="destination in detail?.row.destinations || []" :key="destination.destinationKey" class="owned-business-arrival"><span>{{ destination.warehouseCode || destination.warehouseName || destination.address || '目的地资料缺失' }}<small v-for="appointment in destination.appointments" :key="appointment.appointmentNo">{{ appointment.appointmentNo }}</small></span><el-date-picker v-model="form.arrivals[destination.destinationKey]" type="datetime" value-format="YYYY-MM-DDTHH:mm:ssZ" :disabled="locked" placeholder="实际到达时间，未登记留空" /></div><p>时间按浏览器本地时区输入，提交时保留时区。</p></template>
+    <template #measurements><el-form label-position="top" class="owned-business-form"><el-form-item label="实际里程（mile）"><el-input v-model="form.actualDistanceMiles" :disabled="locked" placeholder="未登记" /></el-form-item><el-form-item label="油耗（L/100km）"><el-input v-model="form.fuelConsumptionLitresPer100Km" :disabled="locked" placeholder="手填耗油率，未登记留空" /></el-form-item></el-form></template>
+  </OwnedBusinessOperationsDialog>
+</template>
+
+<style scoped>
+.owned-business-form { display: grid; grid-template-columns: repeat(3,minmax(0,1fr)); gap: 0 var(--admin-space-4); }
+.owned-business-arrival { display: grid; grid-template-columns: minmax(0,1fr) 280px; align-items: center; gap: var(--admin-space-4); margin-bottom: var(--admin-space-3); }
+.owned-business-arrival small { display: block; }
+</style>

src/modules/overseas-master-data/components/OwnedBusinessPhotosDialog.vue

@@ -0,0 +1,56 @@
+<script setup lang="ts">
+import AppDialog from '@/shared/components/AppDialog.vue'
+
+const props = defineProps<{
+  dispatchNo?: string
+  busy?: boolean
+  beforeClose?: (done: () => void) => void | Promise<void>
+}>()
+const open = defineModel<boolean>({ default: false })
+const activeTab = defineModel<'loading' | 'fuel'>('activeTab', { default: 'loading' })
+// These are prototype presentation slots; the public file categories are not yet frozen.
+const loadingPhotos = [
+  { slot: 'loading-scene', label: '装车现场' },
+  { slot: 'loading-list', label: '装车清单' },
+  { slot: 'pre-departure-check', label: '出车前检查' },
+  { slot: 'driver-license', label: '驾驶证附件' },
+  { slot: 'delivery-receipt', label: '签收凭证' },
+]
+const fuelPhotos = [{ slot: 'fuel-start', label: '起始油耗表盘' }, { slot: 'fuel-end', label: '结束油耗表盘' }]
+function close(done: () => void) {
+  if (props.busy) return
+  if (props.beforeClose) return props.beforeClose(done)
+  done()
+}
+</script>
+
+<template>
+  <AppDialog v-model="open" class="admin-density-dialog admin-density" title="上传照片" width="760px" :show-confirm="false" cancel-text="关闭" :confirm-loading="busy" :close-on-press-escape="!busy" :before-close="close">
+    <p class="owned-business-photo-reference">排车单号 {{ dispatchNo || '—' }}</p>
+    <slot name="state" />
+    <p>每个附件方框单独处理，支持 JPG、PNG；上传照片不改变装车状态。</p>
+    <el-tabs v-model="activeTab" class="density-element-tabs density-contained-tabs">
+      <el-tab-pane name="loading" label="装车完成">
+        <div class="owned-business-photo-grid">
+          <section v-for="photo in loadingPhotos" :key="photo.slot" class="owned-business-photo-slot" :aria-label="photo.label">
+            <h3>{{ photo.label }}</h3><slot :name="photo.slot"><p>暂无照片</p></slot>
+          </section>
+        </div>
+      </el-tab-pane>
+      <el-tab-pane name="fuel" label="油耗图片">
+        <div class="owned-business-photo-grid">
+          <section v-for="photo in fuelPhotos" :key="photo.slot" class="owned-business-photo-slot" :aria-label="photo.label">
+            <h3>{{ photo.label }}</h3><slot :name="photo.slot"><p>暂无照片</p></slot>
+          </section>
+        </div>
+      </el-tab-pane>
+    </el-tabs>
+  </AppDialog>
+</template>
+
+<style scoped>
+.owned-business-photo-reference { overflow-wrap: anywhere; }
+.owned-business-photo-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: var(--admin-space-4); }
+.owned-business-photo-slot { min-width: 0; padding: var(--admin-space-4); border: 1px solid var(--admin-table-border); }
+.owned-business-photo-slot h3 { margin: 0 0 var(--admin-space-3); font-size: inherit; }
+</style>

src/modules/overseas-master-data/components/OwnedBusinessPhotosEditor.test.ts

@@ -0,0 +1,52 @@
+import { defineComponent, h } from 'vue'
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { ApiResponseError } from '@/shared/api/http'
+import OwnedBusinessPhotosEditor from './OwnedBusinessPhotosEditor.vue'
+import { ownedBusinessFixture } from './OwnedBusinessFixtures'
+import type { OwnedBusinessPhoto } from '../ownedBusinessTypes'
+
+const calls=vi.hoisted(()=>({upload:vi.fn(),bind:vi.fn(),command:vi.fn(),detail:vi.fn(),content:vi.fn(),actor:{user:{id:'actor'}},canUpload:true}))
+vi.mock('../api/ownedBusiness',()=>({uploadOwnedBusinessPhoto:calls.upload,bindOwnedBusinessPhoto:calls.bind,getOwnedBusinessCommand:calls.command,getOwnedBusiness:calls.detail,getOwnedBusinessPhotoContent:calls.content}))
+vi.mock('@/core/auth/auth',()=>({useAuthStore:()=>calls.actor}))
+vi.mock('@/core/access/accessPreview',()=>({useAccessPreviewStore:()=>({can:()=>calls.canUpload})}))
+vi.mock('@/core/unsaved-work/useUnsavedWorkRegistration',()=>({useUnsavedWorkRegistration:()=>({captureBaseline:vi.fn()})}))
+vi.mock('element-plus',()=>({ElMessage:{success:vi.fn()},ElMessageBox:{confirm:vi.fn()}}))
+const Frame=defineComponent({props:['modelValue','busy','beforeClose'],setup(_props,{slots}){return()=>h('div',Object.values(slots).map(slot=>slot?.()))}})
+const Button=defineComponent({props:['disabled'],template:'<button :disabled="disabled"><slot /></button>'})
+const global={stubs:{OwnedBusinessPhotosDialog:Frame,ElButton:Button,LoadErrorState:{props:['message'],template:'<div>{{message}}<slot name="details" /></div>'},ApiErrorMeta:true}}
+const photo:OwnedBusinessPhoto={slot:'LOADING_SCENE',category:'LOADING',fileId:'9007199254740993',fileName:'loading.png',contentType:'image/png',sizeBytes:'5',uploadedAt:'2026-10-20T10:00:00Z',savedAt:null}
+async function choose(wrapper:ReturnType<typeof mount>){const input=wrapper.find('input[type="file"]');Object.defineProperty(input.element,'files',{configurable:true,value:[new File(['image'],'loading.png',{type:'image/png'})]});await input.trigger('change');await flushPromises()}
+beforeEach(()=>{
+  vi.clearAllMocks();sessionStorage.clear();calls.actor.user.id='actor';calls.canUpload=true
+  calls.upload.mockResolvedValue(photo);calls.command.mockRejectedValue(new ApiResponseError('not found','A0404',404))
+  const current=ownedBusinessFixture();current.row.recordVersion='1';current.photos=[{...photo,savedAt:'2026-10-20T10:01:00Z'}]
+  calls.bind.mockResolvedValue(current);calls.detail.mockResolvedValue(current)
+})
+describe('owned business per-slot photo save',()=>{
+  it('retains prepared file and original binding request through a failed bind without retransmitting the image',async()=>{
+    calls.bind.mockRejectedValueOnce(new TypeError('network interrupted'))
+    const wrapper=mount(OwnedBusinessPhotosEditor,{global,props:{modelValue:true,detail:ownedBusinessFixture()}});await choose(wrapper)
+    expect(calls.upload).toHaveBeenCalledTimes(1);expect(calls.bind).toHaveBeenCalledTimes(1)
+    expect(wrapper.text()).toContain('尚未确认绑定保存');expect(wrapper.emitted('saved')).toBeUndefined()
+    const original=structuredClone(calls.bind.mock.calls[0]![2])
+    await wrapper.findAll('button').find(button=>button.text()==='核对原结果并继续绑定')!.trigger('click');await flushPromises()
+    expect(calls.upload).toHaveBeenCalledTimes(1);expect(calls.bind).toHaveBeenCalledTimes(2)
+    expect(calls.bind.mock.calls[1]![2]).toEqual(original);expect(original.fileId).toBe(photo.fileId);expect(original.recordVersion).toBe('0')
+    expect(wrapper.emitted('saved')).toHaveLength(1);wrapper.unmount()
+  })
+  it('does not offer a new upload after unknown upload or fabricate a saved photo',async()=>{
+    calls.upload.mockRejectedValue(new TypeError('network interrupted'))
+    const wrapper=mount(OwnedBusinessPhotosEditor,{global,props:{modelValue:true,detail:ownedBusinessFixture()}});await choose(wrapper)
+    await wrapper.findAll('button').find(button=>button.text()==='核对原结果并继续绑定')!.trigger('click');await flushPromises()
+    expect(calls.upload).toHaveBeenCalledTimes(1);expect(calls.bind).not.toHaveBeenCalled();expect(wrapper.emitted('saved')).toBeUndefined()
+    expect(wrapper.find('input[type="file"]').attributes('disabled')).toBeDefined();expect(wrapper.text()).toContain('禁止重复上传');wrapper.unmount()
+  })
+  it('keeps saved metadata readable without upload permission and fetches image bytes only on explicit preview',async()=>{
+    calls.canUpload=false
+    const detail=ownedBusinessFixture();detail.photos=[{...photo,savedAt:'2026-10-20T10:01:00Z'}]
+    const wrapper=mount(OwnedBusinessPhotosEditor,{global,props:{modelValue:true,detail}});await flushPromises()
+    expect(wrapper.find('input[type="file"]').exists()).toBe(false);expect(wrapper.text()).toContain('已保存');expect(calls.content).not.toHaveBeenCalled()
+    wrapper.unmount()
+  })
+})

src/modules/overseas-master-data/components/OwnedBusinessPhotosEditor.vue

@@ -0,0 +1,127 @@
+<script setup lang="ts">
+import { computed, getCurrentInstance, onBeforeUnmount, reactive, ref, watch } from 'vue'
+import { ElMessage, ElMessageBox } from 'element-plus'
+import { useAuthStore } from '@/core/auth/auth'
+import { useAccessPreviewStore } from '@/core/access/accessPreview'
+import { useUnsavedWorkRegistration } from '@/core/unsaved-work/useUnsavedWorkRegistration'
+import { ApiResponseError, getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
+import ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
+import LoadErrorState from '@/shared/components/LoadErrorState.vue'
+import OwnedBusinessPhotosDialog from './OwnedBusinessPhotosDialog.vue'
+import { ownedBusinessPhotoRoles, ownedBusinessVersion, type OwnedBusinessDetail, type OwnedBusinessPhoto, type OwnedBusinessPhotoSlot } from '../ownedBusinessTypes'
+import { getOwnedBusiness, getOwnedBusinessPhotoContent, uploadOwnedBusinessPhoto } from '../api/ownedBusiness'
+import { overseasMasterDataPermissions as permission } from '../permissions'
+import { acceptOwnedBusinessResult, newOwnedBusinessPending, ownedBusinessPendingKey, persistOwnedBusinessPending, restoreOwnedBusinessPending, recoverOwnedBusinessCommand, type OwnedBusinessPending } from './OwnedBusinessCommandRecovery'
+
+const open = defineModel<boolean>({ default: false })
+const props = defineProps<{ detail: OwnedBusinessDetail | null }>()
+const emit = defineEmits<{ saved: [value: OwnedBusinessDetail]; busy: [value: boolean] }>()
+const auth = useAuthStore(), access = useAccessPreviewStore(), busy = ref(false), error = ref<ApiErrorDetails | null>(null), pending = ref<OwnedBusinessPending | null>(null), prepared = ref<OwnedBusinessPhoto | null>(null), corrupted = ref(false)
+const urls = ref<Partial<Record<OwnedBusinessPhotoSlot,string>>>({}), reading = ref<OwnedBusinessPhotoSlot | null>(null)
+const uploadable = computed(() => !corrupted.value && access.can(permission.ownedBusinessUpload) && props.detail?.row.actions.upload.allowed === true)
+useUnsavedWorkRegistration({ key: `owned-business-photos:${getCurrentInstance()?.uid}`, label: computed(() => '自有业务照片作业'), isOpen: computed(() => open.value || Boolean(pending.value) || Boolean(prepared.value)), model: reactive({ pending, prepared }), requiredPermission: computed(() => permission.ownedBusinessUpload) })
+let actor = '', number = '', generation = 0
+function savedPhoto(slot: OwnedBusinessPhotoSlot) { return props.detail?.photos.find(photo => photo.slot === slot && photo.savedAt) }
+function release() { Object.values(urls.value).forEach(url => { if (url) URL.revokeObjectURL(url) }); urls.value = {} }
+function ensureScope() { if (auth.user?.id !== actor || props.detail?.row.dispatchNo !== number) throw new Error('图片作业身份或排车单已变化，请重新打开') }
+function persist() { persistOwnedBusinessPending(actor, number, 'photos', pending.value) }
+function persistPrepared() {
+  const key = ownedBusinessPendingKey(actor, number, 'prepared-photo')
+  if (prepared.value) sessionStorage.setItem(key, JSON.stringify(prepared.value)); else sessionStorage.removeItem(key)
+}
+watch(busy, value => emit('busy', value))
+watch(open, value => {
+  generation++; release(); reading.value = null; error.value = null; corrupted.value = false
+  if (!value || !props.detail) return
+  actor = auth.user?.id || ''; number = props.detail.row.dispatchNo
+  try {
+    pending.value = restoreOwnedBusinessPending(actor, number, 'photos')
+    const raw = sessionStorage.getItem(ownedBusinessPendingKey(actor, number, 'prepared-photo'))
+    prepared.value = raw ? JSON.parse(raw) as OwnedBusinessPhoto : null
+    if (prepared.value && (!prepared.value.fileId || !ownedBusinessPhotoRoles.some(role => role.slot === prepared.value!.slot))) throw new Error('原上传文件资料损坏，请保留现场核对')
+  } catch (cause) { corrupted.value = true; error.value = getApiErrorDetails(cause, '照片作业恢复失败') }
+}, { immediate: true })
+watch(() => props.detail?.photos, () => { generation++; release(); reading.value = null })
+onBeforeUnmount(() => { generation++; release() })
+async function preview(slot: OwnedBusinessPhotoSlot) {
+  const photo = savedPhoto(slot), current = generation
+  if (!photo || reading.value) return
+  reading.value = slot; error.value = null
+  try { const blob = await getOwnedBusinessPhotoContent(number, photo); if (current !== generation || !open.value) return; urls.value[slot] = URL.createObjectURL(blob) }
+  catch (cause) { if (current === generation) error.value = getApiErrorDetails(cause, '图片读取失败') }
+  finally { if (current === generation) reading.value = null }
+}
+async function bindPrepared() {
+  if ((!prepared.value && !pending.value) || !props.detail || !uploadable.value) return
+  if (!pending.value) {
+    const body = { recordVersion: ownedBusinessVersion(props.detail.row.recordVersion), idempotencyKey: crypto.randomUUID(), fileId: prepared.value!.fileId }
+    pending.value = newOwnedBusinessPending(actor, number, 'BIND_PHOTO', body, prepared.value!.slot); persist()
+  }
+  const result = await recoverOwnedBusinessCommand(pending.value, persist, ensureScope)
+  if (!result.detail) throw new Error('照片绑定尚未确认')
+  pending.value = null; persist(); prepared.value = null; persistPrepared(); emit('saved', result.detail); ElMessage.success('照片已绑定保存')
+}
+async function recover() {
+  if (busy.value || !uploadable.value) return
+  busy.value = true; error.value = null
+  try {
+    ensureScope()
+    if (pending.value?.action === 'UPLOAD_PHOTO') {
+      const result = await recoverOwnedBusinessCommand(pending.value, persist, ensureScope)
+      if (!result.photo) throw new Error('原上传文件未确认')
+      prepared.value = result.photo; persistPrepared(); pending.value = null; persist()
+    }
+    await bindPrepared()
+  } catch (cause) { error.value = getApiErrorDetails(cause, cause instanceof Error ? cause.message : '照片结果尚未确认') }
+  finally { busy.value = false }
+}
+async function upload(slot: OwnedBusinessPhotoSlot, event: Event) {
+  const input = event.target as HTMLInputElement, file = input.files?.[0]; input.value = ''
+  if (!file || busy.value || pending.value || prepared.value || !uploadable.value) return
+  if (!['image/jpeg','image/png'].includes(file.type) || file.size <= 0) { error.value = { message: '请选择有效的JPG或PNG图片' }; return }
+  busy.value = true; error.value = null
+  try {
+    ensureScope(); pending.value = newOwnedBusinessPending(actor, number, 'UPLOAD_PHOTO', null, slot); pending.value.attempted = true; persist()
+    const uploaded = await uploadOwnedBusinessPhoto(number, slot, file, pending.value.key)
+    ensureScope(); acceptOwnedBusinessResult(pending.value, uploaded); persist()
+    const result = await recoverOwnedBusinessCommand(pending.value, persist, ensureScope)
+    if (!result.photo) throw new Error('真实上传文件未确认')
+    prepared.value = result.photo; persistPrepared(); pending.value = null; persist(); await bindPrepared()
+  } catch (cause) {
+    if (pending.value?.action === 'UPLOAD_PHOTO' && cause instanceof ApiResponseError && ['A0400','A0403','A0404','400','403','404','422'].includes(cause.code)) { pending.value.rejected = true; persist() }
+    error.value = getApiErrorDetails(cause, cause instanceof Error ? cause.message : '图片上传或绑定结果尚未确认')
+  } finally { busy.value = false }
+}
+async function discardRejected() {
+  if (busy.value || !pending.value?.rejected) return
+  busy.value = true
+  try { const latest = await getOwnedBusiness(number); ensureScope(); pending.value = null; persist(); emit('saved', latest); error.value = null }
+  catch (cause) { error.value = getApiErrorDetails(cause, '当前照片版本读取失败') }
+  finally { busy.value = false }
+}
+async function beforeClose(done: () => void) {
+  if (busy.value) return
+  if (pending.value || prepared.value) {
+    try { await ElMessageBox.confirm('未完成的原上传或绑定记录将保留，重新打开后继续核对；关闭不会保存尚未绑定的照片。是否关闭？', '关闭照片窗口', { customClass: 'admin-density-confirm', confirmButtonText: '保留记录并关闭', cancelButtonText: '继续核对' }) } catch { return }
+  }
+  done()
+}
+</script>
+
+<template>
+  <OwnedBusinessPhotosDialog v-model="open" :dispatch-no="detail?.row.dispatchNo" :busy="busy" :before-close="beforeClose">
+    <template #state><LoadErrorState v-if="error" title="照片作业未完成" :message="error.message" :show-retry="false"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState><p v-if="pending">原{{ pending.action === 'UPLOAD_PHOTO' ? '上传' : '绑定' }}请求已保留，不会重新上传文件。</p><p v-if="prepared">{{ prepared.fileName }} 已上传，尚未确认绑定保存。</p><el-button v-if="pending || prepared" :loading="busy" :disabled="!uploadable" @click="recover">核对原结果并继续绑定</el-button><el-button v-if="pending?.rejected" :disabled="busy" @click="discardRejected">按明确拒绝重新核对，保留已上传文件</el-button><p v-if="!uploadable">{{ detail?.row.actions.upload.blockReason || '当前仅可查看照片' }}</p></template>
+    <template v-for="role in ownedBusinessPhotoRoles" :key="role.slot" #[role.viewSlot]>
+      <img v-if="urls[role.slot]" :src="urls[role.slot]" :alt="role.label" class="owned-business-photo" />
+      <template v-if="savedPhoto(role.slot)"><p>{{ savedPhoto(role.slot)?.fileName }} · 已保存</p><el-button :loading="reading === role.slot" :disabled="Boolean(reading)" @click="preview(role.slot)">查看图片</el-button></template>
+      <p v-else>暂无已保存照片</p>
+      <label v-if="uploadable" class="owned-business-upload">{{ savedPhoto(role.slot) ? '替换图片' : '上传图片' }}<input type="file" accept="image/jpeg,image/png" :disabled="busy || Boolean(pending) || Boolean(prepared)" @change="upload(role.slot, $event)" /></label>
+    </template>
+  </OwnedBusinessPhotosDialog>
+</template>
+
+<style scoped>
+.owned-business-photo { display: block; width: 100%; max-height: 160px; object-fit: contain; }
+.owned-business-upload { display: block; margin-top: var(--admin-space-3); }
+.owned-business-upload input { display: block; width: 100%; margin-top: var(--admin-space-2); }
+</style>

src/modules/overseas-master-data/components/TransportRouteDialog.test.ts

@@ -25,7 +25,7 @@ describe('transport route address resolution', () => {
     expect(wrapper.text()).toContain('目的地地址：' + addresses.ABE3)
     expect(resolveRouteLocation).toHaveBeenCalledTimes(2)
     const iframe = wrapper.get('iframe').element
-    await wrapper.get('button').trigger('click')
+    await wrapper.findAll('button').find(button => button.text() === '重新加载地图')!.trigger('click')
     expect(wrapper.get('iframe').element).not.toBe(iframe)
     expect(resolveRouteLocation).toHaveBeenCalledTimes(2)
     await wrapper.setProps({ modelValue: false })

src/modules/overseas-master-data/components/TransportRouteDialog.vue

@@ -56,7 +56,7 @@ const tooLong = computed(() => mapUrl.value.length > 2048 || externalUrl.value.l
       <el-select v-if="props.destinations.length > 1" v-model="destinationIndex" aria-label="选择目的仓">
         <el-option v-for="(item, index) in props.destinations" :key="index" :label="item.label" :value="index" />
       </el-select>
-      
+
       <p v-if="loading" role="status">正在查询仓库详细地址…</p>
       <LoadErrorState v-else-if="error" title="无法加载路线" :message="error.message" @retry="retry"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
       <p v-else-if="tooLong" role="status">地点信息过长，请核对起点和目的地地址后重试。</p>
@@ -65,7 +65,7 @@ const tooLong = computed(() => mapUrl.value.length > 2048 || externalUrl.value.l
         referrerpolicy="no-referrer" />
       </template>
       <div v-if="ready && !tooLong" class="route-help">
-        
+
         <el-button @click="mapRevision++">重新加载地图</el-button>
         <el-link :href="externalUrl" target="_blank" rel="noopener noreferrer" type="primary">在新窗口打开地图</el-link>
       </div>

src/modules/overseas-master-data/components/TripBookingPanel.vue

@@ -1,4 +1,5 @@
 <script setup lang="ts">
+import InlineHelp from '@/shared/components/InlineHelp.vue'
 import { computed, onBeforeUnmount, reactive, ref, watch } from 'vue'
 import { ElMessage, ElMessageBox } from 'element-plus'
 import DataTable, { type DataTableColumn } from '@/shared/components/DataTable.vue'
@@ -147,10 +148,10 @@ onBeforeUnmount(() => { generation++; searchSequence++; quoteSequence++; clearTi
 </script>
 <template>
   <div>
-    <p>询价不占用车辆空间；确认承运后预留容量。实收时核对运费，转派送时按确认报价登记应收，付款状态以财务为准。</p>
+
     <LoadErrorState v-if="error" title="外接操作未完成" :message="error.message" @retry="load"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
     <DataTable :data="records" :columns="columns" :loading="loading" row-key="bookingNo" empty-text="暂无外接预订">
-      <template #toolbar-actions><el-button :disabled="busy" @click="load">刷新预订</el-button><el-button v-if="planned && access.can(permission.tripBookingCreate)" type="primary" :disabled="busy" @click="edit()">{{ pendingCreate ? '继续原登记' : '登记外接询价' }}</el-button></template>
+      <template #toolbar-actions><el-button :disabled="busy" @click="load">刷新预订</el-button><el-button v-if="planned && access.can(permission.tripBookingCreate)" type="primary" :disabled="busy" @click="edit()">{{ pendingCreate ? '继续原登记' : '登记外接询价' }}</el-button><InlineHelp title="外接预订说明"><p>询价不占位，确认承运后预留容量。实收时核对运费，转派送后按确认报价登记应收，付款状态以财务为准。</p></InlineHelp></template>
       <template #actions="{ row }"><div class="density-actions"><el-button class="density-action" :disabled="busy" @click="edit(row as TripBooking, true)">详情</el-button><el-button v-if="!row.offerNo && planned && row.status === 'DRAFT' && access.can(permission.tripBookingEdit)" class="density-action" :disabled="busy || !!pendingCreate" @click="edit(row as TripBooking)">编辑</el-button><el-button v-if="!row.offerNo && planned && row.status === 'DRAFT' && access.can(permission.tripBookingConfirm)" class="density-action" :disabled="busy" @click="command(row as TripBooking, 'confirm')">确认承运</el-button><el-button v-if="!row.offerNo && planned && ['DRAFT','CONFIRMED','RECEIVED'].includes(row.status) && access.can(permission.tripBookingCancel)" class="density-action" data-tone="danger" :disabled="busy" @click="command(row as TripBooking, 'cancel')">取消预订</el-button><el-button v-if="row.incomingNo" class="density-action" @click="fulfill(row as TripBooking, 'view')">来货详情</el-button><el-button v-if="planned && row.status === 'CONFIRMED' && !row.incomingNo && access.can(permission.tripBookingEdit)" class="density-action" :disabled="busy" @click="fulfill(row as TripBooking, 'incoming')">登记来货</el-button><el-button v-if="canConfirmReceipt(row as TripBooking)" class="density-action" :disabled="busy" @click="fulfill(row as TripBooking, 'receipt')">核对实收</el-button><el-button v-if="planned && row.status === 'RECEIVED' && access.can(permission.tripBookingEdit) && access.can(permission.tripEdit)" class="density-action" :disabled="busy" @click="fulfill(row as TripBooking, 'bind')">关联排车</el-button></div></template>
       <template #status="{ row }">{{ bookingStatusLabels[row.status as keyof typeof bookingStatusLabels] }}</template>
       <template #cargo="{ row }">{{ row.receipt ? '实收' : '预计' }} · {{ row.cargo.packageCount ?? '—' }} 箱 · {{ row.expectedPalletCount ?? '—' }} 实托 · {{ row.cargo.palletSpaces ?? '—' }} 托位 · {{ row.cargo.weightKg ?? '—' }} kg · {{ row.cargo.volumeCbm ?? '—' }} m³</template>
@@ -177,9 +178,9 @@ onBeforeUnmount(() => { generation++; searchSequence++; quoteSequence++; clearTi
         <p v-if="quoteSource">来源：{{ quoteSource.quoteNo }} · 版本 {{ quoteSource.recordVersion }} · {{ quoteSource.originCity }} → {{ quoteSource.destinationCode }} · 适用日期 {{ quoteSource.effectiveOn }}<br>来源单价：{{ quoteSource.quotedUnitPrice.toFixed(2) }} {{ quoteSource.currency }} / {{ quoteSource.priceBasis === 'PALLET' ? '托位' : '单' }} · 有效期 {{ quoteSource.validFrom }} 至 {{ quoteSource.validTo }}</p>
         <p v-else>{{ quoteRef ? `已选报价 ${quoteRef.quoteNo} · 版本 ${quoteRef.recordVersion}` : '手工询价，尚未选择报价库来源。' }}</p>
         <template v-if="!readOnly && canReadQuotes">
-          <el-button :disabled="quoteLocked || !canQueryQuotes || quoteLoading" @click="queryQuotes()">查询报价库</el-button>
+          <el-button :disabled="quoteLocked || !canQueryQuotes || quoteLoading" @click="queryQuotes()">查询报价库</el-button><InlineHelp title="报价来源说明"><p>来源报价与实际约定价格分别保存；确认承运时重新核对报价版本与适用日期。可选择手工询价。</p></InlineHelp>
           <el-button v-if="quoteRef" :disabled="quoteLocked" @click="clearQuote">改为手工询价</el-button>
-          <p v-if="!canQueryQuotes">选择客户、FBA卸货站及CNY或USD后可查询；其他场景可继续填写手工价格。</p>
+          <p v-if="!canQueryQuotes">查询报价需客户、FBA卸货站和 CNY/USD。</p>
           <el-select v-if="candidates.length" data-testid="booking-quote-candidate" :model-value="quoteRef ? sourceKey(quoteRef) : ''" :disabled="quoteLocked || quoteLoading" placeholder="选择报价后带入单价，可另行议价" @update:model-value="selectQuote">
             <el-option v-for="item in candidates" :key="sourceKey(item)" :value="sourceKey(item)" :label="`${item.quoteNo} · ${item.quotedUnitPrice.toFixed(2)} ${item.currency} · ${item.validFrom} 至 ${item.validTo}`" />
           </el-select>
@@ -187,7 +188,7 @@ onBeforeUnmount(() => { generation++; searchSequence++; quoteSequence++; clearTi
           <div v-if="quotePages > 1"><el-button :disabled="quoteLoading || quotePage <= 1" @click="queryQuotes(quotePage - 1)">上一页</el-button> {{ quotePage }} / {{ quotePages }} <el-button :disabled="quoteLoading || quotePage >= quotePages" @click="queryQuotes(quotePage + 1)">下一页</el-button></div>
           <p v-if="quoteError" role="alert">{{ quoteError.message }} <ApiErrorMeta :details="quoteError" /></p>
         </template>
-        <p v-if="quoteRef">来源报价与实际约定价格分别保存；确认承运时会重新核对报价版本与适用日期。</p>
+
       </section>
       <p>约定运费：{{ quotedAmount == null ? '待报价' : `${quotedAmount.toFixed(2)} ${form.currency || ''}` }}。保存询价不会占位，确认承运时核对本车剩余容量。</p>
     </AppDialog>

src/modules/overseas-master-data/components/TripCostPanel.vue

@@ -1,4 +1,5 @@
 <script setup lang="ts">
+import InlineHelp from '@/shared/components/InlineHelp.vue'
 import { computed, onBeforeUnmount, reactive, ref, watch } from 'vue'
 import { ElMessage } from 'element-plus'
 import AppDialog from '@/shared/components/AppDialog.vue'
@@ -139,7 +140,7 @@ onBeforeUnmount(() => { scopeGeneration++; generation++; historyGeneration++ })
   <section aria-label="车次直接成本">
     <p v-if="!allowed">暂无车次成本查看权限。</p>
     <template v-else>
-      <p class="cost-note">按实际费用登记，金额按币种分别汇总。运营分摊用于单趟分析，不代表已付款，也不生成客户账单。</p>
+
       <LoadErrorState v-if="error" title="车次成本加载失败" :message="error.message" @retry="load"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
       <template v-if="summary">
         <p v-if="!summary.totals.length" class="cost-note">尚未登记直接成本。</p>
@@ -154,7 +155,7 @@ onBeforeUnmount(() => { scopeGeneration++; generation++; historyGeneration++ })
         </div>
       </template>
       <DataTable v-model:page="page" v-model:page-size="size" :data="rows" :columns="columns" :total="total" :loading="loading" row-key="costNo" empty-text="暂无直接成本记录">
-        <template #toolbar-actions><el-button :disabled="loading || saving" @click="load">刷新</el-button><el-button v-if="access.can(permission.tripCostCreate)" type="primary" :disabled="opening || saving" @click="beginEdit(null)">登记成本</el-button></template>
+        <template #toolbar-actions><el-button :disabled="loading || saving" @click="load">刷新</el-button><el-button v-if="access.can(permission.tripCostCreate)" type="primary" :disabled="opening || saving" @click="beginEdit(null)">登记成本</el-button><InlineHelp title="直接成本说明"><p>按实际费用登记，各币种分别汇总。运营分摊用于单趟分析，不代表已付款，也不生成客户账单。</p></InlineHelp></template>
         <template #actions="{ row }"><RowActions :actions="actions()" @action="$event === 'edit' ? beginEdit(row as TripCost) : showHistory(row as TripCost)" /></template>
         <template #category="{ row }">{{ categories[row.details.category as CostCategory] }}</template>
         <template #amount="{ row }">{{ row.details.currency }} {{ row.details.amount.toFixed(2) }}</template>

src/modules/overseas-master-data/components/TripOperationsRecordDialog.vue

@@ -93,13 +93,13 @@ watch([tab, page, size], () => { clearPreview(); if (tab.value === 'history') vo
       <el-form-item v-if="!readonly" label="更正说明（选填）" class="full"><el-input v-model="reason" maxlength="1000" placeholder="选填，留空使用标准更正说明" /></el-form-item>
       <el-form-item label="实测凭证（选填）" class="full"><template #label><span>实测凭证（选填）<InlineHelp title="实测凭证说明"><p>PDF、JPG、PNG，单个不超过10MiB，最多20个；不上传也可保存。</p></InlineHelp></span></template>
         <input v-if="!readonly" data-testid="evidence-input" type="file" accept="application/pdf,image/jpeg,image/png" aria-label="选择实测凭证" :disabled="!record || loading || saving || uploading || uncertain || uploadUncertain || form.evidenceFiles.length >= 20" @change="chooseFile" />
-        
+
       </el-form-item>
     </el-form>
     <ul v-if="form.evidenceFiles.length" class="evidence-list"><li v-for="file in form.evidenceFiles" :key="file.fileId"><el-button :disabled="previewLoading || !savedFileIds.has(file.fileId)" @click="preview(file)">{{ file.fileName }}</el-button><span v-if="!savedFileIds.has(file.fileId)">（保存后可预览）</span><el-button v-if="!readonly" :disabled="saving || uploading || uncertain" @click="removeFile(file.fileId)">移除引用</el-button></li></ul>
     <p v-if="uploading">正在上传 {{ uploadName }}…</p>
     <p v-if="uploadUncertain">{{ uploadName }} 的上传结果未确认，可能已上传但尚未绑定。请先核对，不要重复上传。<el-button :disabled="uploading" @click="omitUpload">暂不绑定此附件</el-button></p>
-    
+
   </el-tab-pane><el-tab-pane label="更正历史" name="history"><DataTable v-model:page="page" v-model:page-size="size" :data="history" :columns="columns" :total="total" :loading="loading" row-key="recordVersion" empty-text="暂无实测更正历史"><template #distance="{ row: item }">{{ item.details.actualDistanceMiles ?? '—' }}</template><template #fuel="{ row: item }">{{ item.details.actualFuelLitres ?? '—' }}</template><template #remark="{ row: item }">{{ item.details.remark || '—' }}</template><template #evidence="{ row: item }"><el-button v-for="file in item.details.evidenceFiles" :key="file.fileId" :disabled="previewLoading" @click="preview(file)">{{ file.fileName }}</el-button><span v-if="!item.details.evidenceFiles.length">—</span></template></DataTable></el-tab-pane></el-tabs>
   <section v-if="previewUrl && previewFile" aria-label="实测凭证预览"><el-button @click="clearPreview">关闭预览</el-button><iframe v-if="previewFile.contentType === 'application/pdf'" :src="previewUrl" :title="previewFile.fileName" class="evidence-preview" /><img v-else :src="previewUrl" :alt="previewFile.fileName" class="evidence-preview" /></section>
   <template #footer><el-button :disabled="saving" @click="open = false">关闭</el-button><el-button v-if="!readonly && tab === 'measured'" type="primary" :loading="saving" :disabled="!record || loading || uploading || uploadUncertain" @click="save">{{ uncertain ? '按原请求重试' : '保存记录' }}</el-button></template>

src/modules/overseas-master-data/components/VehicleCareEditor.vue

@@ -121,7 +121,7 @@ onBeforeUnmount(() => { editSession++ })
         <el-form-item v-if="costRecord" label="费用（申报金额）"><template #label><span>费用（申报金额）<InlineHelp title="申报费用说明"><p>此处保存申报费用；保存后可从记录行“财务”核对并提交公司成本。处理完成不会标记为已入账或已付款。</p></InlineHelp></span></template><el-input-number v-model="form.incident.reportedCost" :min="0" :precision="2" placeholder="未确定时留空" /></el-form-item>
         <el-form-item v-if="costRecord" label="币种" :required="form.incident.reportedCost != null"><el-select v-model="form.incident.currency" filterable allow-create default-first-option clearable placeholder="请选择或输入三位币种"><el-option v-for="currency in ['USD','CNY','CAD','EUR','GBP','MXN']" :key="currency" :label="currency" :value="currency" /></el-select></el-form-item>
         <el-form-item label="处理状态"><el-select v-model="form.incident.processingStatus"><el-option v-for="(label, key) in processingLabels" :key="key" :label="label" :value="key" /></el-select></el-form-item>
-        
+
       </template>
       <el-form-item v-if="meterRecord" label="核验状态"><el-select v-model="form.verificationStatus"><el-option label="待核验" value="PENDING" /><el-option label="已核验" value="VERIFIED" /></el-select></el-form-item>
       <el-form-item label="备注" class="full-width"><el-input v-model="form.remark" type="textarea" :rows="2" maxlength="1000" placeholder="补充本次记录的其他情况（选填）" /></el-form-item>

src/modules/overseas-master-data/components/VehicleCareTable.vue

@@ -194,7 +194,7 @@ onBeforeUnmount(() => { request++; operationEpoch++; supplierRequest++; disposed
     <VehicleCareEditor v-model="editorOpen" :vehicle-id="vehicleId" :plate="plate" :record-type="recordType" :record="editing" @saved="saved" />
     <AppDialog v-model="financeOpen" title="公司车辆成本" width="620px" class="admin-density-dialog" confirm-text="提交财务"
       :show-confirm="canSubmitFinance || !!pendingFinance" :confirm-loading="financeSaving" :confirm-disabled="ledgerBusy || !access.can(vehicleCareFinanceSubmitPermission)" @confirm="submitFinance">
-      
+
       <p v-if="financeTarget">{{ financeTarget.recordNo }} · {{ financeTarget.vehiclePlate }} · 申报费用 {{ financeTarget.details.incident?.currency || '—' }} {{ financeTarget.details.incident?.reportedCost?.toFixed(2) ?? '—' }}</p>
       <p v-if="financeStatus">{{ vehicleCareFinanceLabels[financeStatus.status] }}</p>
       <template v-if="financeStatus?.finance">

src/modules/overseas-master-data/ownedBusinessTypes.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest'
+import { ownedBusinessDecimal, ownedBusinessVersion, ownedBusinessText } from './ownedBusinessTypes'
+
+describe('owned business decimal and version boundary', () => {
+  it('preserves the maximum decimal money text and distinguishes empty from explicit zero', () => {
+    expect(ownedBusinessDecimal('9999999999999999.99', 2, 18)).toBe('9999999999999999.99')
+    expect(ownedBusinessDecimal('0.00', 2, 18)).toBe('0.00'); expect(ownedBusinessDecimal('  ', 2, 18)).toBeNull()
+    expect(() => ownedBusinessDecimal('10000000000000000.00', 2, 18)).toThrow()
+    for (const value of ['-1','1e3','1.001','01','NaN','Infinity']) expect(() => ownedBusinessDecimal(value, 2, 18)).toThrow()
+    expect(ownedBusinessDecimal('123.456', 3, 12)).toBe('123.456')
+  })
+  it('keeps version zero and large string identities without accepting unsafe numeric versions', () => {
+    expect(ownedBusinessVersion(0)).toBe('0'); expect(ownedBusinessVersion('9007199254740993')).toBe('9007199254740993')
+    for (const value of [undefined,null,-1,0.5,Number.MAX_SAFE_INTEGER + 1,'','1e3']) expect(() => ownedBusinessVersion(value)).toThrow()
+    expect(ownedBusinessText(null)).toBe('—'); expect(ownedBusinessText(0)).toBe('0')
+  })
+})

src/modules/overseas-master-data/ownedBusinessTypes.ts

@@ -0,0 +1,45 @@
+import type { DispatchDetail } from '@/modules/overseas-warehouse'
+
+export type OwnedBusinessStage = 'AFTER_LOADING' | 'DELIVERING' | 'DELIVERED'
+export type OwnedBusinessPhotoSlot = 'LOADING_SCENE' | 'LOADING_LIST' | 'PRE_DEPARTURE_CHECK' | 'DRIVER_LICENSE' | 'RECEIPT' | 'FUEL_START' | 'FUEL_END'
+export interface OwnedBusinessMoney { currency: 'CNY' | 'USD'; amount: string }
+export interface OwnedBusinessArrival { destinationKey: string; actualArrivedAt: string | null }
+export interface OwnedBusinessOperations { money: OwnedBusinessMoney | null; actualDistanceMiles: string | null; fuelConsumptionLitresPer100Km: string | null; arrivals: OwnedBusinessArrival[] }
+export interface OwnedBusinessPhoto { slot: OwnedBusinessPhotoSlot; category: 'LOADING' | 'FUEL'; fileId: string; fileName: string; contentType: 'image/jpeg' | 'image/png'; sizeBytes: string; uploadedAt: string; savedAt: string | null }
+export interface OwnedBusinessDestination { destinationKey: string; warehouseCode: string | null; warehouseName: string | null; address: string | null; appointments: { appointmentNo: string; confirmationNo: string | null; scheduledAt: string | null; allocatedPackages: string }[]; actualArrivedAt: string | null }
+export interface OwnedBusinessRow {
+  dispatchNo: string; stage: OwnedBusinessStage; plannedDepartureAt: string; loadingCompletedAt: string; departedAt: string | null; deliveryCompletedAt: string | null
+  origin: { warehouseId: string; warehouseCode: string; warehouseName: string }
+  vehicle: { vehicleId: string; plate: string; ownership: 'OWNED' }; driver: { name: string | null; phone: string | null }
+  destinations: OwnedBusinessDestination[]; actualPalletCount: number | null; operations: OwnedBusinessOperations; unitPrice: string | null; recordVersion: string; dispatchRecordVersion: string
+  photoSummary: { loadingCount: number; fuelCount: number }; actions: { edit: OwnedBusinessGate; upload: OwnedBusinessGate }; sourceIssues: string[]
+}
+export interface OwnedBusinessGate { allowed: boolean; blockReason: string | null }
+export interface OwnedBusinessQuery { page?: number; size?: number; plannedDepartureFrom?: string; plannedDepartureTo?: string; keyword?: string; stage?: OwnedBusinessStage; warehouseId?: string }
+export interface OwnedBusinessSummary { dispatchCount: number; afterLoadingCount: number; deliveringCount: number; deliveredCount: number }
+export interface OwnedBusinessPage<T> { records: T[]; page: number; size: number; total: number }
+export interface OwnedBusinessList extends OwnedBusinessPage<OwnedBusinessRow> { summary: OwnedBusinessSummary }
+export interface OwnedBusinessDetail { row: OwnedBusinessRow; dispatch: DispatchDetail; cargo: { sourceKey: string; customerId: string; customerName: string | null; orderNo: string | null; inboundCode: string | null; palletNo: string; destinationKey: string; packages: string }[]; photos: OwnedBusinessPhoto[] }
+export interface OwnedBusinessSave { recordVersion: string; idempotencyKey: string; operations: OwnedBusinessOperations; reason: string | null }
+export interface OwnedBusinessBind { recordVersion: string; idempotencyKey: string; fileId: string }
+export type OwnedBusinessAction = 'SAVE_OPERATIONS' | 'UPLOAD_PHOTO' | 'BIND_PHOTO'
+export interface OwnedBusinessCommand { dispatchNo: string; action: OwnedBusinessAction; idempotencyKey: string; state: 'SUCCEEDED' | 'PENDING' | 'UNKNOWN_RESULT' | 'REJECTED'; recordVersion: string | null; replayed: boolean; result: OwnedBusinessDetail | OwnedBusinessPhoto | null; errorCode: string | null; retryAllowed: boolean }
+export interface OwnedBusinessHistory { eventSource: 'DISPATCH' | 'OPERATIONS'; recordVersion: string | null; dispatchRecordVersion: string | null; action: string; operatorName: string | null; occurredAt: string; reason: string | null; operations: OwnedBusinessOperations | null; photos: OwnedBusinessPhoto[] }
+export const ownedBusinessStages: Record<OwnedBusinessStage, string> = { AFTER_LOADING: '装车完成', DELIVERING: '派送中', DELIVERED: '派送完成' }
+export const ownedBusinessActionLabels: Record<string,string> = { CREATE: '新建排车', EDIT: '维护车辆信息', ADD_CARGO: '添加货物', REMOVE_CARGO: '移除货物', SUBMIT_REVIEW: '提交调度审核', DISPATCH_REVIEW: '调度审核', LOADING_REVIEW: '理货员审核', RETURN_TO_REVIEW: '退回重审', PICK: '真实拣货', LOADING_COMPLETE: '确认装车完成', ARRANGE_DELIVERY: '安排派送', DEPART: '实际发车', CANCEL: '取消排车', SAVE_OPERATIONS: '登记运营信息', BIND_PHOTO: '保存分类照片' }
+export const ownedBusinessPhotoRoles: { slot: OwnedBusinessPhotoSlot; viewSlot: string; label: string; category: 'LOADING' | 'FUEL' }[] = [
+  { slot: 'LOADING_SCENE', viewSlot: 'loading-scene', label: '装车现场', category: 'LOADING' }, { slot: 'LOADING_LIST', viewSlot: 'loading-list', label: '装车清单', category: 'LOADING' },
+  { slot: 'PRE_DEPARTURE_CHECK', viewSlot: 'pre-departure-check', label: '出车前检查', category: 'LOADING' }, { slot: 'DRIVER_LICENSE', viewSlot: 'driver-license', label: '驾驶证附件', category: 'LOADING' },
+  { slot: 'RECEIPT', viewSlot: 'delivery-receipt', label: '签收凭证', category: 'LOADING' }, { slot: 'FUEL_START', viewSlot: 'fuel-start', label: '起始油耗表盘', category: 'FUEL' }, { slot: 'FUEL_END', viewSlot: 'fuel-end', label: '结束油耗表盘', category: 'FUEL' },
+]
+export function ownedBusinessVersion(value: unknown): string {
+  if ((typeof value !== 'string' && typeof value !== 'number') || !/^(0|[1-9]\d*)$/.test(String(value)) || typeof value === 'number' && !Number.isSafeInteger(value)) throw new Error('运营记录版本无效，请重新读取')
+  return String(value)
+}
+export function ownedBusinessDecimal(value: string, scale: number, precision: number): string | null {
+  const text = value.trim()
+  if (!text) return null
+  if (!new RegExp(`^(?:0|[1-9]\\d*)(?:\\.\\d{1,${scale}})?$`).test(text) || text.split('.')[0]!.length > precision - scale) throw new Error(`请输入不超过${scale}位小数的有效非负数`)
+  return text
+}
+export function ownedBusinessText(value: unknown): string { return value == null || value === '' ? '—' : String(value) }

src/modules/overseas-master-data/pages/OwnedBusinessDetailView.vue

@@ -0,0 +1,82 @@
+<script setup lang="ts">
+import { computed, onActivated, onBeforeUnmount, onDeactivated, onMounted, ref, watch } from 'vue'
+import { useRoute, useRouter } from 'vue-router'
+import dayjs from 'dayjs'
+import { useAccessPreviewStore } from '@/core/access/accessPreview'
+import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
+import LoadErrorState from '@/shared/components/LoadErrorState.vue'
+import ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
+import DataTable, { type DataTableColumn } from '@/shared/components/DataTable.vue'
+import OwnedBusinessDetailLayout from '../components/OwnedBusinessDetailLayout.vue'
+import OwnedBusinessOperationsEditor from '../components/OwnedBusinessOperationsEditor.vue'
+import OwnedBusinessPhotosEditor from '../components/OwnedBusinessPhotosEditor.vue'
+import { getOwnedBusiness, getOwnedBusinessPhotoContent, listOwnedBusinessHistory } from '../api/ownedBusiness'
+import { ownedBusinessActionLabels, ownedBusinessStages, ownedBusinessText as text, ownedBusinessPhotoRoles, type OwnedBusinessDetail, type OwnedBusinessHistory, type OwnedBusinessPhoto } from '../ownedBusinessTypes'
+import { overseasMasterDataPermissions as permission } from '../permissions'
+
+const route = useRoute(), router = useRouter(), access = useAccessPreviewStore()
+const dispatchNo = computed(() => typeof route.params.dispatchNo === 'string' ? route.params.dispatchNo : '')
+const detail = ref<OwnedBusinessDetail | null>(null), loading = ref(false), error = ref<ApiErrorDetails | null>(null), activeTab = ref<'task'|'route'|'history'>('task')
+const editorOpen = ref(false), photosOpen = ref(false), busy = ref(false)
+const history = ref<OwnedBusinessHistory[]>([]), historyPage = ref(1), historySize = ref(20), historyTotal = ref(0), historyLoading = ref(false), historyError = ref<ApiErrorDetails | null>(null), previewError = ref<ApiErrorDetails | null>(null)
+let generation = 0, historyGeneration = 0, active = true, initialActivation = true
+const previewUrls = new Set<string>()
+const historyRows = computed(() => history.value.map((event, index) => ({ ...event, eventKey: `${event.eventSource}:${event.recordVersion ?? event.dispatchRecordVersion ?? event.occurredAt}:${event.action}:${index}` })))
+const cargoColumns: DataTableColumn[] = [{ prop: 'customerName', label: '客户', minWidth: 150 }, { prop: 'orderNo', label: '订单号', minWidth: 220 }, { prop: 'inboundCode', label: '入仓码', minWidth: 180 }, { prop: 'palletNo', label: '实物托盘码', minWidth: 180 }, { key: 'destination', label: '目的地', minWidth: 180, slotName: 'destination' }, { prop: 'packages', label: '箱数', minWidth: 90 }]
+const historyColumns: DataTableColumn[] = [{ key: 'source', label: '事件来源', minWidth: 110, slotName: 'source' }, { key: 'revision', label: '运营版本', minWidth: 90, prop: 'recordVersion' }, { prop: 'dispatchRecordVersion', label: '排车版本', minWidth: 90 }, { key: 'action', label: '操作', minWidth: 150, slotName: 'action' }, { prop: 'operatorName', label: '操作人', minWidth: 140 }, { key: 'occurredAt', label: '操作时间', minWidth: 180, slotName: 'occurredAt' }, { prop: 'reason', label: '说明', minWidth: 160 }, { key: 'snapshot', label: '当时运营信息', minWidth: 250, slotName: 'snapshot' }, { key: 'photos', label: '当时照片', minWidth: 190, slotName: 'photos' }]
+const taskFields = computed(() => {
+  const row = detail.value?.row
+  return [['计划发车', time(row?.plannedDepartureAt)], ['装车完成', time(row?.loadingCompletedAt)], ['实际发车', time(row?.departedAt)], ['派送完成', time(row?.deliveryCompletedAt)], ['车牌', text(row?.vehicle.plate)], ['司机', text(row?.driver.name)], ['司机电话', text(row?.driver.phone)], ['提货仓库', text(row?.origin.warehouseName)], ['实际物理托数', text(row?.actualPalletCount)], ['整车金额', row?.operations.money ? `${row.operations.money.currency} ${row.operations.money.amount}` : '未登记'], ['单价', row?.unitPrice == null ? '—' : `${row.operations.money?.currency || ''} ${row.unitPrice}`], ['实际里程（mile）', row?.operations.actualDistanceMiles ?? '未登记'], ['油耗（L/100km）', row?.operations.fuelConsumptionLitresPer100Km ?? '未登记']]
+})
+function time(value: string | null | undefined) { return value && dayjs(value).isValid() ? dayjs(value).format('YYYY-MM-DD HH:mm') : '—' }
+function destinationLabel(key: string) { const value = detail.value?.row.destinations.find(destination => destination.destinationKey === key); return value?.warehouseCode || value?.warehouseName || value?.address || '—' }
+function photoLabel(photo: OwnedBusinessPhoto) { return ownedBusinessPhotoRoles.find(role => role.slot === photo.slot)?.label || '照片' }
+async function load() {
+  if (!active) return
+  const request = ++generation, no = dispatchNo.value; loading.value = true; error.value = null
+  try { if (!no || !access.can(permission.ownedBusinessList)) throw new Error('缺少排车业务号或查看权限'); const value = await getOwnedBusiness(no); if (active && request === generation) { if (value.row.dispatchNo !== no) throw new Error('当前运营资料与排车业务号不一致'); detail.value = value; if (activeTab.value === 'history') void loadHistory() } }
+  catch (cause) { if (active && request === generation) { detail.value = null; error.value = getApiErrorDetails(cause, '自有业务详情读取失败') } }
+  finally { if (request === generation) loading.value = false }
+}
+async function loadHistory() {
+  if (!active || activeTab.value !== 'history' || !detail.value) return
+  const request = ++historyGeneration, no = dispatchNo.value; historyLoading.value = true; historyError.value = null
+  try { const value = await listOwnedBusinessHistory(no, historyPage.value, historySize.value); if (active && request === historyGeneration && no === dispatchNo.value) { history.value = value.records; historyTotal.value = value.total } }
+  catch (cause) { if (request === historyGeneration) historyError.value = getApiErrorDetails(cause, '操作记录读取失败') }
+  finally { if (request === historyGeneration) historyLoading.value = false }
+}
+async function preview(photo: OwnedBusinessPhoto, revision: string | null) {
+  const no = dispatchNo.value, request = generation; previewError.value = null
+  if (revision == null) { previewError.value = { message: '历史照片缺少运营资料版本，请重新读取' }; return }
+  const windowRef = window.open('', '_blank')
+  if (!windowRef) { previewError.value = { message: '请允许本站打开图片预览窗口' }; return }
+  try { const blob = await getOwnedBusinessPhotoContent(no, photo, revision); if (!active || request !== generation || no !== dispatchNo.value) { windowRef.close(); return }; const url = URL.createObjectURL(blob); previewUrls.add(url); windowRef.location.href = url }
+  catch (cause) { windowRef.close(); previewError.value = getApiErrorDetails(cause, '历史照片读取失败') }
+}
+function saved(value: OwnedBusinessDetail) { if (value.row.dispatchNo !== dispatchNo.value) return; detail.value = value; if (activeTab.value === 'history') void loadHistory() }
+watch([activeTab,historyPage,historySize], () => { if (active) void loadHistory() })
+watch(dispatchNo, () => { generation++; historyGeneration++; detail.value = null; history.value = []; historyTotal.value = 0; activeTab.value = 'task'; editorOpen.value = false; photosOpen.value = false; if (active) void load() })
+onMounted(load)
+onActivated(() => { active = true; if (initialActivation) initialActivation = false; else void load() })
+onDeactivated(() => { active = false; generation++; historyGeneration++; loading.value = false; historyLoading.value = false; editorOpen.value = false; photosOpen.value = false })
+onBeforeUnmount(() => { active = false; generation++; historyGeneration++; previewUrls.forEach(url => URL.revokeObjectURL(url)) })
+</script>
+
+<template>
+  <OwnedBusinessDetailLayout v-model:active-tab="activeTab" :dispatch-no="detail?.row.dispatchNo || dispatchNo" :status-text="detail ? ownedBusinessStages[detail.row.stage] : ''" :loading="loading" @back="router.push('/overseas-master-data/owned-business')">
+    <template #actions><el-button v-if="detail && access.can(permission.ownedBusinessEdit)" class="density-action" :disabled="busy || !detail.row.actions.edit.allowed" @click="editorOpen = true">登记运营信息</el-button><el-button v-if="detail" class="density-action" :disabled="busy" @click="photosOpen = true">{{ access.can(permission.ownedBusinessUpload) && detail.row.actions.upload.allowed ? '上传照片' : '查看照片' }}</el-button></template>
+    <template #state><LoadErrorState v-if="error" title="自有业务详情读取失败" :message="error.message" @retry="load"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState><p v-for="issue in detail?.row.sourceIssues || []" :key="issue">{{ issue }}</p></template>
+    <template #task><dl v-if="detail" class="density-fields owned-business-fields"><div v-for="field in taskFields" :key="field[0]"><dt>{{ field[0] }}</dt><dd>{{ field[1] }}</dd></div></dl></template>
+    <template #route><template v-if="detail"><section v-for="destination in detail.row.destinations" :key="destination.destinationKey" class="owned-business-route"><h3>{{ destination.warehouseCode || destination.warehouseName || destination.address || '目的地资料缺失' }}</h3><p v-if="destination.address">{{ destination.address }}</p><p v-for="appointment in destination.appointments" :key="appointment.appointmentNo">预约号 {{ appointment.appointmentNo }} · 确认号 {{ text(appointment.confirmationNo) }} · 预约到达 {{ time(appointment.scheduledAt) }}</p><p>实际到达 {{ time(destination.actualArrivedAt) }}</p></section><DataTable :data="detail.cargo" :columns="cargoColumns" row-key="sourceKey" column-settings-mode="hide" empty-text="暂无真实货物明细"><template #destination="{ row }">{{ destinationLabel(row.destinationKey) }}</template></DataTable><section class="owned-business-route"><h3>原排车关联单据</h3><p>出库单：{{ detail.dispatch.documents.outbounds.map(item => item.outboundNo).join('、') || '—' }}</p><p>派送单：{{ detail.dispatch.documents.deliveries.map(item => item.deliveryNo).join('、') || '—' }}</p><el-button @click="photosOpen = true">查看分类照片</el-button></section></template></template>
+    <template #history><LoadErrorState v-if="historyError" title="操作记录读取失败" :message="historyError.message" @retry="loadHistory"><template #details><ApiErrorMeta :details="historyError" /></template></LoadErrorState><LoadErrorState v-if="previewError" title="历史照片读取失败" :message="previewError.message" :show-retry="false"><template #details><ApiErrorMeta :details="previewError" /></template></LoadErrorState><DataTable v-model:page="historyPage" v-model:page-size="historySize" :data="historyRows" :columns="historyColumns" :total="historyTotal" :loading="historyLoading" row-key="eventKey" empty-text="暂无操作记录"><template #source="{ row }">{{ row.eventSource === 'DISPATCH' ? '原排车' : '运营登记' }}</template><template #action="{ row }">{{ ownedBusinessActionLabels[row.action] || '其他操作' }}</template><template #occurredAt="{ row }">{{ time(row.occurredAt) }}</template><template #snapshot="{ row }"><template v-if="row.operations"><p>整车金额 {{ row.operations.money ? row.operations.money.currency + ' ' + row.operations.money.amount : '未登记' }}</p><p>里程 {{ row.operations.actualDistanceMiles ?? '未登记' }} mile · 油耗 {{ row.operations.fuelConsumptionLitresPer100Km ?? '未登记' }} L/100km</p><div v-for="arrival in row.operations.arrivals" :key="arrival.destinationKey">{{ destinationLabel(arrival.destinationKey) }} · {{ time(arrival.actualArrivedAt) }}</div></template><span v-else>—</span></template><template #photos="{ row }"><el-button v-for="photo in row.photos" :key="photo.slot" link @click="preview(photo, row.recordVersion)">{{ photoLabel(photo) }}</el-button></template></DataTable></template>
+  </OwnedBusinessDetailLayout>
+  <OwnedBusinessOperationsEditor v-model="editorOpen" :detail="detail" @busy="busy = $event" @saved="saved" />
+  <OwnedBusinessPhotosEditor v-model="photosOpen" :detail="detail" @busy="busy = $event" @saved="saved" />
+</template>
+
+<style scoped>
+.owned-business-fields { display: grid; grid-template-columns: repeat(4,minmax(0,1fr)); padding: var(--admin-space-4); }
+.owned-business-fields > div { min-width: 0; overflow-wrap: anywhere; }
+.owned-business-route { padding: var(--admin-space-4); border-bottom: 1px solid var(--admin-table-border); }
+.owned-business-route h3 { font-size: inherit; margin: 0 0 var(--admin-space-3); }
+</style>

src/modules/overseas-master-data/pages/OwnedBusinessView.vue

@@ -0,0 +1,115 @@
+<script setup lang="ts">
+import { computed, onActivated, onBeforeUnmount, onDeactivated, onMounted, ref, watch } from 'vue'
+import { useRouter } from 'vue-router'
+import dayjs from 'dayjs'
+import { useAccessPreviewStore } from '@/core/access/accessPreview'
+import { listAllPlatformWarehouses } from '@/modules/warehouses'
+import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
+import QueryToolbar, { type QueryField, type QueryModel, type QueryOption } from '@/shared/components/QueryToolbar.vue'
+import DataTable, { type DataTableColumn } from '@/shared/components/DataTable.vue'
+import LoadErrorState from '@/shared/components/LoadErrorState.vue'
+import ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
+import OwnedBusinessListLayout from '../components/OwnedBusinessListLayout.vue'
+import OwnedBusinessOperationsEditor from '../components/OwnedBusinessOperationsEditor.vue'
+import OwnedBusinessPhotosEditor from '../components/OwnedBusinessPhotosEditor.vue'
+import { getOwnedBusiness, listOwnedBusiness } from '../api/ownedBusiness'
+import { ownedBusinessStages, ownedBusinessText as text, type OwnedBusinessDetail, type OwnedBusinessList, type OwnedBusinessQuery, type OwnedBusinessRow, type OwnedBusinessStage } from '../ownedBusinessTypes'
+import { overseasMasterDataPermissions as permission } from '../permissions'
+
+const router = useRouter(), access = useAccessPreviewStore()
+const result = ref<OwnedBusinessList | null>(null), page = ref(1), size = ref(20), loading = ref(false), error = ref<ApiErrorDetails | null>(null)
+const filters = ref<QueryModel>({ plannedRange: [], keyword: '', stage: '', warehouseId: '' })
+const warehouseOptions = ref<QueryOption[]>([]), warehouseError = ref<ApiErrorDetails | null>(null)
+const detail = ref<OwnedBusinessDetail | null>(null), editorOpen = ref(false), photosOpen = ref(false), opening = ref(false), mutating = ref(false)
+let applied: Omit<OwnedBusinessQuery,'page'|'size'> = {}, generation = 0, openGeneration = 0, active = true, initialActivation = true
+const fields = computed<QueryField[]>(() => [
+  { key: 'plannedRange', type: 'daterange', label: '计划发车日期', width: 270, props: { valueFormat: 'YYYY-MM-DD', 'aria-label': '计划发车日期范围' } },
+  { key: 'keyword', type: 'input', label: '关键词', width: 230, placeholder: '排车单号 / 车牌 / 目的仓', props: { maxlength: 128 } },
+  { key: 'stage', type: 'select', label: '阶段', width: 140, options: Object.entries(ownedBusinessStages).map(([value,label]) => ({ value,label })) },
+  { key: 'warehouseId', type: 'select', label: '提货仓库', width: 180, options: warehouseOptions.value, props: { disabled: !access.can('platform:warehouse:list') } },
+])
+const summary = computed(() => [
+  ['排车数', result.value?.summary.dispatchCount], ['装车完成', result.value?.summary.afterLoadingCount], ['派送中', result.value?.summary.deliveringCount], ['派送完成', result.value?.summary.deliveredCount],
+])
+const columns: DataTableColumn[] = [
+  { key: 'actions', label: '操作', width: 245, fixed: 'left', slotName: 'actions' },
+  { key: 'appointments', label: '预约号', minWidth: 195, slotName: 'appointments' }, { prop: 'dispatchNo', label: '排车单号', minWidth: 300 },
+  { prop: 'vehicle.plate', label: '车牌', minWidth: 130 }, { key: 'driver', label: '司机', minWidth: 150, slotName: 'driver' }, { prop: 'origin.warehouseName', label: '提货仓库', minWidth: 150 },
+  { key: 'destinations', label: '目的仓 / 预约到达 / 实际到达', minWidth: 285, slotName: 'destinations' },
+  { key: 'fuel', label: '油耗（L/100km）', minWidth: 145, slotName: 'fuel' }, { prop: 'actualPalletCount', label: '实际托数', minWidth: 105 },
+  { key: 'money', label: '整车总金额 / 单价', minWidth: 170, slotName: 'money' },
+  { key: 'plannedDepartureAt', label: '计划发车时间', minWidth: 180, slotName: 'plannedDeparture' }, { key: 'loadingCompletedAt', label: '实际装车完成时间', minWidth: 180, slotName: 'loaded' },
+  { key: 'stage', label: '阶段', minWidth: 110, slotName: 'stage' },
+]
+function time(value: string | null | undefined) { return value && dayjs(value).isValid() ? dayjs(value).format('YYYY-MM-DD HH:mm') : '—' }
+async function load() {
+  if (!active) return
+  const request = ++generation
+  loading.value = true; error.value = null
+  try {
+    if (!access.can(permission.ownedBusinessList)) throw new Error('没有自有业务查看权限')
+    const value = await listOwnedBusiness({ ...applied, page: page.value, size: size.value })
+    if (active && request === generation) result.value = value
+  } catch (cause) { if (active && request === generation) { result.value = null; error.value = getApiErrorDetails(cause, '自有业务读取失败') } }
+  finally { if (request === generation) loading.value = false }
+}
+function search() {
+  try {
+    const range = filters.value.plannedRange
+    const dates = Array.isArray(range) ? range : []
+    if (dates.length && (dates.length !== 2 || !dayjs(String(dates[0])).isValid() || !dayjs(String(dates[1])).isValid() || dayjs(String(dates[1])).isBefore(dayjs(String(dates[0]))))) throw new Error('请选择有效的计划发车日期范围')
+    applied = { keyword: String(filters.value.keyword || '').trim() || undefined, stage: (filters.value.stage || undefined) as OwnedBusinessStage | undefined, warehouseId: String(filters.value.warehouseId || '') || undefined,
+      plannedDepartureFrom: dates.length ? dayjs(String(dates[0])).startOf('day').toISOString() : undefined, plannedDepartureTo: dates.length ? dayjs(String(dates[1])).add(1,'day').startOf('day').toISOString() : undefined }
+    if (page.value !== 1) page.value = 1; else void load()
+  } catch (cause) { error.value = getApiErrorDetails(cause, '筛选条件无效') }
+}
+async function loadWarehouses() {
+  if (!access.can('platform:warehouse:list')) return
+  try { const values = await listAllPlatformWarehouses({ warehouseType: 'OVERSEAS', status: 'ACTIVE' }); warehouseOptions.value = values.map(value => ({ value: String(value.id), label: value.warehouseName })) }
+  catch (cause) { warehouseError.value = getApiErrorDetails(cause, '仓库目录读取失败，可继续使用其他筛选') }
+}
+async function openAction(row: OwnedBusinessRow, kind: 'operations' | 'photos') {
+  if (opening.value || mutating.value) return
+  const code = kind === 'operations' ? permission.ownedBusinessEdit : permission.ownedBusinessList
+  if (!access.can(code) || kind === 'operations' && !row.actions.edit.allowed) return
+  const request = ++openGeneration; opening.value = true; error.value = null
+  try { const value = await getOwnedBusiness(row.dispatchNo); if (!active || request !== openGeneration) return; detail.value = value; if (kind === 'operations') editorOpen.value = true; else photosOpen.value = true }
+  catch (cause) { if (request === openGeneration) error.value = getApiErrorDetails(cause, '当前运营资料读取失败') }
+  finally { if (request === openGeneration) opening.value = false }
+}
+function saved(value: OwnedBusinessDetail) { detail.value = value; void load() }
+watch([page,size], () => { if (active) void load() })
+onMounted(() => { void load(); void loadWarehouses() })
+onActivated(() => { active = true; if (initialActivation) initialActivation = false; else void load() })
+onDeactivated(() => { active = false; generation++; openGeneration++; loading.value = false; opening.value = false; editorOpen.value = false; photosOpen.value = false })
+onBeforeUnmount(() => { active = false; generation++; openGeneration++ })
+</script>
+
+<template>
+  <OwnedBusinessListLayout>
+    <template #statistics><section class="owned-business-statistics" aria-label="完整筛选范围自有业务统计" :aria-busy="loading"><div v-for="item in summary" :key="String(item[0])"><span>{{ item[0] }}</span><strong>{{ item[1] ?? '—' }}</strong></div></section></template>
+    <DataTable appearance="integrated" :stripe="false" v-model:page="page" v-model:page-size="size" :data="result?.records || []" :columns="columns" :total="result?.total || 0" :loading="loading" row-key="dispatchNo" preference-key="owned-business-table" empty-text="当前筛选范围暂无已装车的自有车辆排车单">
+      <template #toolbar-start><h1>自有业务</h1></template>
+      <template #filters><QueryToolbar v-model="filters" :fields="fields" ariaLabel="自有业务筛选" preference-key="owned-business-query" :loading="loading" @search="search" /><small>日期和时间按浏览器本地时区显示；统计覆盖同一完整筛选范围。</small></template>
+      <template #notices><LoadErrorState v-if="error" title="自有业务读取未完成" :message="error.message" @retry="load"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState><p v-if="warehouseError">{{ warehouseError.message }} <el-button link @click="loadWarehouses">重试目录</el-button></p><p v-if="!access.can('platform:warehouse:list')">没有公共仓库目录读取权限，仓库筛选暂不可选。</p></template>
+      <template #actions="{ row }"><div class="density-actions"><el-button class="density-action" link @click="router.push(`/overseas-master-data/owned-business/${encodeURIComponent(row.dispatchNo)}`)">查看明细</el-button><el-button v-if="access.can(permission.ownedBusinessEdit)" class="density-action" link :disabled="opening || mutating || !row.actions.edit.allowed" @click="openAction(row as OwnedBusinessRow, 'operations')">登记运营信息</el-button><el-button class="density-action" link :disabled="opening || mutating" @click="openAction(row as OwnedBusinessRow, 'photos')">{{ access.can(permission.ownedBusinessUpload) && row.actions.upload.allowed ? '上传照片' : '查看照片' }}</el-button></div></template>
+      <template #driver="{ row }">{{ text(row.driver.name) }}<br>{{ text(row.driver.phone) }}</template>
+      <template #appointments="{ row }"><div v-for="destination in row.destinations" :key="destination.destinationKey" class="owned-business-destination"><strong>{{ destination.warehouseCode || destination.warehouseName || '—' }}</strong><div v-for="appointment in destination.appointments" :key="appointment.appointmentNo">{{ appointment.appointmentNo }}<small v-if="appointment.confirmationNo">确认号 {{ appointment.confirmationNo }}</small></div><span v-if="!destination.appointments.length">—</span></div></template>
+      <template #destinations="{ row }"><div v-for="destination in row.destinations" :key="destination.destinationKey" class="owned-business-destination"><strong>{{ destination.warehouseCode || destination.warehouseName || destination.address || '—' }}</strong><div v-for="appointment in destination.appointments" :key="appointment.appointmentNo">预约 {{ time(appointment.scheduledAt) }}</div><div>实到 {{ time(destination.actualArrivedAt) }}</div></div></template>
+      <template #fuel="{ row }">{{ row.operations.fuelConsumptionLitresPer100Km ?? '未登记' }}</template>
+      <template #money="{ row }"><template v-if="row.operations.money">{{ row.operations.money.currency }} {{ row.operations.money.amount }}<br>单价 {{ row.unitPrice ?? '—' }}</template><span v-else>未登记</span></template>
+      <template #plannedDeparture="{ row }">{{ time(row.plannedDepartureAt) }}</template><template #loaded="{ row }">{{ time(row.loadingCompletedAt) }}</template><template #stage="{ row }">{{ ownedBusinessStages[row.stage as OwnedBusinessStage] }}</template>
+    </DataTable>
+    <OwnedBusinessOperationsEditor v-model="editorOpen" :detail="detail" @busy="mutating = $event" @saved="saved" />
+    <OwnedBusinessPhotosEditor v-model="photosOpen" :detail="detail" @busy="mutating = $event" @saved="saved" />
+  </OwnedBusinessListLayout>
+</template>
+
+<style scoped>
+.owned-business-statistics { display: grid; grid-template-columns: repeat(4,minmax(0,1fr)); background: white; border: 1px solid var(--admin-table-border); }
+.owned-business-statistics > div { padding: var(--admin-space-4) var(--admin-space-5); border-right: 1px solid var(--admin-table-border); }
+.owned-business-statistics > div:last-child { border-right: 0; }
+.owned-business-statistics strong { display: block; margin-top: var(--admin-space-2); font-size: var(--admin-font-title); }
+.owned-business-destination + .owned-business-destination { margin-top: var(--admin-space-3); border-top: 1px solid var(--admin-table-border); padding-top: var(--admin-space-3); }
+.owned-business-destination small { display: block; }
+</style>

src/modules/overseas-master-data/pages/OwnedBusinessViews.test.ts

@@ -0,0 +1,85 @@
+import { defineComponent, h } from 'vue'
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import dayjs from 'dayjs'
+import OwnedBusinessView from './OwnedBusinessView.vue'
+import OwnedBusinessDetailView from './OwnedBusinessDetailView.vue'
+import { ownedBusinessFixture } from '../components/OwnedBusinessFixtures'
+import { overseasMasterDataPermissions as permission } from '../permissions'
+
+const calls = vi.hoisted(() => ({ list: vi.fn(), detail: vi.fn(), history: vi.fn(), content: vi.fn(), warehouses: vi.fn(), push: vi.fn(), allowed: new Set<string>() }))
+vi.mock('../api/ownedBusiness', () => ({ listOwnedBusiness: calls.list, getOwnedBusiness: calls.detail, listOwnedBusinessHistory: calls.history, getOwnedBusinessPhotoContent: calls.content }))
+vi.mock('@/modules/warehouses', () => ({ listAllPlatformWarehouses: calls.warehouses }))
+vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can: (code: string) => calls.allowed.has(code) }) }))
+vi.mock('vue-router', () => ({ useRouter: () => ({ push: calls.push }), useRoute: () => ({ params: { dispatchNo: 'DS-OWN-1' } }) }))
+const Surface = defineComponent({ template: '<section><slot name="header" /><slot /></section>' })
+const Button = defineComponent({ props: ['disabled'], template: '<button :disabled="disabled"><slot /></button>' })
+const Tabs = defineComponent({ props: ['modelValue'], emits: ['update:modelValue'], template: '<div><slot /></div>' })
+const Pane = defineComponent({ props: ['name','label'], template: '<article><slot /></article>' })
+const Query = defineComponent({ props: ['modelValue','fields'], emits: ['update:modelValue','search'], template: '<div />' })
+const Table = defineComponent({ props: ['data','columns','total','page','pageSize'], emits: ['update:page','update:pageSize'], setup(props,{slots}) { return () => h('div', [slots['toolbar-start']?.(), slots.filters?.(), slots.notices?.(), ...(props.data || []).map((row: object) => h('div', Object.entries(slots).filter(([name]) => !['toolbar-start','filters','notices'].includes(name)).map(([,slot]) => slot?.({row}))))]) } })
+const Editor = defineComponent({ props: ['modelValue','detail'], emits: ['update:modelValue','saved','busy'], template: '<div />' })
+const global = { stubs: { AdminPage: Surface, DetailPageLayout: Surface, DataTable: Table, QueryToolbar: Query, ElTabs: Tabs, ElTabPane: Pane, ElButton: Button, OwnedBusinessOperationsEditor: Editor, OwnedBusinessPhotosEditor: Editor, LoadErrorState: { props:['message'], template:'<div>{{message}}<slot name="details" /></div>' }, ApiErrorMeta: true }, directives: { loading: () => {} } }
+
+beforeEach(() => {
+  vi.clearAllMocks(); calls.allowed = new Set(Object.values(permission)); calls.allowed.add('platform:warehouse:list')
+  const detail = ownedBusinessFixture()
+  calls.list.mockResolvedValue({ records:[detail.row],page:1,size:20,total:41,summary:{dispatchCount:41,afterLoadingCount:30,deliveringCount:10,deliveredCount:1} })
+  calls.detail.mockResolvedValue(detail); calls.history.mockResolvedValue({records:[],page:1,size:20,total:0}); calls.warehouses.mockResolvedValue([])
+})
+
+describe('owned business views', () => {
+  it('uses one list request for all statistics and never hydrates each row', async () => {
+    const wrapper = mount(OwnedBusinessView,{global}); await flushPromises()
+    expect(calls.list).toHaveBeenCalledTimes(1); expect(calls.detail).not.toHaveBeenCalled(); expect(calls.content).not.toHaveBeenCalled()
+    expect(wrapper.find('[aria-label="完整筛选范围自有业务统计"]').text()).toContain('排车数41')
+    expect(wrapper.text()).not.toContain('今日排车')
+    expect(wrapper.findComponent(Table).props('columns')[0].key).toBe('actions')
+    expect(wrapper.findComponent(Table).props('total')).toBe(41)
+    wrapper.unmount()
+  })
+  it('applies planned date half-open boundaries only on query and keeps all stage counts from the response', async () => {
+    const wrapper=mount(OwnedBusinessView,{global});await flushPromises();const query=wrapper.findComponent(Query)
+    query.vm.$emit('update:modelValue',{plannedRange:['2026-10-20','2026-10-21'],keyword:' FBA-1 ',stage:'AFTER_LOADING',warehouseId:'1'});await wrapper.vm.$nextTick()
+    expect(calls.list).toHaveBeenCalledTimes(1)
+    query.vm.$emit('search');await flushPromises()
+    expect(calls.list).toHaveBeenLastCalledWith({page:1,size:20,keyword:'FBA-1',stage:'AFTER_LOADING',warehouseId:'1',plannedDepartureFrom:dayjs('2026-10-20').startOf('day').toISOString(),plannedDepartureTo:dayjs('2026-10-21').add(1,'day').startOf('day').toISOString()})
+    expect(wrapper.find('[aria-label="完整筛选范围自有业务统计"]').text()).toContain('装车完成30')
+    wrapper.unmount()
+  })
+  it('opens the operations modal on demand with auxiliary zero version instead of the dispatch version', async () => {
+    const wrapper=mount(OwnedBusinessView,{global});await flushPromises()
+    await wrapper.findAll('button').find(button=>button.text()==='登记运营信息')!.trigger('click');await flushPromises()
+    expect(calls.detail).toHaveBeenCalledExactlyOnceWith('DS-OWN-1')
+    const editor=wrapper.findAllComponents(Editor).find(child=>child.props('modelValue'))!
+    expect(editor.props('detail').row.recordVersion).toBe('0');expect(editor.props('detail').dispatch.recordVersion).toBe('8')
+    wrapper.unmount()
+  })
+  it('keeps a list-only user read-only while retaining detail and authorized photo reads', async () => {
+    calls.allowed=new Set([permission.ownedBusinessList])
+    const wrapper=mount(OwnedBusinessView,{global});await flushPromises()
+    expect(wrapper.text()).not.toContain('登记运营信息');expect(wrapper.text()).toContain('查看照片');expect(calls.warehouses).not.toHaveBeenCalled()
+    wrapper.unmount()
+  })
+  it('loads aggregated history only on its tab, preserving null operations on dispatch events', async () => {
+    calls.history.mockResolvedValue({records:[{eventSource:'DISPATCH',recordVersion:null,dispatchRecordVersion:'8',action:'LOADING_COMPLETE',operatorName:null,occurredAt:'2026-10-20T09:00:00Z',reason:null,operations:null,photos:[]},{eventSource:'OPERATIONS',recordVersion:'1',dispatchRecordVersion:null,action:'SAVE_OPERATIONS',operatorName:'登记员',occurredAt:'2026-10-20T10:00:00Z',reason:null,operations:ownedBusinessFixture().row.operations,photos:[]}],page:1,size:20,total:2})
+    const wrapper=mount(OwnedBusinessDetailView,{global});await flushPromises()
+    expect(calls.detail).toHaveBeenCalledTimes(1);expect(calls.history).not.toHaveBeenCalled()
+    wrapper.findComponent(Tabs).vm.$emit('update:modelValue','history');await flushPromises()
+    expect(calls.history).toHaveBeenCalledExactlyOnceWith('DS-OWN-1',1,20)
+    expect(wrapper.text()).toContain('原排车');expect(wrapper.text()).toContain('运营登记')
+    const table=wrapper.findComponent(Table), records=table.props('data')
+    expect(records[0].eventKey).not.toBe(records[1].eventKey);expect(records[0].operations).toBeNull()
+    table.vm.$emit('update:page',2);await flushPromises();expect(calls.history).toHaveBeenLastCalledWith('DS-OWN-1',2,20)
+    expect(calls.detail).toHaveBeenCalledTimes(1);expect(calls.content).not.toHaveBeenCalled()
+    wrapper.unmount()
+  })
+  it('shows authoritative large money text and unit price without rounding or recomputing from two cargo rows', async () => {
+    const detail=ownedBusinessFixture();detail.row.operations.money={currency:'USD',amount:'9999999999999999.99'};detail.row.unitPrice='9999999999999999.99'
+    calls.detail.mockResolvedValue(detail)
+    const wrapper=mount(OwnedBusinessDetailView,{global});await flushPromises()
+    expect(wrapper.text()).toContain('USD 9999999999999999.99');expect(wrapper.text()).not.toContain('10000000000000000')
+    expect(wrapper.text()).not.toContain('4999999999999999')
+    wrapper.unmount()
+  })
+})

src/modules/overseas-master-data/routes.test.ts

@@ -11,6 +11,8 @@ describe('overseas master data routes', () => {
       ['overseas-master-data/capacity-offers/:offerNo', overseasMasterDataPermissions.capacityOfferList],
       ['overseas-master-data/fleet-quotes', overseasMasterDataPermissions.fleetQuoteList],
       ['overseas-master-data/trip-operations', overseasMasterDataPermissions.operationsList],
+      ['overseas-master-data/owned-business', overseasMasterDataPermissions.ownedBusinessList],
+      ['overseas-master-data/owned-business/:dispatchNo', overseasMasterDataPermissions.ownedBusinessList],
       ['overseas-master-data/trips', overseasMasterDataPermissions.tripList],
       ['overseas-master-data/trips/:tripNo', overseasMasterDataPermissions.tripList],
       ['overseas-master-data/drivers', overseasMasterDataPermissions.driverList],
@@ -31,6 +33,18 @@ describe('overseas master data routes', () => {
     }
   })
 
+  it('uses one list permission for owned-business list and independent detail without granting writes', () => {
+    const owned = overseasMasterDataRoutes.filter(route => route.path.includes('/owned-business'))
+    expect(owned).toHaveLength(2)
+    expect(owned.map(route => route.path)).toContain('overseas-master-data/owned-business/:dispatchNo')
+    for (const route of owned) {
+      expect(route.meta?.permission).toBe(overseasMasterDataPermissions.ownedBusinessList)
+      expect(route.meta?.permissionAnyOf).toBeUndefined()
+      expect(route.meta?.permission).not.toBe(overseasMasterDataPermissions.ownedBusinessEdit)
+      expect(route.meta?.permission).not.toBe(overseasMasterDataPermissions.ownedBusinessUpload)
+    }
+  })
+
   it('keeps vehicle detail as a route page and does not add a duplicate partner warehouse route', () => {
     expect(overseasMasterDataRoutes.at(-1)?.meta?.showPageHeading).toBe(false)
     expect(overseasMasterDataRoutes.some((route) => route.path.includes('partner-warehouse'))).toBe(false)

src/modules/overseas-master-data/routes.ts

@@ -26,6 +26,18 @@ export const overseasMasterDataRoutes = [
     component: () => import('./pages/TripOperationsView.vue'),
     meta: { title: '出车记录', description: '按实际发车记录查询车辆运营统计', permission: permission.operationsList, showPageHeading: false },
   },
+  {
+    path: 'overseas-master-data/owned-business',
+    name: 'overseas-master-data-owned-business',
+    component: () => import('./pages/OwnedBusinessView.vue'),
+    meta: { title: '自有业务', description: '查看自有车辆装车后的排车与运营记录', permission: permission.ownedBusinessList, showPageHeading: false },
+  },
+  {
+    path: 'overseas-master-data/owned-business/:dispatchNo',
+    name: 'overseas-master-data-owned-business-detail',
+    component: () => import('./pages/OwnedBusinessDetailView.vue'),
+    meta: { title: '自有业务详情', description: '查看原排车事实与附加运营信息', permission: permission.ownedBusinessList, showPageHeading: false },
+  },
   {
     path: 'overseas-master-data/trips',
     name: 'overseas-master-data-trips',