278 lines
23 KiB
JavaScript
278 lines
23 KiB
JavaScript
import { createHash } from 'node:crypto'
|
|
import { mkdir, open, writeFile, rename } from 'node:fs/promises'
|
|
import { resolve, dirname } from 'node:path'
|
|
|
|
export const DISPATCH_BASE = '/api/platform/v1/last-leg/dispatches'
|
|
export const id = value => value == null ? '' : String(value)
|
|
export const canonical = value => JSON.stringify(value)
|
|
export const success = response => response?.http === 200 && String(response.body?.code) === '200'
|
|
const positiveId = value => /^[1-9]\d*$/.test(id(value))
|
|
const amount = value => (typeof value === 'number' || typeof value === 'string' && /^\d+$/.test(value)) && Number.isSafeInteger(Number(value)) && Number(value) > 0
|
|
export class DispatchNotRun extends Error { constructor(message) { super(message); this.notRun = true } }
|
|
export function version(value) {
|
|
if (!(typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 || typeof value === 'string' && /^(0|[1-9]\d*)$/.test(value))
|
|
|| BigInt(value) > 9223372036854775807n) throw Error('缺少服务器recordVersion或精度无效，不能猜测零版本')
|
|
return value
|
|
}
|
|
export const versionAfter = (next, previous) => BigInt(version(next)) > BigInt(version(previous))
|
|
|
|
// 主run提供真实原子落盘；独立调用者必须显式提供checkpoint，禁止内存意图冒充持久化。
|
|
export async function dispatchEvidenceContext(context) {
|
|
if (typeof context.checkpoint === 'function') return context
|
|
if (typeof context.marker !== 'string' || !/^[A-Za-z0-9_-]+$/.test(context.marker)) throw new DispatchNotRun('缺少可用于独占检查点的本轮marker')
|
|
const path = resolve(dirname(context.options?.output || 'reports/admin-test-env.json'), 'phase4-dispatch-checkpoints', `${context.marker}.json`)
|
|
const redact = value => {
|
|
if (Array.isArray(value)) return value.map(redact)
|
|
if (value && typeof value === 'object') return Object.fromEntries(Object.entries(value)
|
|
.filter(([name]) => !/password|authorization|secret|apiKey|credential|accessToken|refreshToken|idToken|^token$|base64|^bytes$|^content$/i.test(name))
|
|
.map(([name, nested]) => [name, redact(nested)]))
|
|
return value
|
|
}
|
|
await mkdir(dirname(path), { recursive: true })
|
|
let reservation
|
|
try { reservation = await open(path, 'wx') }
|
|
catch (error) { if (error.code === 'EEXIST') throw Error(`已存在本轮排车检查点，须核对原请求结果，禁止自动重跑：${path}`); throw error }
|
|
await reservation.close()
|
|
const scoped = Object.create(context)
|
|
scoped.checkpoint = async () => {
|
|
const resources = context.createdResources
|
|
const evidence = redact({ marker: context.marker, boundary: resources.dispatchWriteBoundary,
|
|
phase4OverseasDispatch: resources.phase4OverseasDispatch, groupedDispatch: resources.groupedDispatch })
|
|
await writeFile(`${path}.tmp`, `${JSON.stringify(evidence, null, 2)}\n`, 'utf8')
|
|
await rename(`${path}.tmp`, path)
|
|
}
|
|
context.createdResources.phase4OverseasDispatch.checkpointPath = path
|
|
await scoped.checkpoint()
|
|
return scoped
|
|
}
|
|
export function query(path, values) {
|
|
const params = new URLSearchParams()
|
|
for (const [key, value] of Object.entries(values)) {
|
|
if (value === undefined || value === null || value === '') continue
|
|
if (Array.isArray(value)) {
|
|
for (const item of value) if (item !== undefined && item !== null && item !== '') params.append(key, String(item))
|
|
continue
|
|
}
|
|
params.set(key, String(value))
|
|
}
|
|
return `${path}?${params}`
|
|
}
|
|
export function commandKey(marker, namespace, action) {
|
|
return `D4-${createHash('sha256').update(`${marker}\n${namespace}\n${action}`).digest('hex').slice(0, 48)}`
|
|
}
|
|
// 仅接受当前Candidate DTO；来源摘要、客户、仓与FBA批次均取生产回执。
|
|
export function sourceSelection(candidate) {
|
|
const source = candidate?.selection
|
|
if (!positiveId(candidate?.customerId) || !positiveId(candidate?.warehouseId) || !amount(candidate?.availablePackages)
|
|
|| !source || !/^[a-f\d]{64}$/i.test(source.sourceVersion || '') || source.sourceVersion !== candidate.sourceVersion
|
|
|| !positiveId(source.warehousePalletId) || !Array.isArray(candidate.blockReasons) || candidate.blockReasons.length
|
|
|| !Array.isArray(candidate.appointmentBatches) || !candidate.destination?.key) throw new DispatchNotRun('缺少完整、可选的本轮原生来源回执')
|
|
const expected = source.sourceType === 'INBOUND_PLAN' && positiveId(source.planPalletId) && source.returnReceiptId == null && source.relabelNo == null ? `PLAN:${source.planPalletId}`
|
|
: source.sourceType === 'RETURN_RECEIPT' && positiveId(source.returnReceiptId) && source.planPalletId == null && source.relabelNo == null ? `RETURN:${source.returnReceiptId}`
|
|
: source.sourceType === 'RELABEL' && source.relabelNo && source.planPalletId == null && source.returnReceiptId == null ? `RELABEL:${source.relabelNo}:${source.warehousePalletId}` : null
|
|
if (!expected || candidate.sourceKey !== expected) throw new DispatchNotRun('来源选择器或服务器来源键不完整')
|
|
return { sourceType: source.sourceType, planPalletId: source.planPalletId, returnReceiptId: source.returnReceiptId,
|
|
relabelNo: source.relabelNo, warehousePalletId: source.warehousePalletId, sourceVersion: source.sourceVersion }
|
|
}
|
|
export function createBody(marker, namespace, candidates) {
|
|
if (!candidates.length || new Set(candidates.map(c => id(c.warehouseId))).size !== 1) throw new DispatchNotRun('整车缺少同仓真实货物')
|
|
const cargo = candidates.map(sourceSelection), batchAllocations = []
|
|
for (const candidate of candidates) {
|
|
const batches = candidate.appointmentBatches
|
|
if (!batches.length) continue
|
|
if (batches.length !== 1 || !positiveId(candidate.selection.planPalletId)) throw new DispatchNotRun('来源跨多个FBA批次，缺少本轮明确逐批实物分配，不能推算')
|
|
const batch = batches[0]
|
|
if (!/^FBA_APPOINTMENT:[1-9]\d*$/.test(batch.batchKey || '') || id(batch.customerId) !== id(candidate.customerId)
|
|
|| !Array.isArray(batch.sources) || !batch.sources.length || batch.sources.some(s => !/^(BOOKING:.+|ORDER:[1-9]\d*)$/.test(s.sourceKey || '') || !s.destinationKey?.startsWith('FBA:') || !amount(s.packageCount))
|
|
|| batch.sources.reduce((sum, s) => sum + Number(s.packageCount), 0) !== Number(candidate.availablePackages)) throw new DispatchNotRun('FBA批次未完整覆盖本托真实逐票货物')
|
|
let batchVersion
|
|
try { batchVersion = version(batch.recordVersion) } catch { throw new DispatchNotRun('FBA批次缺少权威recordVersion') }
|
|
for (const source of batch.sources) batchAllocations.push({ planPalletId: candidate.selection.planPalletId, batchKey: batch.batchKey,
|
|
customerId: candidate.customerId, sourceKey: source.sourceKey, destinationKey: source.destinationKey,
|
|
packageCount: Number(source.packageCount), recordVersion: batchVersion })
|
|
}
|
|
return { idempotencyKey: commandKey(marker, namespace, 'create'), warehouseId: candidates[0].warehouseId,
|
|
vehicle: null, driver: null, plannedDepartureAt: null, estimatedArrivalAt: null,
|
|
remark: `${marker}-${namespace}`, cargo, batchAllocations }
|
|
}
|
|
export function markerCandidates(context, candidates) {
|
|
const fixture = context.createdResources?.phase4OverseasPda
|
|
const pallets = new Set([...(fixture?.palletIds || []), ...Object.values(fixture?.generatedPalletsByInbound || {}).flat().filter(p => id(p.warehouseId) === id(fixture?.overseasWarehouseId)).map(p => p.palletId)].map(id))
|
|
if (fixture?.marker !== context.marker || fixture?.finalStatus !== 'COMPLETED' || !positiveId(fixture?.customerId) || !positiveId(fixture?.overseasWarehouseId)) throw new DispatchNotRun('缺少本轮PDA完成回执及真实客户仓')
|
|
return candidates.filter(candidate => {
|
|
try { sourceSelection(candidate) } catch { return false }
|
|
return candidate.selection.sourceType === 'INBOUND_PLAN' && pallets.has(id(candidate.selection.warehousePalletId))
|
|
&& id(candidate.customerId) === id(fixture.customerId) && id(candidate.warehouseId) === id(fixture.overseasWarehouseId)
|
|
&& candidate.destination.type === 'FBA'
|
|
})
|
|
}
|
|
export function notRun(context, proof, reason) {
|
|
proof.status = 'NOT_RUN'; proof.reason = reason
|
|
// 未运行时保留既有终态；否则显式标记 NOT_RUN，便于下游区分前置不足与代码失败。
|
|
proof.finalStatus ??= 'NOT_RUN'
|
|
context.addCoverageGap?.('phase4-overseas-dispatch', 'native-dispatch', '缺少当前生产前置', reason, 'fixture', { deploymentBlocker: true })
|
|
return proof
|
|
}
|
|
// 请求意图必须先持久化，未知写结果使同marker后续写入全部停止。
|
|
export function dispatchIo(context, module, proof, namespace) {
|
|
context.createdResources ??= {}; proof.requests ??= []
|
|
const boundary = context.createdResources.dispatchWriteBoundary ??= { marker: context.marker, stopped: false }
|
|
if (!context.marker || boundary.marker !== context.marker) throw new DispatchNotRun('请求边界不属于本轮marker')
|
|
const checkpoint = async () => { if (typeof context.checkpoint === 'function') await context.checkpoint() }
|
|
const check = (label, response, passed, detail = '') => {
|
|
context.assert?.(module, label, response, passed, `${detail ? `${detail}; ` : ''}marker=${context.marker}; HTTP=${response?.http}; requestId=${response?.requestId}; traceId=${response?.traceId}`, { scenario: namespace, deploymentBlocker: true })
|
|
if (!passed) throw Error(`${namespace}: ${label}`)
|
|
}
|
|
const send = async (method, path, body, label) => {
|
|
const write = !['GET', 'HEAD'].includes(method)
|
|
if (write && boundary.stopped) throw Error('本轮写请求结果未知或回执存档失败，停写并保留原键')
|
|
if (write && typeof context.checkpoint !== 'function') throw new DispatchNotRun('缺少真实持久化checkpoint，未发送排车写请求')
|
|
const entry = { method, path, ...(body === undefined ? {} : { body: structuredClone(body) }), label, status: 'SENDING' }
|
|
proof.requests.push(entry)
|
|
try { await checkpoint() } catch (error) { boundary.stopped = true; entry.status = 'NOT_SENT'; throw error }
|
|
let response
|
|
try { response = await context.request(method, path, body) }
|
|
catch (error) { entry.status = 'UNKNOWN_RESULT'; entry.error = error.message; if (write) { boundary.stopped = true; boundary.outcomeUnknown = true; proof.outcomeUnknown = true; proof.cleanup = 'PRESERVED_FOR_REVIEW' }; await checkpoint(); throw error }
|
|
const unknown = !response?.http || response.http >= 500 || write && (response.body?.code == null || success(response) && response.body.data == null)
|
|
Object.assign(entry, { status: unknown ? 'UNKNOWN_RESULT' : 'RESPONDED', http: response?.http,
|
|
code: response?.body?.code, message: response?.body?.message, raw: response?.raw, transportError: response?.transportError,
|
|
requestId: response?.requestId, traceId: response?.traceId, result: structuredClone(response?.body?.data) })
|
|
if (write && entry.status === 'UNKNOWN_RESULT') { boundary.stopped = true; boundary.outcomeUnknown = true; proof.outcomeUnknown = true; proof.cleanup = 'PRESERVED_FOR_REVIEW' }
|
|
try { await checkpoint() } catch (error) { if (write) boundary.stopped = true; throw error }
|
|
return response
|
|
}
|
|
const command = async (method, path, body, label) => { const response = await send(method, path, body, label); check(label, response, success(response)); return response.body.data }
|
|
const key = action => commandKey(context.marker, namespace, action)
|
|
return { check, send, command, key,
|
|
planIds: (context.createdResources?.phase4OverseasPda?.generatedPlanIds || []).map(String) }
|
|
}
|
|
export function replayFacts(result) { const copy = structuredClone(result); if (copy && typeof copy === 'object') delete copy.replayed; return copy }
|
|
export async function replay(io, path, body, result, label, method = 'POST') {
|
|
const again = await io.command(method, path, body, label)
|
|
io.check(`${label}恢复原命令结果`, null, canonical(replayFacts(again)) === canonical(replayFacts(result)))
|
|
return again
|
|
}
|
|
export async function candidatePage(io, warehouseId, extra = {}) {
|
|
const planIds = extra.planIds ?? io?.planIds
|
|
const params = { warehouseId, sourceStage: 'RECEIVED', ...(Array.isArray(planIds) && planIds.length ? { planIds } : {}), ...extra }
|
|
const result = await io.command('GET', query(`${DISPATCH_BASE}/candidates`, params), undefined, '读取同仓原生候选')
|
|
io.check('候选完整包络', null, result?.complete === true && Array.isArray(result.candidates))
|
|
return result.candidates
|
|
}
|
|
export async function readDispatch(io, dispatchNo) {
|
|
const path = `${DISPATCH_BASE}/${encodeURIComponent(dispatchNo)}`
|
|
const data = await io.command('GET', path, undefined, '回查原生整车详情')
|
|
const items = await io.command('GET', `${path}/items`, undefined, '回查真实货物明细')
|
|
const route = await io.command('GET', `${path}/route`, undefined, '回查真实起点与目的地')
|
|
const page = await io.command('GET', query(DISPATCH_BASE, { page: 1, size: 20, dispatchNo }), undefined, '按业务号核对整车仓库')
|
|
const rows = page?.records?.filter(r => r.dispatchNo === dispatchNo) || []
|
|
io.check('主单、货物、路线版本与实际仓一致', null, data?.dispatchNo === dispatchNo && items?.dispatchNo === dispatchNo && route?.dispatchNo === dispatchNo
|
|
&& rows.length === 1 && positiveId(rows[0].warehouseId) && id(version(data.recordVersion)) === id(version(items.recordVersion))
|
|
&& id(version(route.recordVersion)) === id(version(data.recordVersion)) && canonical(rows[0].counts) === canonical(data.counts)
|
|
&& id(rows[0].recordVersion) === id(data.recordVersion) && rows[0].status === data.status && rows[0].stage === data.stage
|
|
&& items.status === data.status && items.stage === data.stage)
|
|
return { data, items, route, warehouseId: rows[0].warehouseId }
|
|
}
|
|
export function dispatchMatches(bundle, candidates) {
|
|
const items = bundle?.items?.items, counts = bundle?.data?.counts
|
|
if (!Array.isArray(items) || !counts || !Array.isArray(candidates) || bundle.data.status !== 'ACTIVE' || bundle.data.stage !== 'BEFORE_LOADING'
|
|
|| items.length !== candidates.length || Number(counts.itemCount) !== items.length || Number(counts.palletCount) !== new Set(candidates.map(c => id(c.selection.warehousePalletId))).size
|
|
|| Number(counts.packageCount) !== candidates.reduce((n, c) => n + Number(c.availablePackages), 0) || Number(counts.pickedPackageCount) !== 0 || Number(counts.shippedPackageCount) !== 0) return false
|
|
const details = bundle.data.orderDetails
|
|
if (!Array.isArray(details) || new Set(details.map(d => d.sourceKey)).size !== candidates.length
|
|
|| details.some(d => !candidates.some(c => c.sourceKey === d.sourceKey && id(c.customerId) === id(d.customerId)
|
|
&& c.inboundCode === d.inboundCode && c.destination.warehouseCode === d.destinationFbaWarehouse))) return false
|
|
return new Set(items.map(i => id(i.dispatchItemId))).size === items.length && new Set(items.map(i => i.sourceKey)).size === items.length && items.every(i => positiveId(i.dispatchItemId) && candidates.some(c =>
|
|
c.sourceKey === i.sourceKey && c.sourceVersion === i.sourceVersion && id(c.customerId) === id(i.customerId) && id(c.warehouseId) === id(bundle.warehouseId)
|
|
&& id(c.selection.warehousePalletId) === id(i.warehousePalletId) && id(c.selection.planPalletId) === id(i.planPalletId)
|
|
&& c.inboundCode === i.inboundCode && c.destination.key === i.destination?.key && Number(c.availablePackages) === Number(i.scheduledPackages) && Number(i.pickedPackages) === 0))
|
|
}
|
|
export function groupedDispatchMatches(result, groups, candidates) {
|
|
if (!Array.isArray(result?.vehicles) || result.vehicles.length !== groups.length) return false
|
|
const seen = new Set(), numbers = new Set()
|
|
return result.vehicles.every(row => {
|
|
const group = groups.find(g => id(g.draftContainerId) === id(row.draftContainerId)), command = row.dispatch
|
|
const selected = candidates.filter(c => group?.sourceKeys.includes(c.sourceKey))
|
|
if (!group || seen.has(id(row.draftContainerId)) || numbers.has(command?.dispatchNo) || !command?.dispatchNo || command.action !== 'CREATE' || command.status !== 'ACTIVE' || command.stage !== 'BEFORE_LOADING') return false
|
|
seen.add(id(row.draftContainerId)); numbers.add(command.dispatchNo)
|
|
return Number(command.counts?.itemCount) === selected.length && Number(command.counts?.palletCount) === selected.length
|
|
&& Number(command.counts?.packageCount) === selected.reduce((n, c) => n + Number(c.availablePackages), 0)
|
|
})
|
|
}
|
|
export async function newDraft(io, warehouseId) {
|
|
const body = { idempotencyKey: io.key('draft-create'), warehouseId }
|
|
const draft = await io.command('POST', `${DISPATCH_BASE}/drafts`, body, '创建服务器草稿token')
|
|
io.check('服务器新草稿身份及零版本', null, Boolean(draft?.draftToken) && id(draft.warehouseId) === id(warehouseId) && id(version(draft.recordVersion)) === '0' && Array.isArray(draft.containers) && Array.isArray(draft.sources))
|
|
await replay(io, `${DISPATCH_BASE}/drafts`, body, draft, '创建草稿同键重放')
|
|
return draft
|
|
}
|
|
export async function activeDraft(io, token) {
|
|
const rows = await io.command('GET', `${DISPATCH_BASE}/drafts`, undefined, '回查当前拥有者草稿')
|
|
io.check('原服务器草稿唯一存在', null, Array.isArray(rows) && rows.filter(d => d.draftToken === token).length === 1)
|
|
return rows.find(d => d.draftToken === token)
|
|
}
|
|
// 分组全成功才移除已证明属于本轮的未拣实物；失败或未知响应保留所有已成功资源。
|
|
export async function verifyGroupedDispatch(context, module, candidates) {
|
|
const proof = { marker: context.marker, status: 'CHECKING', groups: [], results: [], cleanup: 'PRESERVED_FOR_REVIEW', requests: [] }
|
|
if (context.createdResources?.groupedDispatch?.requests?.length) throw Error('本轮分组尝试已经存在，禁止自动重造')
|
|
context.createdResources ??= {}; context.createdResources.groupedDispatch = proof
|
|
try {
|
|
const owned = markerCandidates(context, candidates)
|
|
if (owned.length !== candidates.length || candidates.length < 2 || new Set(candidates.map(c => c.sourceKey)).size !== candidates.length
|
|
|| new Set(candidates.map(c => id(c.selection?.warehousePalletId))).size !== candidates.length) throw new DispatchNotRun('分组须有本轮两个独立未拣实托')
|
|
candidates.forEach((c, n) => createBody(context.marker, `GROUP-${n}`, [c]))
|
|
const io = dispatchIo(context, module, proof, 'GROUPED')
|
|
let draft = await newDraft(io, candidates[0].warehouseId); proof.draftToken = draft.draftToken
|
|
for (const [n, candidate] of candidates.entries()) {
|
|
const previous = new Set(draft.containers.map(c => id(c.draftContainerId)))
|
|
draft = await io.command('POST', `${DISPATCH_BASE}/drafts/containers`, { recordVersion: version(draft.recordVersion), idempotencyKey: io.key(`container-${n}`), draftToken: draft.draftToken, capacity: 15 }, '创建真实草稿容器')
|
|
const additions = draft.containers.filter(c => !previous.has(id(c.draftContainerId)))
|
|
io.check('容器身份来自服务器草稿', null, additions.length === 1 && positiveId(additions[0].draftContainerId))
|
|
const group = { draftContainerId: additions[0].draftContainerId, sourceKeys: [candidate.sourceKey] }; proof.groups.push(group)
|
|
const body = { recordVersion: version(draft.recordVersion), idempotencyKey: io.key(`lock-${n}`), draftToken: draft.draftToken, draftContainerId: group.draftContainerId, source: sourceSelection(candidate) }
|
|
draft = await io.command('POST', `${DISPATCH_BASE}/draft-locks/lock`, body, '锁定完整真实来源到原容器')
|
|
await replay(io, `${DISPATCH_BASE}/draft-locks/lock`, body, draft, '锁定同键重放')
|
|
}
|
|
const snapshot = { recordVersion: version(draft.recordVersion), idempotencyKey: io.key('snapshot'), draftToken: draft.draftToken, planIds: [], containers: draft.containers }
|
|
draft = await io.command('POST', `${DISPATCH_BASE}/drafts/snapshot`, snapshot, '保存版本化完整容器布局')
|
|
await replay(io, `${DISPATCH_BASE}/drafts/snapshot`, snapshot, draft, '布局同键重放')
|
|
const groups = proof.groups.map((g, n) => ({ draftContainerId: g.draftContainerId, dispatch: createBody(context.marker, `GROUPED-CHILD-${n}`, candidates.filter(c => g.sourceKeys.includes(c.sourceKey))) }))
|
|
const before = await activeDraft(io, draft.draftToken)
|
|
const wrong = { recordVersion: version(draft.recordVersion), idempotencyKey: io.key('convert-reject'), draftToken: draft.draftToken,
|
|
groups: groups.map((g, n) => ({ ...g, dispatch: groups[(n + 1) % groups.length].dispatch })) }
|
|
const rejected = await io.send('POST', `${DISPATCH_BASE}/drafts/pre-arrange`, wrong, '错组转换拒绝')
|
|
io.check('错组来源明确冲突', rejected, [200, 409].includes(rejected?.http) && String(rejected.body?.code) === 'A0409')
|
|
io.check('拒绝后原草稿不变', null, canonical(await activeDraft(io, draft.draftToken)) === canonical(before))
|
|
const body = { recordVersion: version(draft.recordVersion), idempotencyKey: io.key('convert'), draftToken: draft.draftToken, groups }
|
|
const converted = await io.command('POST', `${DISPATCH_BASE}/drafts/pre-arrange`, body, '原子转换一容器一整车')
|
|
io.check('真实分组命令数量与货物核平', null, converted?.draftToken === draft.draftToken && groupedDispatchMatches(converted, proof.groups, candidates))
|
|
proof.results = converted.vehicles
|
|
for (const row of proof.results) {
|
|
const selected = candidates.filter(c => proof.groups.find(g => id(g.draftContainerId) === id(row.draftContainerId)).sourceKeys.includes(c.sourceKey))
|
|
const current = await readDispatch(io, row.dispatch.dispatchNo)
|
|
io.check('成功创建后逐车回查真实来源', null, dispatchMatches(current, selected))
|
|
}
|
|
await replay(io, `${DISPATCH_BASE}/drafts/pre-arrange`, body, converted, '整批转换同键重放')
|
|
for (const row of proof.results) {
|
|
let current = await readDispatch(io, row.dispatch.dispatchNo)
|
|
const selected = candidates.filter(c => proof.groups.find(g => id(g.draftContainerId) === id(row.draftContainerId)).sourceKeys.includes(c.sourceKey))
|
|
io.check('清理前仍为本轮完整未拣货物', null, dispatchMatches(current, selected))
|
|
for (const item of current.items.items) {
|
|
io.check('服务端允许移出本轮实物', null, item.remove?.allowed === true)
|
|
const remove = { recordVersion: version(current.data.recordVersion), idempotencyKey: io.key(`remove-${item.dispatchItemId}`), reason: `${context.marker}-分组验收释放未拣实物` }
|
|
await io.command('POST', `${DISPATCH_BASE}/${encodeURIComponent(row.dispatch.dispatchNo)}/items/${encodeURIComponent(item.dispatchItemId)}/remove`, remove, '版本化移出本轮分组实物')
|
|
current = await readDispatch(io, row.dispatch.dispatchNo)
|
|
}
|
|
io.check('空对照单真实数量归零', null, dispatchMatches(current, []))
|
|
}
|
|
const available = await candidatePage(io, candidates[0].warehouseId)
|
|
io.check('原来源回到可选集合', null, candidates.every(c => available.some(a => a.sourceKey === c.sourceKey && a.blockReasons?.length === 0)))
|
|
proof.cleanup = 'OWNED_UNPICKED_SOURCES_RELEASED'; proof.status = 'GROUPED_DISPATCH_VERIFIED'; await context.checkpoint()
|
|
return proof
|
|
} catch (error) {
|
|
if (error.notRun && !proof.requests.length) return notRun(context, proof, error.message)
|
|
proof.status = proof.outcomeUnknown ? 'OUTCOME_UNKNOWN' : 'UNPROVEN'; proof.error = error.message
|
|
throw error
|
|
}
|
|
}
|