pda-overseas-uniapp/src/api/fulfillment.js

import { overseasRequest, overseasUpload, overseasDownload } from './overseas.js'

const DISPATCH_BASE = '/pda/v1/last-leg/dispatches'
const OUTBOUND_BASE = '/pda/v1/last-leg/outbound-tasks'
const CARGO_DISCARD_BASE = '/pda/v1/last-leg/cargo-discards'
const STORAGE_PREPARATION_BASE = '/pda/v1/last-leg/storage-rent/preparations'

const encoded = (value) => encodeURIComponent(String(value || '').trim())

function asList(value) {
	if (Array.isArray(value)) return value
	if (Array.isArray(value?.records)) return value.records
	if (Array.isArray(value?.items)) return value.items
	return []
}

function count(value) {
	const number = Number(value || 0)
	return Number.isFinite(number) ? Math.max(0, number) : 0
}

export function requireDispatchVersion(value) {
	if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0) return value
	if (typeof value === 'string' && /^\d+$/.test(value)) return value
	throw new Error('排车操作版本缺失或无效，请刷新任务')
}

export function dispatchVersionAtLeast(current, confirmed) {
 const latest = String(requireDispatchVersion(current)).replace(/^0+(?=\d)/, '')
 const original = String(requireDispatchVersion(confirmed)).replace(/^0+(?=\d)/, '')
 return latest.length > original.length || latest.length === original.length && latest >= original
}

function dispatchCount(value) {
 if (typeof value !== 'number' && (typeof value !== 'string' || !/^(?:0|[1-9]\d*)$/.test(value))) throw new Error('排车数量不是有效非负整数，请重新读取任务')
 const number = typeof value === 'number' ? value : Number(value)
 if (!Number.isSafeInteger(number) || number < 0) throw new Error('排车数量超出安全整数范围或无效，请重新读取任务')
 return number
}

export function normalizeDispatchTask(value) {
	if (!value || !value.dispatchNo || !Array.isArray(value.items)) throw new Error('排车任务返回结构不完整')
	return {
		...value, taskNo: String(value.taskNo || ''), dispatchNo: String(value.dispatchNo),
		recordVersion: value.recordVersion, pickingReconciled: value.pickingReconciled === true,
		actions: Object.fromEntries(Object.entries(value.actions || {}).map(([key, gate]) => [key, { ...gate, allowed: gate?.allowed === true }])),
		items: value.items.map(item => ({ ...item, dispatchItemId: String(item.dispatchItemId || ''), sourceKey: String(item.sourceKey || ''), sourceBusinessType: item.sourceBusinessType == null ? null : String(item.sourceBusinessType), sourceBusinessNo: item.sourceBusinessNo == null ? null : String(item.sourceBusinessNo), palletNo: String(item.palletNo || ''),
			scheduledPackages: dispatchCount(item.scheduledPackages), pickedPackages: dispatchCount(item.pickedPackages),
			returnCartons: (item.returnCartons || []).map(carton => ({ ...carton, returnCartonId: String(carton.returnCartonId || ''), cartonMark: String(carton.cartonMark || ''), productQuantity: dispatchCount(carton.productQuantity) })),
			positions: (item.positions || []).map(position => ({ ...position, positionId: String(position.positionId || ''), balanceId: String(position.balanceId || ''), availablePackages: dispatchCount(position.availablePackages), allocatedPackages: dispatchCount(position.allocatedPackages), pickedPackages: dispatchCount(position.pickedPackages) }))
		}))
	}
}

export function normalizeOutboundTask(value) {
	const header = value?.task || value || {}
	return {
		...header,
		taskNo: String(header?.taskNo || ''),
		outboundNo: String(header?.outboundNo || ''),
		outboundType: String(header?.outboundType || ''),
		status: String(header?.status || ''),
		items: asList(value?.items).map((item) => ({
			...item,
			outboundPalletItemId: String(item?.outboundPalletItemId || ''),
			palletNo: String(item?.palletNo || ''),
			plannedPackages: count(item?.packageCount),
			pickedPackages: count(item?.pickedPackageCount),
			positions: asList(item?.positions).map((position) => ({
				...position,
				inventoryPositionId: String(position?.inventoryPositionId || ''),
				palletNo: String(position?.palletNo || item?.palletNo || ''),
				cartonMark: String(position?.cartonMark || ''),
				skuCode: String(position?.skuCode || position?.sku || ''),
				inboundCode: String(position?.inboundCode || ''),
				availablePackages: count(position?.availablePackages),
				pickedPackages: count(position?.pickedPackages)
			}))
		}))
	}
}

