2026-09-02 19:29:23 +08:00
|
|
|
const MODULE = 'firstleg-container-fee-allocation'
|
|
|
|
|
const OPTIONS = { scenario: 'firstleg-container-fee-allocation-http', deploymentBlocker: true }
|
|
|
|
|
|
|
|
|
|
import { run as createMerchant } from './merchant-qualification-fixture.mjs'
|
2026-09-10 21:18:52 +08:00
|
|
|
import { channelGroup } from './smart-loading-channel-group.mjs'
|
2026-09-02 19:29:23 +08:00
|
|
|
|
|
|
|
|
function id(value) { return value == null ? '' : String(value) }
|
|
|
|
|
function rows(value) { return Array.isArray(value) ? value : Array.isArray(value?.records) ? value.records : [] }
|
|
|
|
|
function code(response) { return String(response?.body?.code ?? response?.http ?? '') }
|
|
|
|
|
function evidence(response, extra = '') {
|
|
|
|
|
return [`HTTP=${response?.http ?? 'missing'}`, `code=${code(response) || 'missing'}`,
|
|
|
|
|
`requestId=${response?.requestId || response?.body?.requestId || 'missing'}`,
|
|
|
|
|
`traceId=${response?.traceId || response?.body?.traceId || 'missing'}`, extra].filter(Boolean).join(', ')
|
|
|
|
|
}
|
|
|
|
|
function operationKey(context, suffix) { return `${context.marker}-container-fee-${suffix}`.slice(0, 128) }
|
|
|
|
|
function post(context, path, body, suffix) {
|
|
|
|
|
return context.request('POST', path, body, context.token, { 'Idempotency-Key': operationKey(context, suffix) })
|
|
|
|
|
}
|
|
|
|
|
function blocker(context, name, detail) {
|
|
|
|
|
context.addStep(MODULE, name, null, false, detail, OPTIONS)
|
|
|
|
|
}
|
|
|
|
|
function expectBusinessFailure(context, name, response, expectedCodes = ['A0400', 'A0404', 'A0409', 'A0422']) {
|
|
|
|
|
context.addStep(MODULE, name, response,
|
|
|
|
|
response?.http >= 400 || (response?.http === 200 && expectedCodes.includes(code(response))),
|
|
|
|
|
evidence(response, `message=${response?.body?.message || 'missing'}`), OPTIONS)
|
|
|
|
|
}
|
|
|
|
|
function money(value) { return Number(Number(value || 0).toFixed(2)) }
|
|
|
|
|
|
|
|
|
|
export function candidateLoadingPlanIds(createdResources = {}) {
|
|
|
|
|
const candidates = [
|
|
|
|
|
createdResources.phase3ContainerLoading?.loadingPlanId,
|
|
|
|
|
createdResources.coloadGroupAcceptance?.fullPlanId,
|
|
|
|
|
createdResources.coloadGroupAcceptance?.planId,
|
|
|
|
|
createdResources.manualLoadingComplete?.loadingPlanId,
|
|
|
|
|
createdResources.phase3ContainerDocuments?.loadingPlanId,
|
|
|
|
|
...rows(createdResources.financeFullFixtures?.feeSources).map((item) => item?.loadingPlanId),
|
|
|
|
|
].map(id).filter((value) => /^[1-9]\d*$/.test(value))
|
|
|
|
|
return [...new Set(candidates)]
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
export function ownershipAllocations(planItems = [], totalAmount = 120) {
|
|
|
|
|
const unique = new Map()
|
|
|
|
|
for (const item of rows(planItems)) {
|
|
|
|
|
const customerId = id(item?.accountId ?? item?.customerId ?? item?.tenantId)
|
|
|
|
|
const orderId = id(item?.orderId)
|
|
|
|
|
const orderNo = String(item?.orderNo || '').trim()
|
|
|
|
|
const inboundId = id(item?.inboundId)
|
|
|
|
|
const inboundCode = String(item?.inboundCode || '').trim()
|
|
|
|
|
if (!customerId || !orderId || !orderNo || !inboundId || !inboundCode) continue
|
|
|
|
|
const key = `${customerId}|${orderId}|${inboundId}`
|
|
|
|
|
if (!unique.has(key)) unique.set(key, { customerId, orderId, orderNo, inboundId, inboundCode })
|
|
|
|
|
}
|
|
|
|
|
const byCustomer = new Map()
|
|
|
|
|
for (const allocation of unique.values()) if (!byCustomer.has(allocation.customerId)) byCustomer.set(allocation.customerId, allocation)
|
|
|
|
|
const selected = [...byCustomer.values()]
|
|
|
|
|
if (selected.length < 2) return []
|
|
|
|
|
const totalCents = Math.round(Number(totalAmount) * 100)
|
|
|
|
|
const base = Math.floor(totalCents / selected.length)
|
|
|
|
|
return selected.map((allocation, index) => ({ ...allocation,
|
|
|
|
|
amount: ((base + (index === selected.length - 1 ? totalCents - base * selected.length : 0)) / 100).toFixed(2) }))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
export function withoutInbound(allocation) {
|
|
|
|
|
const { inboundId: _inboundId, inboundCode: _inboundCode, ...required } = allocation
|
|
|
|
|
return required
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function groupRows(allRows, groupId) {
|
|
|
|
|
return allRows.filter((item) => id(item?.allocationGroupId) === id(groupId))
|
|
|
|
|
}
|
|
|
|
|
function signature(group) {
|
|
|
|
|
return group.map((item) => [id(item?.id), id(item?.tenantId), item?.reviewStatus,
|
|
|
|
|
item?.sourceStatus, Number(item?.sourceVersion), money(item?.amount)].join(':')).sort().join('|')
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
async function readOwnedRows(context, loadingPlanId, customerIds, label) {
|
|
|
|
|
const result = []
|
|
|
|
|
for (const customerId of customerIds) {
|
|
|
|
|
const response = await context.request('GET',
|
|
|
|
|
`/api/platform/v1/loading-plans/${encodeURIComponent(loadingPlanId)}/fee-details?accountId=${encodeURIComponent(customerId)}`)
|
|
|
|
|
const data = context.apiSuccess(MODULE, `${label}：客户 ${customerId} 回读费用`, response,
|
|
|
|
|
evidence(response, `loadingPlanId=${loadingPlanId}, customerId=${customerId}`), OPTIONS)
|
|
|
|
|
const owned = rows(data)
|
|
|
|
|
context.assert(MODULE, `${label}：客户费用隔离`, response,
|
|
|
|
|
owned.every((item) => id(item?.tenantId) === customerId),
|
|
|
|
|
`customerId=${customerId}, returnedTenants=${[...new Set(owned.map((item) => id(item?.tenantId)))].join('|') || 'none'}`, OPTIONS)
|
|
|
|
|
result.push(...owned)
|
|
|
|
|
}
|
|
|
|
|
return result
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
async function findCrossCustomerPlan(context) {
|
|
|
|
|
for (const loadingPlanId of candidateLoadingPlanIds(context.createdResources)) {
|
|
|
|
|
const response = await context.request('GET',
|
|
|
|
|
`/api/platform/v1/first-leg/smart-loading/plans/${encodeURIComponent(loadingPlanId)}`)
|
|
|
|
|
const plan = context.apiSuccess(MODULE, '回读本轮柜次费用分摊候选', response,
|
|
|
|
|
evidence(response, `loadingPlanId=${loadingPlanId}`), OPTIONS)
|
|
|
|
|
const allocations = ownershipAllocations(plan?.items, 120)
|
|
|
|
|
if (allocations.length >= 2) return { loadingPlanId, plan, allocations }
|
|
|
|
|
}
|
|
|
|
|
return null
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
async function createCustomerWaitSplit(context, suffix, fixedRoute = null) {
|
|
|
|
|
const runMarker = context.marker
|
|
|
|
|
context.marker = `${runMarker}-${suffix}`
|
|
|
|
|
if (fixedRoute) context.context.waitSplitRoute = fixedRoute
|
|
|
|
|
await createMerchant(context)
|
|
|
|
|
const orders = await import(new URL(`./orders.mjs?allocation=${encodeURIComponent(suffix)}-${Date.now()}`, import.meta.url))
|
|
|
|
|
const measurementModule = await import(new URL(`./inbound-measurement.mjs?allocation=${encodeURIComponent(suffix)}-${Date.now()}`, import.meta.url))
|
|
|
|
|
await orders.run(context)
|
|
|
|
|
await measurementModule.run(context)
|
|
|
|
|
const order = structuredClone(context.createdResources.orders || {})
|
|
|
|
|
const measurement = structuredClone(context.createdResources.inboundMeasurement || {})
|
|
|
|
|
context.assert(MODULE, `${suffix}客户产生真实WAIT_SPLIT入仓单`, null,
|
|
|
|
|
Boolean(order.tenantId && order.orderId && order.inboundId && order.inboundCode
|
|
|
|
|
&& measurement.processStatus === 'WAIT_SPLIT'),
|
|
|
|
|
`customerId=${order.tenantId || 'missing'}, inboundCode=${order.inboundCode || 'missing'}, status=${measurement.processStatus || 'missing'}`,
|
|
|
|
|
OPTIONS)
|
|
|
|
|
context.marker = runMarker
|
|
|
|
|
return { ...order, processStatus: measurement.processStatus }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
async function provisionCrossCustomerPlan(context) {
|
|
|
|
|
const originalMarker = context.marker
|
|
|
|
|
const originalUsername = process.env.MERCHANT_TEST_USERNAME
|
|
|
|
|
const originalPassword = process.env.MERCHANT_TEST_PASSWORD
|
|
|
|
|
const originalRoute = context.context.waitSplitRoute
|
|
|
|
|
const originalMerchant = context.context.merchantQualificationFixture
|
|
|
|
|
try {
|
|
|
|
|
const first = await createCustomerWaitSplit(context, 'ALLOC-A')
|
|
|
|
|
const route = {
|
|
|
|
|
originWarehouseName: first.receivingWarehouseName,
|
|
|
|
|
channelCode: first.channelCode,
|
|
|
|
|
destinationType: first.destinationType,
|
|
|
|
|
destinationWarehouseId: first.destinationWarehouseId,
|
|
|
|
|
taxModeIndex: 0,
|
|
|
|
|
}
|
|
|
|
|
const second = await createCustomerWaitSplit(context, 'ALLOC-B', route)
|
|
|
|
|
if (id(first.tenantId) === id(second.tenantId)
|
|
|
|
|
|| id(first.receivingWarehouseId) !== id(second.receivingWarehouseId)
|
|
|
|
|
|| first.channelCode !== second.channelCode) return null
|
|
|
|
|
const containerResponse = await context.request('POST', '/api/platform/v1/containers', {
|
2026-09-10 21:18:52 +08:00
|
|
|
channelGroupCode: channelGroup(first.channelCode), warehouseId: id(first.receivingWarehouseId),
|
2026-09-02 19:29:23 +08:00
|
|
|
containerType: '40HC', capacityCbm: 76, maxWeightKg: 28000,
|
|
|
|
|
})
|
|
|
|
|
const container = context.apiSuccess(MODULE, '创建跨客户费用分摊专用模拟柜', containerResponse,
|
|
|
|
|
evidence(containerResponse), OPTIONS)
|
|
|
|
|
const bookingId = id(container?.id)
|
|
|
|
|
if (!bookingId) return null
|
|
|
|
|
const planResponse = await context.request('GET',
|
|
|
|
|
`/api/platform/v1/first-leg/smart-loading/plans/by-booking/${encodeURIComponent(bookingId)}`)
|
|
|
|
|
let plan = context.apiSuccess(MODULE, '读取跨客户费用分摊专用计划', planResponse,
|
|
|
|
|
evidence(planResponse), OPTIONS)
|
|
|
|
|
const loadingPlanId = id(plan?.id)
|
|
|
|
|
if (!loadingPlanId) return null
|
|
|
|
|
for (const [index, item] of [first, second].entries()) {
|
|
|
|
|
const assigned = await context.request('POST',
|
|
|
|
|
`/api/platform/v1/first-leg/smart-loading/plans/${encodeURIComponent(loadingPlanId)}/inbound-assignments`, {
|
|
|
|
|
inboundId: id(item.inboundId),
|
|
|
|
|
packageCount: rows(item.skuLines).reduce((sum, line) => sum + Number(line.packageCount || 0), 0),
|
|
|
|
|
expectedVersion: Number(plan?.version),
|
|
|
|
|
operationId: operationKey(context, `fixture-assign-${index + 1}`),
|
|
|
|
|
})
|
|
|
|
|
plan = context.apiSuccess(MODULE, `原子分配第${index + 1}个客户入仓单`, assigned,
|
|
|
|
|
evidence(assigned, `inboundCode=${item.inboundCode}`), OPTIONS)
|
|
|
|
|
if (!plan) return null
|
|
|
|
|
}
|
|
|
|
|
const allocations = ownershipAllocations(plan.items, 120)
|
|
|
|
|
return allocations.length >= 2 ? { loadingPlanId, plan, allocations } : null
|
|
|
|
|
} finally {
|
|
|
|
|
context.marker = originalMarker
|
|
|
|
|
context.context.waitSplitRoute = originalRoute
|
|
|
|
|
context.context.merchantQualificationFixture = originalMerchant
|
|
|
|
|
if (originalUsername === undefined) delete process.env.MERCHANT_TEST_USERNAME
|
|
|
|
|
else process.env.MERCHANT_TEST_USERNAME = originalUsername
|
|
|
|
|
if (originalPassword === undefined) delete process.env.MERCHANT_TEST_PASSWORD
|
|
|
|
|
else process.env.MERCHANT_TEST_PASSWORD = originalPassword
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
export async function run(context) {
|
|
|
|
|
const start = context.steps.length
|
|
|
|
|
const fixture = await findCrossCustomerPlan(context) || await provisionCrossCustomerPlan(context)
|
|
|
|
|
if (!fixture) {
|
|
|
|
|
blocker(context, '取得本轮跨客户真实柜次',
|
|
|
|
|
`marker=${context.marker}, candidateLoadingPlanIds=${candidateLoadingPlanIds(context.createdResources).join('|') || 'none'}；必须由本轮前置创建至少包含两个客户、真实订单和入仓码的柜次，禁止借用历史数据`)
|
|
|
|
|
context.createdResources.firstlegContainerFeeAllocation = { marker: context.marker, ready: false }
|
|
|
|
|
context.scenarios.push({ name: OPTIONS.scenario, module: MODULE, success: false,
|
|
|
|
|
deploymentBlocked: true, passed: context.steps.slice(start).filter((step) => step.passed).length,
|
|
|
|
|
failed: context.steps.slice(start).filter((step) => !step.passed).length })
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const { loadingPlanId, allocations } = fixture
|
|
|
|
|
const customerIds = allocations.map((item) => item.customerId)
|
|
|
|
|
const feeItemsResponse = await context.request('GET', '/api/platform/v1/fee-items?page=1&pageSize=200')
|
|
|
|
|
const feeItems = context.apiSuccess(MODULE, '查询柜次应收费用项目', feeItemsResponse,
|
|
|
|
|
evidence(feeItemsResponse), OPTIONS)
|
|
|
|
|
const feeItem = rows(feeItems).find((item) => item?.status === 'ACTIVE'
|
|
|
|
|
&& (item?.warehouseReceivable === true || item?.pickupReceivable === true))
|
|
|
|
|
if (!feeItem?.id) {
|
|
|
|
|
blocker(context, '取得可用应收费用项目', '没有 ACTIVE 且启用仓储/提货应收的费用项目，禁止猜测 feeItemId')
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const base = `/api/platform/v1/loading-plans/${encodeURIComponent(loadingPlanId)}/fee-details`
|
|
|
|
|
const groupPath = `${base}/allocation-groups`
|
|
|
|
|
const fee = { feeItemId: id(feeItem.id), direction: 'RECEIVABLE',
|
|
|
|
|
businessDate: new Date().toISOString().slice(0, 10), amount: 120, currency: 'CNY',
|
|
|
|
|
remark: `${context.marker}-cross-customer-allocation` }
|
|
|
|
|
|
|
|
|
|
const initial = await readOwnedRows(context, loadingPlanId, customerIds, '创建前')
|
|
|
|
|
const invalidTotal = await post(context, groupPath,
|
|
|
|
|
{ fee, allocations: allocations.map((item, index) => ({ ...withoutInbound(item), amount: index === 0 ? '1.00' : item.amount })) }, 'invalid-total')
|
|
|
|
|
expectBusinessFailure(context, '分摊金额合计不一致被拒绝', invalidTotal, ['A0409'])
|
|
|
|
|
|
|
|
|
|
const missingCustomer = await post(context, groupPath,
|
|
|
|
|
{ fee, allocations: allocations.map((item, index) => index === 0 ? { ...withoutInbound(item), customerId: null } : withoutInbound(item)) }, 'missing-customer')
|
|
|
|
|
expectBusinessFailure(context, '分摊客户必填', missingCustomer, ['A0422'])
|
|
|
|
|
const missingOrder = await post(context, groupPath,
|
|
|
|
|
{ fee, allocations: allocations.map((item, index) => index === 0 ? { ...withoutInbound(item), orderId: null } : withoutInbound(item)) }, 'missing-order')
|
|
|
|
|
expectBusinessFailure(context, '分摊订单必填', missingOrder, ['A0422'])
|
|
|
|
|
|
|
|
|
|
const forgedOrder = allocations.map(withoutInbound)
|
|
|
|
|
forgedOrder[0] = { ...forgedOrder[0], orderId: '999999999999999999' }
|
|
|
|
|
const forgedOrderResponse = await post(context, groupPath, { fee, allocations: forgedOrder }, 'forged-order')
|
|
|
|
|
expectBusinessFailure(context, '伪造非柜内订单归属被拒绝', forgedOrderResponse, ['A0409'])
|
|
|
|
|
const forgedInbound = allocations.map((item) => ({ ...item }))
|
|
|
|
|
forgedInbound[0] = { ...forgedInbound[0], inboundCode: `${context.marker}-FORGED-INBOUND`.slice(0, 64) }
|
|
|
|
|
const forgedInboundResponse = await post(context, groupPath, { fee, allocations: forgedInbound }, 'forged-inbound')
|
|
|
|
|
expectBusinessFailure(context, '伪造非柜内入仓码被拒绝', forgedInboundResponse, ['A0409'])
|
|
|
|
|
const afterNegatives = await readOwnedRows(context, loadingPlanId, customerIds, '负向请求后')
|
|
|
|
|
context.assert(MODULE, '负向请求未产生部分分摊行', null,
|
|
|
|
|
signature(initial) === signature(afterNegatives),
|
|
|
|
|
`before=${signature(initial) || 'empty'}, after=${signature(afterNegatives) || 'empty'}`, OPTIONS)
|
|
|
|
|
|
|
|
|
|
const createResponse = await post(context, groupPath,
|
|
|
|
|
{ fee, allocations: allocations.map(withoutInbound) }, 'create')
|
|
|
|
|
const created = context.apiSuccess(MODULE, '不填写入仓码原子创建跨客户分摊组', createResponse,
|
|
|
|
|
evidence(createResponse, `loadingPlanId=${loadingPlanId}`), OPTIONS)
|
|
|
|
|
const createdRows = rows(created)
|
|
|
|
|
const groupId = id(createdRows[0]?.allocationGroupId)
|
|
|
|
|
context.assert(MODULE, '分摊组客户订单完整且未伪造入仓码', createResponse,
|
|
|
|
|
Boolean(groupId) && createdRows.length === allocations.length
|
|
|
|
|
&& new Set(createdRows.map((item) => id(item?.tenantId))).size >= 2
|
|
|
|
|
&& createdRows.every((item) => item?.allocationInboundId == null && !item?.allocationInboundCode)
|
|
|
|
|
&& money(createdRows.reduce((sum, item) => sum + Number(item?.amount || 0), 0)) === 120,
|
|
|
|
|
`groupId=${groupId || 'missing'}, rows=${createdRows.length}, customers=${new Set(createdRows.map((item) => id(item?.tenantId))).size}, total=${createdRows.reduce((sum, item) => sum + Number(item?.amount || 0), 0)}`, OPTIONS)
|
|
|
|
|
if (!groupId || createdRows.length < 2) return
|
|
|
|
|
|
|
|
|
|
const first = createdRows[0]
|
|
|
|
|
const singleApprove = await post(context,
|
|
|
|
|
`${base}/${encodeURIComponent(id(first.id))}/approve?accountId=${encodeURIComponent(id(first.tenantId))}`, null, 'single-approve')
|
|
|
|
|
expectBusinessFailure(context, '单行审核不能破坏分摊组一致性', singleApprove, ['A0409'])
|
|
|
|
|
const beforeApprove = await readOwnedRows(context, loadingPlanId, customerIds, '单行审核拒绝后')
|
|
|
|
|
context.assert(MODULE, '单行审核拒绝后整组仍为待审核', singleApprove,
|
|
|
|
|
groupRows(beforeApprove, groupId).length === createdRows.length
|
|
|
|
|
&& groupRows(beforeApprove, groupId).every((item) => item?.reviewStatus === 'PENDING'),
|
|
|
|
|
`group=${signature(groupRows(beforeApprove, groupId))}`, OPTIONS)
|
|
|
|
|
|
|
|
|
|
const approveResponse = await post(context, `${groupPath}/${encodeURIComponent(groupId)}/approve`, null, 'approve')
|
|
|
|
|
const approved = rows(context.apiSuccess(MODULE, '整组审核原子成功', approveResponse,
|
|
|
|
|
evidence(approveResponse, `groupId=${groupId}`), OPTIONS))
|
|
|
|
|
context.assert(MODULE, '整组审核后全部行已审核且版本一致', approveResponse,
|
|
|
|
|
approved.length === createdRows.length && approved.every((item) => item?.reviewStatus === 'APPROVED'
|
|
|
|
|
&& item?.sourceStatus === 'ACTIVE' && Number(item?.sourceVersion) === 1),
|
|
|
|
|
`group=${signature(approved)}`, OPTIONS)
|
|
|
|
|
|
|
|
|
|
const partialAdjustBody = { expectedSourceVersion: 1, businessDate: fee.businessDate, totalAmount: 120,
|
|
|
|
|
allocations: [{ feeId: id(approved[0]?.id), amount: 120 }] }
|
|
|
|
|
const partialAdjust = await post(context, `${groupPath}/${encodeURIComponent(groupId)}/adjust`, partialAdjustBody, 'partial-adjust')
|
|
|
|
|
expectBusinessFailure(context, '缺少组成员的调整被拒绝', partialAdjust, ['A0409'])
|
|
|
|
|
const afterPartialAdjust = groupRows(await readOwnedRows(context, loadingPlanId, customerIds, '部分调整拒绝后'), groupId)
|
|
|
|
|
context.assert(MODULE, '部分调整失败后整组零漂移', partialAdjust,
|
|
|
|
|
signature(afterPartialAdjust) === signature(approved),
|
|
|
|
|
`approved=${signature(approved)}, after=${signature(afterPartialAdjust)}`, OPTIONS)
|
|
|
|
|
|
|
|
|
|
const adjustedAmounts = approved.map((item, index) => ({ feeId: id(item.id),
|
|
|
|
|
amount: index === 0 ? '70.00' : index === 1 ? '50.00' : '0.01' }))
|
|
|
|
|
if (adjustedAmounts.length > 2) {
|
|
|
|
|
const overflow = (adjustedAmounts.length - 2) * 0.01
|
|
|
|
|
adjustedAmounts[1].amount = (50 - overflow).toFixed(2)
|
|
|
|
|
}
|
|
|
|
|
const adjustResponse = await post(context, `${groupPath}/${encodeURIComponent(groupId)}/adjust`,
|
|
|
|
|
{ expectedSourceVersion: 1, businessDate: fee.businessDate, totalAmount: 120, allocations: adjustedAmounts }, 'adjust')
|
|
|
|
|
const adjusted = rows(context.apiSuccess(MODULE, '整组调整原子成功', adjustResponse,
|
|
|
|
|
evidence(adjustResponse, `groupId=${groupId}`), OPTIONS))
|
|
|
|
|
context.assert(MODULE, '整组调整后全部行统一升版并待复核', adjustResponse,
|
|
|
|
|
adjusted.length === approved.length && adjusted.every((item) => Number(item?.sourceVersion) === 2
|
|
|
|
|
&& item?.reviewStatus === 'PENDING' && item?.sourceStatus === 'ACTIVE')
|
|
|
|
|
&& money(adjusted.reduce((sum, item) => sum + Number(item?.amount || 0), 0)) === 120,
|
|
|
|
|
`group=${signature(adjusted)}`, OPTIONS)
|
|
|
|
|
|
|
|
|
|
const reapproveResponse = await post(context, `${groupPath}/${encodeURIComponent(groupId)}/approve`, null, 'reapprove')
|
|
|
|
|
const reapproved = rows(context.apiSuccess(MODULE, '调整后整组复核原子成功', reapproveResponse,
|
|
|
|
|
evidence(reapproveResponse, `groupId=${groupId}`), OPTIONS))
|
|
|
|
|
const voidResponse = await post(context, `${groupPath}/${encodeURIComponent(groupId)}/void`,
|
|
|
|
|
{ expectedSourceVersion: 2 }, 'void')
|
|
|
|
|
context.apiSuccess(MODULE, '整组作废原子成功', voidResponse, evidence(voidResponse, `groupId=${groupId}`), OPTIONS)
|
|
|
|
|
const voided = groupRows(await readOwnedRows(context, loadingPlanId, customerIds, '整组作废后'), groupId)
|
|
|
|
|
context.assert(MODULE, '整组作废后全部行冻结且无活动残留', voidResponse,
|
|
|
|
|
reapproved.length === createdRows.length && voided.length === createdRows.length
|
|
|
|
|
&& voided.every((item) => item?.sourceStatus === 'VOIDED' && Number(item?.sourceVersion) === 2),
|
|
|
|
|
`group=${signature(voided)}`, OPTIONS)
|
|
|
|
|
|
|
|
|
|
const frozenAdjust = await post(context, `${groupPath}/${encodeURIComponent(groupId)}/adjust`,
|
|
|
|
|
{ expectedSourceVersion: 2, businessDate: fee.businessDate, totalAmount: 120, allocations: adjustedAmounts }, 'frozen-adjust')
|
|
|
|
|
expectBusinessFailure(context, '已作废冻结分摊组拒绝继续调整', frozenAdjust, ['A0409'])
|
|
|
|
|
const afterFrozen = groupRows(await readOwnedRows(context, loadingPlanId, customerIds, '冻结调整拒绝后'), groupId)
|
|
|
|
|
context.assert(MODULE, '冻结门禁拒绝后整组零漂移', frozenAdjust,
|
|
|
|
|
signature(afterFrozen) === signature(voided),
|
|
|
|
|
`voided=${signature(voided)}, after=${signature(afterFrozen)}`, OPTIONS)
|
|
|
|
|
|
|
|
|
|
const foreignResponse = await context.request('GET',
|
|
|
|
|
`${base}?accountId=999999999999999999`)
|
|
|
|
|
expectBusinessFailure(context, '非柜内客户不能读取柜次费用', foreignResponse, ['A0404'])
|
|
|
|
|
|
|
|
|
|
context.createdResources.firstlegContainerFeeAllocation = {
|
|
|
|
|
marker: context.marker, ready: true, loadingPlanId, groupId,
|
|
|
|
|
customerIds, feeIds: createdRows.map((item) => id(item.id)), finalStatus: 'VOIDED',
|
|
|
|
|
}
|
|
|
|
|
const steps = context.steps.slice(start)
|
|
|
|
|
context.scenarios.push({ name: OPTIONS.scenario, module: MODULE,
|
|
|
|
|
success: steps.every((step) => step.passed), deploymentBlocked: steps.some((step) => step.deploymentBlocker),
|
|
|
|
|
passed: steps.filter((step) => step.passed).length, failed: steps.filter((step) => !step.passed).length })
|
|
|
|
|
}
|
