334 lines
23 KiB
JavaScript
334 lines
23 KiB
JavaScript
import { ensureMatsonCarrierPartner } from './carrier-partner-fixture.mjs'
|
|
import { oceanBookingDraft } from './ocean-booking-fixture.mjs'
|
|
import { truckAppointmentFieldGaps } from './fulfillment-list-field-contract.mjs'
|
|
|
|
const MODULE = 'truck-appointments'
|
|
const OPTIONS = { scenario: 'booking-level-truck-appointment-lifecycle', deploymentBlocker: true }
|
|
const TRUCKS = '/api/platform/v1/truck-appointments'
|
|
const BOOKINGS = '/api/platform/v1/ocean-bookings'
|
|
const FORBIDDEN_TRUCK_FIELDS = ['containerBookingId', 'loadingPlanId', 'containerNo', 'cabinetNo', 'containers']
|
|
|
|
function id(value) { return value == null ? '' : String(value) }
|
|
function codeOf(response) { return response?.body?.code == null ? 'missing' : String(response.body.code) }
|
|
function responseEvidence(response) {
|
|
return `HTTP=${response?.http ?? 'missing'}, code=${codeOf(response)}, requestId=${response?.requestId || 'missing'}, traceId=${response?.traceId || 'missing'}`
|
|
}
|
|
function data(response) { return codeOf(response) === '200' ? response.body.data : null }
|
|
function failure(response) { return response?.http === 0 || response?.http >= 400 || (response?.http === 200 && codeOf(response) !== '200') }
|
|
function records(value) { return Array.isArray(value) ? value : value?.records || [] }
|
|
function hasForbiddenTruckFields(value) { return FORBIDDEN_TRUCK_FIELDS.some((field) => Object.hasOwn(value || {}, field)) }
|
|
|
|
export function minimalPdfBytes(label = 'truck-appointment-fixture') {
|
|
const safeLabel = String(label).replace(/[^\x20-\x7E]/g, '_').slice(0, 64)
|
|
return new TextEncoder().encode(`%PDF-1.4
|
|
% ${safeLabel}
|
|
1 0 obj
|
|
<< /Type /Catalog /Pages 2 0 R >>
|
|
endobj
|
|
2 0 obj
|
|
<< /Type /Pages /Kids [] /Count 0 >>
|
|
endobj
|
|
trailer
|
|
<< /Root 1 0 R >>
|
|
%%EOF
|
|
`)
|
|
}
|
|
|
|
export function platformWarehouseIdentity(item) {
|
|
return { warehouseId: id(item?.warehouseId || item?.id || item?.warehouse?.id), platformTenantId: '0' }
|
|
}
|
|
|
|
export function activeCustomerIdentity(item) {
|
|
const customerId = id(item?.id || item?.tenantId)
|
|
const customerName = String(item?.tenantName || item?.customerName || item?.name || '').trim()
|
|
return customerId && customerName ? { customerId, customerName } : null
|
|
}
|
|
|
|
async function request(context, method, path, body, headers = {}) {
|
|
try {
|
|
const response = await fetch(`${context.options.gateway}${path}`, {
|
|
method, headers: { Accept: 'application/json', Authorization: `Bearer ${context.token}`,
|
|
...(body === undefined ? {} : { 'Content-Type': 'application/json; charset=utf-8' }), ...headers },
|
|
body: body === undefined ? undefined : JSON.stringify(body), signal: AbortSignal.timeout(60_000),
|
|
})
|
|
const raw = await response.text(); let parsed = null
|
|
try { parsed = raw ? JSON.parse(raw) : null } catch { /* bounded raw evidence */ }
|
|
return { method, path, http: response.status, body: parsed, raw: parsed == null ? raw.slice(0, 500) : null,
|
|
requestId: parsed?.requestId || response.headers.get('x-request-id'), traceId: parsed?.traceId || response.headers.get('x-trace-id') }
|
|
} catch (error) { return { method, path, http: 0, body: null, raw: String(error), requestId: null, traceId: null } }
|
|
}
|
|
|
|
export function inspectOceanBookingIdentity(marker, resource, detail = null) {
|
|
if (!resource?.id || resource.marker !== marker) return { identity: null, reason: '订舱不属于本轮' }
|
|
const booking = detail?.oceanBooking || resource
|
|
if (id(booking.id) !== id(resource.id)) return { identity: null, reason: '订舱详情资源归属不一致' }
|
|
return { identity: { oceanBookingId: id(resource.id), warehouseId: id(booking.warehouseId) }, reason: null, missingFields: [] }
|
|
}
|
|
|
|
export function truckAppointmentPayload(context, suffix, identity, version = 0, overrides = {}) {
|
|
const supplier = identity.truckSupplier || context.createdResources?.truckSupplier || {}
|
|
return { outboundOrderId: null, oceanBookingId: identity.oceanBookingId, warehouseId: identity.warehouseId,
|
|
carrierId: id(supplier.supplierId), carrierName: supplier.supplierName,
|
|
billOfLadingNo: identity.billOfLadingNo, fleetContact: '车队联系人', fleetPhone: '13800000004',
|
|
driverName: '司机验收', driverPhone: '13800000005', vehicleNo: `粤B-${suffix.slice(-6)}`,
|
|
storeName: `装柜点-${suffix}`, storeContact: '仓库联系人', storePhone: '13800000006',
|
|
storeAddress: '深圳市南山区验收地址', storeCity: '深圳', storeZipcode: '518000',
|
|
packageCount: 0, grossWeightKg: 0, volumeCbm: 0, palletCount: 0, poNo: `PO-${suffix}`,
|
|
plannedLoadingAt: '2026-12-31T10:00:00', transitMinutes: 0, payableAmount: 0,
|
|
currency: 'RMB', remark: `订舱级拖车-${suffix}`, expectedVersion: version, ...overrides }
|
|
}
|
|
|
|
async function activeSupplier(context, category, suffix) {
|
|
if (context.options?.fixedCustomerId) {
|
|
const { loadSupplier } = await import('./finance-full-fixtures.mjs')
|
|
const supplier = await loadSupplier(context, category, category === 'BOOKING'
|
|
? { carrierCode: 'MATSON' } : { truckingScope: 'DOMESTIC' })
|
|
if (!supplier) throw new Error(`缺少现有 ${category} 供应商，禁止自动创建`)
|
|
return { supplierId: id(supplier.id), supplierName: supplier.name }
|
|
}
|
|
const carrierFilter = category === 'BOOKING' ? '&carrierCode=MATSON' : category === 'TRUCKING' ? '&truckingScope=DOMESTIC' : ''
|
|
const list = await request(context, 'GET', `/api/platform/v1/suppliers?tenantId=0&category=${category}&status=ACTIVE${carrierFilter}&page=1&size=100`)
|
|
const existing = records(data(list)).find((item) => item?.category === category && item?.status === 'ACTIVE'
|
|
&& (category !== 'TRUCKING' || item?.truckingScope === 'DOMESTIC')
|
|
&& (category !== 'BOOKING' || item?.carrierCodes?.includes?.('MATSON')))
|
|
if (existing) return { supplierId: id(existing.id), supplierName: existing.name }
|
|
const created = await request(context, 'POST', '/api/platform/v1/suppliers?tenantId=0', {
|
|
name: `${category}-验收-${suffix}`, category, truckingScope: category === 'TRUCKING' ? 'DOMESTIC' : null, carrierCodes: category === 'BOOKING' ? ['MATSON'] : [],
|
|
region: '深圳', legalRepresentative: '验收法人', contactName: '验收联系人', phone: '13800000000',
|
|
email: 'truck-acceptance@example.com', address: '深圳市验收地址', businessLicenseNo: `TRUCK-${suffix}`.slice(0, 64),
|
|
licenseFileId: null, status: 'ACTIVE', settlementPeriod: 'MONTHLY_30', remark: context.marker,
|
|
})
|
|
const value = data(created); const supplierId = id(value?.id || value)
|
|
context.apiSuccess(MODULE, `创建 ACTIVE ${category} 供应商`, created, '', OPTIONS)
|
|
return supplierId ? { supplierId, supplierName: value?.name || `${category}-验收-${suffix}` } : null
|
|
}
|
|
|
|
async function bookingMaster(context, suffix) {
|
|
const fixtureCustomerId = id(context.createdResources?.merchantQualificationFixture?.tenantId
|
|
|| context.context?.customerId || context.customerId)
|
|
const customersResponse = await request(context, 'GET', '/api/platform/v1/iam/tenants?page=1&size=100&status=ACTIVE')
|
|
const candidates = records(data(customersResponse))
|
|
const customer = activeCustomerIdentity(candidates.find((item) =>
|
|
fixtureCustomerId && id(item?.id || item?.tenantId) === fixtureCustomerId) || candidates[0])
|
|
if (!customer) {
|
|
context.addStep(MODULE, '通过正式平台客户查询解析 ACTIVE 订舱客户', customersResponse, false,
|
|
`preferredCustomerId=${fixtureCustomerId || 'missing'}`, OPTIONS)
|
|
return null
|
|
}
|
|
let lastWarehousesResponse = null
|
|
for (let page = 1; page <= 100; page++) {
|
|
const warehousesResponse = await request(context, 'GET',
|
|
`/api/platform/v1/warehouse-admin?tenantId=0&warehouseType=DOMESTIC&status=ACTIVE&page=${page}&size=100`)
|
|
lastWarehousesResponse = warehousesResponse
|
|
const warehousePage = data(warehousesResponse); const warehouseRows = records(warehousePage)
|
|
for (const item of warehouseRows) {
|
|
const { warehouseId } = platformWarehouseIdentity(item)
|
|
if (!warehouseId) continue
|
|
const channelsResponse = await request(context, 'GET', `${BOOKINGS}/channels?originWarehouseId=${warehouseId}`)
|
|
const channelRows = records(data(channelsResponse)); const channel = channelRows[0]
|
|
if (channel?.channelCode) return { ...customer, warehouseId, channelCode: channel.channelCode, channelName: channel.channelName }
|
|
}
|
|
const total = Number(warehousePage?.total ?? warehouseRows.length)
|
|
if (warehouseRows.length === 0 || page * 100 >= total) break
|
|
}
|
|
context.addStep(MODULE, '解析具备有效海运渠道的平台仓库', lastWarehousesResponse, false,
|
|
`platformTenantId=0, customerId=${customer.customerId}`, OPTIONS)
|
|
return null
|
|
}
|
|
|
|
async function candidate(context, identity) {
|
|
const response = await request(context, 'GET', `${TRUCKS}/candidates?keyword=${encodeURIComponent(identity.oceanBookingNo)}&page=1&size=200`)
|
|
const page = data(response)
|
|
return { response, item: records(page).find((value) => id(value?.oceanBookingId) === identity.oceanBookingId) }
|
|
}
|
|
|
|
async function fixture(context) {
|
|
const suffix = context.marker.replace(/[^A-Za-z0-9]/g, '').slice(-10) || 'TRUCK'
|
|
const master = await bookingMaster(context, suffix); if (!master?.customerId) return null
|
|
const bookingAgent = await activeSupplier(context, 'BOOKING', suffix)
|
|
const truckSupplier = await activeSupplier(context, 'TRUCKING', suffix)
|
|
const carrier = await ensureMatsonCarrierPartner(context, MODULE, OPTIONS)
|
|
if (!bookingAgent || !truckSupplier || !carrier?.id) return null
|
|
const draft = oceanBookingDraft(context, suffix, master, {
|
|
billOfLadingNo: `BL-TRUCK-${context.marker}`.slice(0, 64),
|
|
bookingAgentId: bookingAgent.supplierId, bookingAgentName: bookingAgent.supplierName,
|
|
shippingCompanyId: id(carrier.id), shippingCompanyName: carrier.name, carrierCode: 'MATSON',
|
|
containerRequirements: [{ containerType: '40HQ', containerKind: 'FCL', quantity: 2, capacityCbm: 68, maxWeightKg: 19500 }],
|
|
})
|
|
const createdResponse = await request(context, 'POST', BOOKINGS, { expectedVersion: 0, data: draft },
|
|
{ 'Idempotency-Key': `${context.marker}-truck-booking-create`.slice(0, 128) })
|
|
const created = context.apiSuccess(MODULE, '自包含创建 DRAFT 订舱', createdResponse, '', OPTIONS)
|
|
const bookingId = id(created?.oceanBooking?.id); if (!bookingId) return null
|
|
const identity = { suffix, oceanBookingId: bookingId, oceanBookingNo: created.oceanBooking.bookingNo,
|
|
warehouseId: master.warehouseId, billOfLadingNo: created.oceanBooking.billOfLadingNo, truckSupplier }
|
|
const draftCandidate = await candidate(context, identity)
|
|
context.assert(MODULE, 'DRAFT订舱不进入拖车候选', draftCandidate.response, !draftCandidate.item,
|
|
`oceanBookingNo=${identity.oceanBookingNo}`, OPTIONS)
|
|
|
|
const form = new FormData(); form.append('expectedVersion', String(created.oceanBooking.version))
|
|
form.append('documentType', 'BILL_OF_LADING')
|
|
form.append('file', new Blob([minimalPdfBytes(`${context.marker}-BILL_OF_LADING`)], { type: 'application/pdf' }), `bill-${suffix}.pdf`)
|
|
const uploadResponse = await context.requestMultipart('POST', `${BOOKINGS}/${bookingId}/documents/upload`, form,
|
|
context.token, { 'Idempotency-Key': `${context.marker}-truck-booking-file`.slice(0, 128) })
|
|
const uploaded = context.apiSuccess(MODULE, '上传当前有效 BILL_OF_LADING 文件', uploadResponse, '', OPTIONS)
|
|
const releaseResponse = await request(context, 'POST', `${BOOKINGS}/${bookingId}/release`,
|
|
{ expectedVersion: Number(uploaded?.bookingVersion), reason: context.marker },
|
|
{ 'Idempotency-Key': `${context.marker}-truck-booking-release`.slice(0, 128) })
|
|
const released = context.apiSuccess(MODULE, '放舱自包含订舱', releaseResponse, '', OPTIONS)
|
|
if (released?.oceanBooking?.status !== 'RELEASED') return null
|
|
identity.billOfLadingNo = released.oceanBooking.billOfLadingNo
|
|
const releasedCandidate = await candidate(context, identity)
|
|
context.assert(MODULE, 'RELEASED且资料有效的订舱进入候选', releasedCandidate.response,
|
|
Boolean(releasedCandidate.item) && !hasForbiddenTruckFields(releasedCandidate.item),
|
|
`oceanBookingNo=${identity.oceanBookingNo}`, OPTIONS)
|
|
return identity
|
|
}
|
|
|
|
async function action(context, path, appointment, name, reason) {
|
|
const response = await request(context, 'POST', `${path}/${name.toLowerCase()}`,
|
|
{ expectedVersion: Number(appointment?.version), reason },
|
|
{ 'Idempotency-Key': `${context.marker}-truck-${name.toLowerCase()}`.slice(0, 128) })
|
|
return context.apiSuccess(MODULE, `整单推进${name}`, response, '', OPTIONS)
|
|
}
|
|
|
|
export async function run(context) {
|
|
const identity = await fixture(context)
|
|
context.assert(MODULE, '订舱级拖车模块自包含前置链完整', null,
|
|
Boolean(identity?.oceanBookingId && identity?.oceanBookingNo && identity?.truckSupplier?.supplierId),
|
|
`oceanBookingNo=${identity?.oceanBookingNo || 'missing'}`, OPTIONS)
|
|
if (!identity) return
|
|
context.createdResources.truckSupplier = identity.truckSupplier
|
|
const base = truckAppointmentPayload(context, identity.suffix, identity)
|
|
context.assert(MODULE, '创建请求完全不含柜次协议字段', null,
|
|
!hasForbiddenTruckFields(base) && !Object.hasOwn(base, 'customerId') && !Object.hasOwn(base, 'customerName'),
|
|
Object.keys(base).join(','), OPTIONS)
|
|
for (const [label, payload] of [
|
|
['错误订舱拒绝创建', { ...base, oceanBookingId: (BigInt(identity.oceanBookingId) + 1n).toString() }],
|
|
['错误仓库拒绝创建', { ...base, warehouseId: (BigInt(identity.warehouseId) + 1n).toString() }],
|
|
['错误提单拒绝创建', { ...base, billOfLadingNo: `WRONG-${identity.suffix}` }],
|
|
['错误承运商拒绝创建', { ...base, carrierId: (BigInt(identity.truckSupplier.supplierId) + 1n).toString() }],
|
|
['非法拖车币种拒绝创建', { ...base, currency: 'CNY' }],
|
|
]) {
|
|
const response = await request(context, 'POST', TRUCKS, payload)
|
|
context.addStep(MODULE, label, response, failure(response), `code=${codeOf(response)}`, OPTIONS)
|
|
}
|
|
|
|
const createdResponse = await request(context, 'POST', TRUCKS, base)
|
|
let appointment = context.apiSuccess(MODULE, '创建合法订舱级拖车预约', createdResponse, '', OPTIONS)
|
|
const appointmentId = id(appointment?.id); if (!appointmentId) return
|
|
const path = `${TRUCKS}/${appointmentId}`
|
|
context.assert(MODULE, '创建响应完全无柜次协议且费用正确', createdResponse,
|
|
truckAppointmentFieldGaps(appointment).length === 0
|
|
&& !hasForbiddenTruckFields(appointment) && appointment?.currency === 'RMB'
|
|
&& Number(appointment?.payableAmount) === 0,
|
|
`appointmentNo=${appointment?.appointmentNo || 'missing'}, fieldGaps=${truckAppointmentFieldGaps(appointment).join('|') || 'none'}`, OPTIONS)
|
|
const afterCreateCandidate = await candidate(context, identity)
|
|
context.assert(MODULE, '创建后订舱立即退出候选', afterCreateCandidate.response, !afterCreateCandidate.item,
|
|
`appointmentNo=${appointment.appointmentNo}`, OPTIONS)
|
|
const duplicateBefore = await request(context, 'POST', TRUCKS, base)
|
|
context.addStep(MODULE, '同订舱第二张非终态拖车单冲突', duplicateBefore, failure(duplicateBefore),
|
|
`code=${codeOf(duplicateBefore)}, appointmentNo=${appointment.appointmentNo}`, OPTIONS)
|
|
const unchangedResponse = await request(context, 'GET', path)
|
|
const unchanged = context.apiSuccess(MODULE, '重复创建冲突后回查零漂移', unchangedResponse, '', OPTIONS)
|
|
context.assert(MODULE, '重复创建未改变版本和状态', unchangedResponse,
|
|
Number(unchanged?.version) === Number(appointment.version) && unchanged?.status === 'DRAFT', '', OPTIONS)
|
|
|
|
const attachmentForm = new FormData(); attachmentForm.append('attachmentType', 'DISPATCH_ORDER')
|
|
attachmentForm.append('file', new Blob([minimalPdfBytes(`${context.marker}-DISPATCH_ORDER`)], { type: 'application/pdf' }),
|
|
`dispatch-order-${identity.suffix}.pdf`)
|
|
const uploadAttachmentResponse = await context.requestMultipart('POST', `${path}/attachments/upload`,
|
|
attachmentForm, context.token)
|
|
const attachment = context.apiSuccess(MODULE, '上传并关联DISPATCH_ORDER拖车附件', uploadAttachmentResponse, '', OPTIONS)
|
|
const attachmentListResponse = await request(context, 'GET', `${path}/attachments`)
|
|
const attachmentList = context.apiSuccess(MODULE, '查询拖车附件列表', attachmentListResponse, '', OPTIONS)
|
|
context.assert(MODULE, '附件列表包含本轮运营附件', attachmentListResponse,
|
|
records(attachmentList).some((item) => id(item?.id) === id(attachment?.id) && item?.attachmentType === 'DISPATCH_ORDER'),
|
|
`attachmentId=${id(attachment?.id) || 'missing'}`, OPTIONS)
|
|
if (!attachment?.id || !attachment?.fileId) return
|
|
const deleteUploadedResponse = await request(context, 'DELETE',
|
|
`${path}/attachments/${encodeURIComponent(id(attachment?.id))}`)
|
|
context.addStep(MODULE, '删除首次上传的拖车附件引用', deleteUploadedResponse,
|
|
deleteUploadedResponse.http === 200 && codeOf(deleteUploadedResponse) === '200',
|
|
responseEvidence(deleteUploadedResponse), OPTIONS)
|
|
const referencedResponse = await request(context, 'POST', `${path}/attachments`, {
|
|
fileId: id(attachment?.fileId), attachmentType: 'DISPATCH_ORDER',
|
|
fileName: attachment?.fileName || `dispatch-order-${identity.suffix}.pdf`,
|
|
fileHash: attachment?.fileHash || null,
|
|
})
|
|
const referenced = context.apiSuccess(MODULE, '重新引用平台归属拖车附件', referencedResponse, '', OPTIONS)
|
|
const referencedListResponse = await request(context, 'GET', `${path}/attachments`)
|
|
const referencedList = context.apiSuccess(MODULE, '回查重新引用的拖车附件', referencedListResponse, '', OPTIONS)
|
|
context.assert(MODULE, '附件列表包含重新引用的DISPATCH_ORDER', referencedListResponse,
|
|
records(referencedList).some((item) => id(item?.id) === id(referenced?.id)
|
|
&& id(item?.fileId) === id(attachment?.fileId) && item?.attachmentType === 'DISPATCH_ORDER'),
|
|
`attachmentId=${id(referenced?.id) || 'missing'}, fileId=${id(attachment?.fileId) || 'missing'}`, OPTIONS)
|
|
const deleteReferencedResponse = await request(context, 'DELETE',
|
|
`${path}/attachments/${encodeURIComponent(id(referenced?.id))}`)
|
|
context.addStep(MODULE, '删除重新引用的拖车附件', deleteReferencedResponse,
|
|
deleteReferencedResponse.http === 200 && codeOf(deleteReferencedResponse) === '200',
|
|
responseEvidence(deleteReferencedResponse), OPTIONS)
|
|
const replacementForm = new FormData(); replacementForm.append('attachmentType', 'DISPATCH_ORDER')
|
|
replacementForm.append('file', new Blob([minimalPdfBytes(`${context.marker}-DISPATCH_ORDER-REPLACEMENT`)],
|
|
{ type: 'application/pdf' }), `dispatch-order-replacement-${identity.suffix}.pdf`)
|
|
const replacementResponse = await context.requestMultipart('POST', `${path}/attachments/upload`,
|
|
replacementForm, context.token)
|
|
const replacement = context.apiSuccess(MODULE, '恢复一份DISPATCH_ORDER拖车附件供后续状态流转',
|
|
replacementResponse, '', OPTIONS)
|
|
context.assert(MODULE, '恢复附件使用新引用且仍指向平台文件', replacementResponse,
|
|
Boolean(id(replacement?.id) && id(replacement?.fileId)) && id(replacement?.id) !== id(attachment?.id),
|
|
`attachmentId=${id(replacement?.id) || 'missing'}, fileId=${id(replacement?.fileId) || 'missing'}`, OPTIONS)
|
|
|
|
const editedResponse = await request(context, 'PUT', path,
|
|
truckAppointmentPayload(context, identity.suffix, identity, Number(appointment.version), { currency: 'RMB', payableAmount: 12.34 }))
|
|
appointment = context.apiSuccess(MODULE, '编辑订舱级拖车为RMB应付费用', editedResponse, '', OPTIONS)
|
|
context.assert(MODULE, '编辑响应费用正确且无柜次协议', editedResponse,
|
|
appointment?.currency === 'RMB' && Number(appointment?.payableAmount) === 12.34 && !hasForbiddenTruckFields(appointment), '', OPTIONS)
|
|
|
|
const submitKey = `${context.marker}-truck-submit`.slice(0, 128)
|
|
const submitBody = { expectedVersion: Number(appointment.version), reason: '幂等提交' }
|
|
const submitResponse = await request(context, 'POST', `${path}/submit`, submitBody, { 'Idempotency-Key': submitKey })
|
|
appointment = context.apiSuccess(MODULE, '整单推进SUBMIT', submitResponse, '', OPTIONS)
|
|
const replayResponse = await request(context, 'POST', `${path}/submit`, submitBody, { 'Idempotency-Key': submitKey })
|
|
const replay = context.apiSuccess(MODULE, 'SUBMIT同键同载荷重放', replayResponse, '', OPTIONS)
|
|
context.assert(MODULE, 'SUBMIT重放版本零漂移', replayResponse,
|
|
Number(replay?.version) === Number(appointment.version) && replay?.status === appointment.status, '', OPTIONS)
|
|
const conflictResponse = await request(context, 'POST', `${path}/submit`, { ...submitBody, reason: '异载荷' },
|
|
{ 'Idempotency-Key': submitKey })
|
|
context.addStep(MODULE, 'SUBMIT同键异载荷A0409', conflictResponse,
|
|
codeOf(conflictResponse) === 'A0409', `code=${codeOf(conflictResponse)}`, OPTIONS)
|
|
|
|
for (const [name, reason] of [['DISPATCH', '派车'], ['PICKUP', '提柜'], ['ARRIVE', '到仓'],
|
|
['LOAD', '装货']]) {
|
|
appointment = await action(context, path, appointment, name, reason)
|
|
context.assert(MODULE, `${name}响应无柜次协议`, null, Boolean(appointment) && !hasForbiddenTruckFields(appointment),
|
|
`status=${appointment?.status || 'missing'}`, OPTIONS)
|
|
}
|
|
const finalDetailResponse = await request(context, 'GET', path)
|
|
const finalDetail = context.apiSuccess(MODULE, '回查待离仓订舱级拖车详情', finalDetailResponse, '', OPTIONS)
|
|
context.assert(MODULE, '未确认国内离仓时保持装柜中且详情无柜次协议', finalDetailResponse,
|
|
finalDetail?.status === 'LOADING' && truckAppointmentFieldGaps(finalDetail).length === 0
|
|
&& !hasForbiddenTruckFields(finalDetail)
|
|
&& id(finalDetail?.oceanBookingId) === identity.oceanBookingId,
|
|
`appointmentNo=${finalDetail?.appointmentNo || 'missing'}, status=${finalDetail?.status || 'missing'}, fieldGaps=${truckAppointmentFieldGaps(finalDetail).join('|') || 'none'}`, OPTIONS)
|
|
for (const obsoleteAction of ['depart', 'complete']) {
|
|
const rejected = await request(context, 'POST', `${path}/${obsoleteAction}`,
|
|
{ expectedVersion: Number(finalDetail.version) }, { 'Idempotency-Key': `${context.marker}-${obsoleteAction}`.slice(0, 128) })
|
|
context.assert(MODULE, '禁止手工离仓或完成拖车', rejected, codeOf(rejected) === 'A0409', '', OPTIONS)
|
|
}
|
|
let rebuilt = finalDetail
|
|
const cancelled = await action(context, `${TRUCKS}/${id(rebuilt?.id)}`, rebuilt, 'CANCEL', '取消测试单')
|
|
const afterCancelCandidate = await candidate(context, identity)
|
|
context.assert(MODULE, 'CANCELLED后订舱恢复候选', afterCancelCandidate.response,
|
|
cancelled?.status === 'CANCELLED' && Boolean(afterCancelCandidate.item), '', OPTIONS)
|
|
const afterCancelResponse = await request(context, 'POST', TRUCKS, base)
|
|
rebuilt = context.apiSuccess(MODULE, 'CANCELLED后同订舱可再次新建', afterCancelResponse, '', OPTIONS)
|
|
const excepted = await action(context, `${TRUCKS}/${id(rebuilt?.id)}`, rebuilt, 'EXCEPTION', '异常测试单')
|
|
const afterExceptionCandidate = await candidate(context, identity)
|
|
context.assert(MODULE, 'EXCEPTION后订舱恢复候选', afterExceptionCandidate.response,
|
|
excepted?.status === 'EXCEPTION' && Boolean(afterExceptionCandidate.item), '', OPTIONS)
|
|
const finalDraftResponse = await request(context, 'POST', TRUCKS, base)
|
|
const finalDraft = context.apiSuccess(MODULE, 'EXCEPTION后同订舱可再次新建', finalDraftResponse, '', OPTIONS)
|
|
context.createdResources.truckAppointment = { id: id(finalDraft?.id), appointmentNo: finalDraft?.appointmentNo,
|
|
marker: context.marker, finalStatus: finalDraft?.status, oceanBookingId: identity.oceanBookingId }
|
|
}
|