优化

firstleg/src/main/java/com/baiyue/firstleg/repository/FbaPricingRepository.java

@@ -201,15 +201,17 @@ public class FbaPricingRepository {
             .set(InboundFeeEntity::getUpdatedAt, LocalDateTime.now()));
     }
 
-    public int markInboundCalculated(long tenantId, long inboundId, String chargeMode,
+    public int markInboundCalculated(long tenantId, long inboundId, String processStatus, String chargeMode,
                                      java.math.BigDecimal chargeable) {
         LambdaUpdateWrapper<InboundPricingEntity> update = new LambdaUpdateWrapper<InboundPricingEntity>()
             .eq(InboundPricingEntity::getTenantId, tenantId)
             .eq(InboundPricingEntity::getId, inboundId)
-            .in(InboundPricingEntity::getProcessStatus, List.of("WAIT_PRICING", "FEE_CONFIRMING"))
+            .eq(InboundPricingEntity::getProcessStatus, processStatus)
             .in(InboundPricingEntity::getFeeStatus, List.of("UNPRICED", "CALCULATED"))
-            .set(InboundPricingEntity::getProcessStatus, "FEE_CONFIRMING")
             .set(InboundPricingEntity::getFeeStatus, "CALCULATED");
+        if (!"WAIT_SPLIT".equals(processStatus)) {
+            update.set(InboundPricingEntity::getProcessStatus, "FEE_CONFIRMING");
+        }
         if ("KG".equals(chargeMode)) update.set(InboundPricingEntity::getChargeableWeightKg, chargeable);
         else update.set(InboundPricingEntity::getChargeableVolumeCbm, chargeable);
         return inbounds.update(null, update);
@@ -227,7 +229,7 @@ public class FbaPricingRepository {
     public int markInboundConfirmed(long tenantId, long inboundId) {
         return inbounds.update(null, new LambdaUpdateWrapper<InboundPricingEntity>()
             .eq(InboundPricingEntity::getTenantId, tenantId).eq(InboundPricingEntity::getId, inboundId)
-            .eq(InboundPricingEntity::getProcessStatus, "FEE_CONFIRMING")
+            .in(InboundPricingEntity::getProcessStatus, List.of("FEE_CONFIRMING", "WAIT_SPLIT"))
             .eq(InboundPricingEntity::getFeeStatus, "CALCULATED")
             .set(InboundPricingEntity::getFeeStatus, "CONFIRMED"));
     }

firstleg/src/main/java/com/baiyue/firstleg/service/FbaPricingService.java

@@ -47,7 +47,7 @@ public class FbaPricingService {
         String hash = hash("CALCULATE", inboundId, requestedAt == null ? "CURRENT" : requestedAt.toString());
         InboundPricingIdempotencyEntity token = beginIdempotency(
             tenantId, operatorId, inboundId, "FEE_CALCULATE", idempotencyKey, hash);
-        if ("COMPLETED".equals(token.getStatus())) return response(tenantId, token.getResultResourceId(), "FEE_CONFIRMING");
+        if ("COMPLETED".equals(token.getStatus())) return response(tenantId, token.getResultResourceId(), null);
 
         InboundPricingEntity inbound = requireEligibleInbound(tenantId, inboundId);
         List<CustomerChargeRuleEntity> matchedRules = repository.matchRules(inbound, pricingAt);
@@ -88,11 +88,14 @@ public class FbaPricingService {
         repository.insertFee(fee);
         repository.insertItem(baseItem(tenantId, fee, rate, chargeable, subtotal, now));
         if (additional.signum() > 0) repository.insertItem(additionalItem(tenantId, fee, additional, now));
-        if (repository.markInboundCalculated(tenantId, inboundId, rule.getChargeMode(), chargeable) != 1) {
+        if (repository.markInboundCalculated(tenantId, inboundId, inbound.getProcessStatus(),
+                rule.getChargeMode(), chargeable) != 1) {
             throw conflict("入库单状态已变化，费用试算未保存");
         }
         complete(token, fee.getId(), now);
-        return response(inbound, fee, rate.getUnitPrice(), "FEE_CONFIRMING");
+        String nextStatus = "WAIT_SPLIT".equals(inbound.getProcessStatus())
+            ? "WAIT_SPLIT" : "FEE_CONFIRMING";
+        return response(inbound, fee, rate.getUnitPrice(), nextStatus);
     }
 
     @Transactional
@@ -103,14 +106,14 @@ public class FbaPricingService {
         String hash = hash("CONFIRM", inboundId, current.getId().toString());
         InboundPricingIdempotencyEntity token = beginIdempotency(
             tenantId, operatorId, inboundId, "FEE_CONFIRM", idempotencyKey, hash);
-        if ("COMPLETED".equals(token.getStatus())) return response(tenantId, token.getResultResourceId(), "FEE_CONFIRMING");
+        if ("COMPLETED".equals(token.getStatus())) return response(tenantId, token.getResultResourceId(), null);
         LocalDateTime now = LocalDateTime.now(clock);
         if (repository.confirmFee(tenantId, current.getId(), operatorId, now) != 1
             || repository.markInboundConfirmed(tenantId, inboundId) != 1) {
             throw conflict("费用或入库单状态已变化，不能重复确认");
         }
         complete(token, current.getId(), now);
-        return response(tenantId, current.getId(), "FEE_CONFIRMING");
+        return response(tenantId, current.getId(), null);
     }
 
     @Transactional
@@ -232,7 +235,7 @@ public class FbaPricingService {
 
     private InboundPricingEntity requireEligibleInbound(long tenantId, long inboundId) {
         InboundPricingEntity inbound = requireApprovedInbound(tenantId, inboundId);
-        if (!List.of("WAIT_PRICING", "FEE_CONFIRMING").contains(inbound.getProcessStatus())
+        if (!List.of("WAIT_PRICING", "FEE_CONFIRMING", "WAIT_SPLIT").contains(inbound.getProcessStatus())
             || !List.of("UNPRICED", "CALCULATED").contains(inbound.getFeeStatus())) {
             throw conflict("当前入库单状态不允许费用试算");
         }

firstleg/src/main/resources/openapi/fba-pricing-v1.yaml

@@ -54,19 +54,20 @@ paths:
   /api/platform/v1/inbounds/{inboundId}/fees/calculate:
     post:
       summary: 按审核通过测量快照试算 FBA 费用
-      description: 精确匹配唯一客户规则和唯一船司价格；需要 firstleg:fba-pricing:calculate 权限。
+      description: 精确匹配唯一客户规则和唯一船司价格；测量审核后即使主流程已到 WAIT_SPLIT，也可独立试算且不回退主流程状态；需要 firstleg:fba-pricing:calculate 权限。
       parameters: [{$ref: '#/components/parameters/TenantId'}, {$ref: '#/components/parameters/InboundId'}, {$ref: '#/components/parameters/IdempotencyKey'}]
       requestBody: {content: {application/json: {schema: {$ref: '#/components/schemas/CalculateRequest'}}}}
       responses: {'200': {description: 成功或业务失败}, '403': {description: 无权限}}
   /api/platform/v1/inbounds/{inboundId}/fees/confirm:
     post:
       summary: 确认最新费用快照
+      description: 确认费用只更新费用状态；主流程已到 WAIT_SPLIT 时保持不变。
       parameters: [{$ref: '#/components/parameters/TenantId'}, {$ref: '#/components/parameters/InboundId'}, {$ref: '#/components/parameters/IdempotencyKey'}]
       responses: {'200': {description: 成功或业务失败}, '403': {description: 无权限}}
   /api/platform/v1/inbounds/{inboundId}/fees/send:
     post:
-      summary: 手工恢复发送费用快照
-      description: 仅作为异常恢复接口；正常业务由客服测量审核通过后自动计费、发布并完成入库。
+      summary: 发送已确认费用快照
+      description: 该动作涉及后续仓储流程，本轮二期验收不调用。
       parameters: [{$ref: '#/components/parameters/TenantId'}, {$ref: '#/components/parameters/InboundId'}, {$ref: '#/components/parameters/IdempotencyKey'}]
       responses: {'200': {description: 成功或业务失败}, '403': {description: 无权限}}
   /api/platform/v1/inbounds/{inboundId}/fees/latest:

firstleg/src/test/java/com/baiyue/firstleg/controller/FbaPricingContractTest.java

@@ -36,7 +36,7 @@ class FbaPricingContractTest {
     }
 
     @Test
-    @DisplayName("契约声明自动发布、已发布费用调整和幂等头")
+    @DisplayName("契约声明二期边界计费、已发布费用调整和幂等头")
     void documentsPricingLifecycle() throws Exception {
         String openapi = new ClassPathResource("openapi/fba-pricing-v1.yaml")
             .getContentAsString(StandardCharsets.UTF_8);
@@ -48,7 +48,8 @@ class FbaPricingContractTest {
             .contains("/api/platform/v1/inbounds/{inboundId}/fees/send:")
             .contains("/api/platform/v1/inbounds/{inboundId}/fees/published:")
             .contains("Idempotency-Key")
-            .contains("客服测量审核通过后自动计费、发布并完成入库")
+            .contains("主流程已到 WAIT_SPLIT，也可独立试算且不回退主流程状态")
+            .contains("该动作涉及后续仓储流程，本轮二期验收不调用")
             .contains("不回退 INBOUNDED 状态")
             .doesNotContain("应收")
             .doesNotContain("应付")

firstleg/src/test/java/com/baiyue/firstleg/service/FbaPricingServiceTest.java

@@ -100,6 +100,51 @@ class FbaPricingServiceTest {
         assertThat(response.totalAmount()).isEqualByComparingTo("100.01");
     }
 
+    @Test
+    @DisplayName("待分柜边界可独立计费且不回退主流程状态")
+    void calculatesAtWaitSplitWithoutRollingBackProcessStatus() {
+        readyRepository();
+        InboundPricingEntity inbound = inbound("100.000", "1.0000");
+        inbound.setProcessStatus("WAIT_SPLIT");
+        CustomerChargeRuleEntity rule = rule("KG", "167.000000", 3, "CEILING");
+        CarrierFbaRateEntity rate = rate("KG", "2.000000", "0.00");
+        when(repository.findInbound(TENANT, INBOUND)).thenReturn(inbound);
+        when(repository.matchRules(inbound, NOW)).thenReturn(List.of(rule));
+        when(repository.matchRates(inbound, "KG", NOW)).thenReturn(List.of(rate));
+
+        FeeSnapshotResponse response = service.calculate(TENANT, OPERATOR, INBOUND, NOW, "wait-split");
+
+        assertThat(response.feeStatus()).isEqualTo("CALCULATED");
+        assertThat(response.nextProcessStatus()).isEqualTo("WAIT_SPLIT");
+        verify(repository).markInboundCalculated(TENANT, INBOUND, "WAIT_SPLIT", "KG",
+            new BigDecimal("167.000"));
+    }
+
+    @Test
+    @DisplayName("待分柜边界确认费用后仍保持主流程状态")
+    void confirmsAtWaitSplitWithoutRollingBackProcessStatus() {
+        InboundPricingEntity inbound = inbound("10.000", "1.0000");
+        inbound.setProcessStatus("WAIT_SPLIT");
+        inbound.setFeeStatus("CALCULATED");
+        InboundFeeEntity fee = savedFee("CALCULATED");
+        when(repository.findLatestFee(TENANT, INBOUND)).thenReturn(fee);
+        when(repository.findIdempotency(TENANT, OPERATOR, "FEE_CONFIRM", "confirm-wait-split"))
+            .thenReturn(null);
+        doAnswer(invocation -> { ((InboundPricingIdempotencyEntity) invocation.getArgument(0)).setId(900L); return null; })
+            .when(repository).insertIdempotency(any());
+        when(repository.confirmFee(TENANT, 501L, OPERATOR, NOW)).thenReturn(1);
+        when(repository.markInboundConfirmed(TENANT, INBOUND)).thenReturn(1);
+        when(repository.completeIdempotency(any(), eq(501L), eq(NOW))).thenReturn(1);
+        when(repository.findFee(TENANT, 501L)).thenReturn(fee);
+        when(repository.findInbound(TENANT, INBOUND)).thenReturn(inbound);
+
+        FeeSnapshotResponse response = service.confirm(
+            TENANT, OPERATOR, INBOUND, "confirm-wait-split");
+
+        assertThat(response.nextProcessStatus()).isEqualTo("WAIT_SPLIT");
+        verify(repository).markInboundConfirmed(TENANT, INBOUND);
+    }
+
     @Test
     @DisplayName("审核未通过的测量快照禁止计费")
     void rejectsUnapprovedMeasurementSnapshot() {
@@ -137,15 +182,18 @@ class FbaPricingServiceTest {
     @DisplayName("同一幂等键重复试算直接返回原费用快照")
     void returnsOriginalSnapshotForRepeatedCalculation() {
         InboundPricingIdempotencyEntity completed = completed("FEE_CALCULATE", 501L);
+        InboundPricingEntity inbound = inbound("10", "1");
+        inbound.setProcessStatus("WAIT_SPLIT");
         when(repository.findIdempotency(TENANT, OPERATOR, "FEE_CALCULATE", "same")).thenReturn(completed);
         when(repository.findFee(TENANT, 501L)).thenReturn(savedFee("CALCULATED"));
-        when(repository.findInbound(TENANT, INBOUND)).thenReturn(inbound("10", "1"));
+        when(repository.findInbound(TENANT, INBOUND)).thenReturn(inbound);
         InboundFeeItemEntity item = new InboundFeeItemEntity(); item.setUnitPrice(new BigDecimal("2.00"));
         when(repository.findBaseItem(TENANT, 501L)).thenReturn(item);
 
         FeeSnapshotResponse response = service.calculate(TENANT, OPERATOR, INBOUND, NOW, "same");
 
         assertThat(response.feeId()).isEqualTo(501L);
+        assertThat(response.nextProcessStatus()).isEqualTo("WAIT_SPLIT");
         verify(repository, never()).matchRules(any(), any());
         verify(repository, never()).insertFee(any());
     }
@@ -233,7 +281,7 @@ class FbaPricingServiceTest {
         doAnswer(invocation -> { ((InboundFeeEntity) invocation.getArgument(0)).setId(501L); return null; })
             .when(repository).insertFee(any());
         when(repository.nextFeeVersion(TENANT, INBOUND)).thenReturn(1);
-        when(repository.markInboundCalculated(eq(TENANT), eq(INBOUND), any(), any())).thenReturn(1);
+        when(repository.markInboundCalculated(eq(TENANT), eq(INBOUND), any(), any(), any())).thenReturn(1);
         when(repository.completeIdempotency(any(), eq(501L), eq(NOW))).thenReturn(1);
     }