export async function listDispatchTasks() {
	const result = await overseasRequest('GET', DISPATCH_BASE)
	if (!Array.isArray(result)) throw new Error('排车任务列表返回结构无效')
	return result.map(normalizeDispatchTask)
}
export async function getDispatchTask(dispatchNo) {
	return normalizeDispatchTask(await overseasRequest('GET', `${DISPATCH_BASE}/${encoded(dispatchNo)}`))
}
export function getDispatchLoading(dispatchNo) {
	return overseasRequest('GET', `${DISPATCH_BASE}/${encoded(dispatchNo)}/loading`)
}
export function getDispatchCommand(dispatchNo, key) {
	return overseasRequest('GET', `${DISPATCH_BASE}/${encoded(dispatchNo)}/commands/${encoded(key)}`)
}
function dispatchWrite(path, request) {
	requireDispatchVersion(request?.recordVersion)
	return overseasRequest('POST', path, request)
}
async function prepareStorageRent(mode, businessNo, request, extra = {}) {
	try {
		if (!request?.idempotencyKey) throw new Error('出库请求标识缺失，请重新进入任务')
		const result = await overseasRequest('POST', STORAGE_PREPARATION_BASE, {
			mode, businessNo, idempotencyKey: request.idempotencyKey, ...extra
		})
		if (result?.ready !== true || !['NOT_REQUIRED', 'READY', 'CONSUMED'].includes(result?.status)) {
			const error = new Error(result?.message || (result?.status === 'FREEZE_PENDING' ? '费用确认中，请稍后重试' : '费用尚未确认，请稍后重试'))
			error.code = `STORAGE_RENT_${result?.status || 'INVALID_RESPONSE'}`
			throw error
		}
	} catch (cause) {
		// 预扣可能已受理，保留完整原请求及幂等键继续核对。
		cause.storageRentPreparation = true
		throw cause
	}
}

export async function pickDispatchItem(dispatchNo, dispatchItemId, request) {
	requireDispatchVersion(request?.recordVersion)
	await prepareStorageRent('DISPATCH', dispatchNo, request, {
		itemId: dispatchItemId, positionId: request.positionId, packages: request.packages,
		cartonMark: request.cartonMark, productQuantity: request.productQuantity
	})
	return dispatchWrite(`${DISPATCH_BASE}/${encoded(dispatchNo)}/items/${encoded(dispatchItemId)}/pick`, request)
}
export function completeDispatchLoading(dispatchNo, request) {
	return dispatchWrite(`${DISPATCH_BASE}/${encoded(dispatchNo)}/loading-complete`, request)
}
export function reviewDispatchLoading(dispatchNo, request) {
	return dispatchWrite(`${DISPATCH_BASE}/${encoded(dispatchNo)}/loading-review`, request)
}

export async function listOutboundTasks(status = '') {
	const suffix = status ? `?status=${encoded(status)}` : ''
	return asList(await overseasRequest('GET', `${OUTBOUND_BASE}${suffix}`)).map(normalizeOutboundTask)
}

export async function getOutboundTask(taskNo) {
	return normalizeOutboundTask(await overseasRequest('GET', `${OUTBOUND_BASE}/${encoded(taskNo)}`))
}

export function resolveOutboundTask(businessNo) {
	return overseasRequest('GET', `${OUTBOUND_BASE}/resolve/${encoded(businessNo)}`)
}

export async function pickOutboundTask(taskNo, request) {
	await prepareStorageRent('OUTBOUND', taskNo, request, {
		itemId: request.outboundPalletItemId, positionId: request.inventoryPositionId,
		packages: request.packages, cartonMarks: request.cartonMarks,
		skuCode: request.skuCode, productQuantity: request.productQuantity
	})
	return overseasRequest('POST', `${OUTBOUND_BASE}/${encoded(taskNo)}/pick`, request)
}

export async function pickOutboundPallet(taskNo, palletNo, request) {
	await prepareStorageRent('OUTBOUND_PALLET', taskNo, request, { palletNo })
	return overseasRequest('POST', `${OUTBOUND_BASE}/${encoded(taskNo)}/pallets/${encoded(palletNo)}/pick`, request)
}

export function outboundPickPayload(item, position, packages, scannedCode = '') {
	const skuScan = item.skuCode && scannedCode === item.skuCode
	return {
		outboundPalletItemId: item.outboundPalletItemId,
		inventoryPositionId: position.inventoryPositionId || null,
		packages: Number(packages),
		...(item.returnSkuQuantity != null ? { productQuantity: Number(item.returnSkuQuantity) } : {}),
		cartonMarks: skuScan ? [] : position.cartonMark ? [position.cartonMark] : [],
		...(skuScan ? { skuCode: item.skuCode } : {})
	}
}

export function completeOutboundTask(taskNo, request) {
	return overseasRequest('POST', `${OUTBOUND_BASE}/${encoded(taskNo)}/complete`, request)
}

export function normalizeCargoDiscardTask(value) {
	const task = value || {}
	return {
		...task,
		discardNo: String(task?.discardNo || ''),
		outboundNo: String(task?.outboundNo || ''),
		palletNo: String(task?.palletNo || ''),
		scanMode: task?.scanMode === 'CARTON' ? 'CARTON' : 'PALLET',
		cartonMarks: asList(task?.cartonMarks).map(String),
		status: String(task?.status || 'PENDING'),
		skus: asList(task?.skus).map((sku) => ({
			...sku,
			itemId: String(sku?.itemId || ''),
			skuCode: String(sku?.skuCode || ''),
			productName: String(sku?.productName || ''),
			quantityUnit: sku?.quantityUnit === '件' ? '件' : '箱',
			plannedPackages: count(sku?.plannedPackages),
			actualPackages: sku?.actualPackages == null ? null : count(sku.actualPackages),
			actualQuantityEditable: sku?.actualQuantityEditable === true,
			status: String(sku?.status || 'PENDING')
		}))
	}
}

export async function listCargoDiscardTasks() {
	return asList(await overseasRequest('GET', CARGO_DISCARD_BASE)).map(normalizeCargoDiscardTask)
}

export async function resolveCargoDiscardPallet(palletNo, discardNo) {
	return normalizeCargoDiscardTask(await overseasRequest('POST', `${CARGO_DISCARD_BASE}/resolve`, { palletNo, ...(discardNo ? { discardNo } : {}) }))
}

export async function confirmCargoDiscard(discardNo, palletNo, lines, photoFileIds, scannedCartonMarks = [], confirmAllCartons = false, request = {}) {
	const body = { lines, photoFileIds, scannedCartonMarks, confirmAllCartons, idempotencyKey: request.idempotencyKey }
	await prepareStorageRent('DISCARD', discardNo, request, { palletNo, lines, photoFileIds, scannedCartonMarks, confirmAllCartons })
	return normalizeCargoDiscardTask(await overseasRequest('POST', `${CARGO_DISCARD_BASE}/${encoded(discardNo)}/pallets/${encoded(palletNo)}/confirm`, body))
}

const discardPhotoPath = (discardNo, palletNo) => `${CARGO_DISCARD_BASE}/${encoded(discardNo)}/pallets/${encoded(palletNo)}/photos/files`
export const listCargoDiscardPhotos = (discardNo, palletNo) => overseasRequest('GET', discardPhotoPath(discardNo, palletNo))
export const uploadCargoDiscardPhoto = (discardNo, palletNo, filePath) => overseasUpload(discardPhotoPath(discardNo, palletNo), filePath)
export const downloadCargoDiscardPhoto = (discardNo, palletNo, fileId) => overseasDownload(`${discardPhotoPath(discardNo, palletNo)}/${encoded(fileId)}/download`, { expectedContentTypePrefix: 'image/' })