test(numbering): expect daily looseboard number on tail source

AGENTS.md

@@ -108,14 +108,14 @@
 
 ## 数据库访问与中文代码注释（所有服务及公共模块强制）
 
-- 本节适用于全部后端服务和公共模块；新增代码遵守下列规范，存量分层仅在影响本次正确性或用户明确要求时整改，不因局部修改迁移整条链路；以上为目标规范，不代表存量均已达标。
+- 本节适用于全部后端服务和公共模块；新增、修改的方法必须执行，触及的存量代码同步整改。登记本约束不代表存量代码已全部完成迁移和注释补齐。
 - 生产代码的关系型数据库读写统一经 MyBatis/MyBatis-Plus Mapper 执行；Controller、Service、定时任务、消费者、编号生成器和公共基础组件不得直接使用 `JdbcTemplate`、`NamedParameterJdbcTemplate`、原生 JDBC/Connection/Statement 或其他通道执行 SQL。仅改成 Repository 包装 JDBC 不算整改，SQL 必须进入 Mapper；无数据库职责的模块不得为满足本条新增数据库访问。
 - 正常业务数据库访问路径统一为 `Controller → Service → Repository → Mapper`，四层职责明确，不得省略 Repository，也不得由 Controller 直接调用 Repository/Mapper，或由 Service 直接调用 Mapper。定时任务、消费者等非 HTTP 入口从 Service 进入，同样经 Repository → Mapper 完成持久化访问。
 - Controller 负责请求接收、参数校验、入口权限和响应转换；Service 负责业务规则、编排及业务事务；Repository 负责领域数据访问封装、查询组合与持久化模型转换，对 Service 提供有业务含义的数据操作；Mapper 负责 SQL 执行及数据库记录映射。Repository 不承载业务状态流转，不直接用 JDBC 执行 SQL；Service 不继承 MyBatis-Plus `ServiceImpl` 等方式绕过 Repository。
 - 复杂查询、批量处理、原子计数、锁定读取、Outbox 和数据库监控查询同样经 Repository → Mapper，不以 SQL 特殊或实现方便为由跳层。公共模块需要数据库能力时，按现有模块边界定义 Repository/持久化接口，由所属服务的 Repository → Mapper 实现，禁止借此跨服务读库。
 - 迁移数据库操作须保留客户隔离条件、事务传播、行锁、幂等和并发语义；`LAST_INSERT_ID()` 等连接级操作必须在同一事务连接完成，并明确关闭相关读取缓存，不能仅机械搬移 SQL。Mapper 注册及扫描仍遵守下文统一规范。
 - 测试代码可用 `JdbcTemplate` 创建隔离测试表、准备数据及核对结果；被测生产路径仍必须调用实际 Mapper，不得把测试造数做法带入生产。数据库基线和迁移脚本按现有部署契约管理。
-- 本次新增或修改的手写方法及构造器须有简短中文业务注释，通常 1—3 行；接口与 Mapper 方法优先用中文 Javadoc，覆盖方法同样适用，关键规则就地说明。不补齐未修改或自动生成方法的注释。
+- 每个手写方法及构造器均须添加简短中文注释，通常 1—3 行说明业务用途；接口方法和 Mapper 方法优先使用中文 Javadoc。覆盖方法同样须有简短中文说明，实现中的关键规则仍须就地注释；自动生成的方法不手工逐个补注释。
 - 核心业务、复杂 SQL、状态流转、资金与库存变更、权限隔离、事务、锁、幂等、并发、重试和补偿逻辑，须在关键代码前增加适量中文注释，解释业务规则、处理原因、约束边界及失败影响；不逐行翻译代码，不添加无信息量或与实现不符的注释。
 - 新增和修改的代码说明注释统一使用中文；必要的技术标识、协议名、类名可保留原文，第三方许可证和生成标记保持原样。修改方法时同步更新相关存量英文或过期说明；审查时同时核对 Controller → Service → Repository → Mapper 分层及中文方法、核心逻辑注释。
 
@@ -132,11 +132,7 @@
 - 数据库只访问所属服务库。模块表结构位于 `<module>/src/main/resources/db/`；开发环境按最新模块基线和 `deploy/sql/头程数据库统一增量-MySQL8.sql` 收敛，不为历史开发数据新增兼容迁移。已有名称含 `migration` 的脚本仅作结构来源和追溯，部署说明见 `deploy/sql/README.md`；生产升级另按明确发布规则处理。
 - 后端同样遵守根指引中的“开发数据和上传文件可丢弃”边界：不得为现有开发库孤儿文件、旧文件归属或历史部分失败新增删除补偿接口、兼容复用、回填或清理链路；只修复当前正式上传与持久化路径，既有开发文件由人工重新上传。
 - 通用配置在 `config/nacos/test/`；服务日志、上传文件、`target/`、`reports/` 不属于源码。
-- 后端本地验证默认使用 `scripts/backend-check.ps1`，必须显式指定 `-Modules`，不传模块直接拒绝；命令及参数见 `scripts/README.md` 的“后端分层检查”。入口自动经 `local-check.ps1` 限流，`-DryRun` 只检查选择范围，不代表测试通过。
+- Java 签名变更的最低编译门禁是 `mvn -pl <module> -am test-compile`，它必须在部署前完成并覆盖测试源码；有行为变化时继续运行 `mvn -pl <module> -am test`。`-DskipTests` 可跳过测试执行但仍须保留测试编译，`-Dmaven.test.skip=true` 会跳过测试编译，不得作为签名变更的交付验证。全量验证仍使用 `mvn -DskipTests validate`、`mvn test`；不要在本地启动 Java/Nacos/数据库，除非用户明确要求。
-- 局部逻辑使用 `-Mode Focused -Tests <精确测试类名>`，覆盖修改行为及必要边界即可交付，不因收尾再跑 `Module`。Java 签名变化须覆盖生产与测试源码编译；定向测试已编译时不重复跑 `-Mode Compile`。只有影响扩及服务内多个行为且定向覆盖不足才选 `Module`，先说明原因。跨服务 DTO、接口或事件变化显式列入生产者和实际消费者；`-am` 仅补上游构建依赖，不自动包含下游或 HTTP/事件消费者。
-- 仅注释/文档调整不触发 Java 回归；脚本调整执行受影响脚本测试和登记合同。API、Mapper、AGENTS 等静态合同仍按各自触发条件执行。纯重构也应覆盖受影响行为，不能只用编译宣称回归通过。`-Dmaven.test.skip=true` 跳过测试编译，不得作为签名变更交付验证。
-- 全仓回归仅用于已确认影响广泛且定向覆盖不足的公共依赖/聚合拓扑/认证/序列化/基础模型变化，或用户要求的全量/跨域集成验收；先说明具体影响，不能因未查清范围而全跑。根 POM、依赖或测试配置改动先按实际影响选编译或测试，不一律全仓。入口为 `scripts/backend-full-regression.ps1`，CI 全量保留。普通提交、单服务任务或对话收尾不触发；有效结果复用，输入变化只补跑受影响范围。
-- 不以缩短耗时为由删除金额、库存、权限隔离、状态流转、幂等和并发测试；冗余测试须根据重复场景及维护成本单独评估。不要在本地启动 Java/Nacos/数据库，除非用户明确要求。
 - 同一批 `AGENTS.md` 索引修改完成后从后端根统一运行一次 `./scripts/agents-index-contract.ps1`；脚本只读源码目录和指定指引，不访问 HTTP、数据库或部署环境。
 - Mapper 注册静态合同为 `scripts/mapper-scan-contract.mjs`、`mapper-scan-contract.test.mjs`：自动发现聚合模块、生产 `*Mapper` 接口、服务启动类和分散扫描配置，不启动 Spring、不连接数据库；遗漏注解、扫描根漂移或重新引入子域扫描时直接失败并输出类与文件路径。
 - 单服务镜像构建/部署从 `Jenkinsfile.service`、`deploy/docker/Dockerfile`、`deploy/scripts/deploy-built-service.sh` 进入；新镜像启动失败或健康检查失败时只允许回滚到同服务先前镜像，并保持任务失败，离线合同见 `scripts/deploy-built-service-rollback.test.mjs`。实际部署仍须当前对话明确授权。

Jenkinsfile

@@ -67,8 +67,6 @@ def parseAutoBuildState(String description, List<String> allowedServices) {
     List<String> failedServices = []
     if (state.startsWith('RESULTS')) {
         String summary = state.substring('RESULTS'.length()).trim()
-        int metadataIndex = summary.indexOf(' | ')
-        if (metadataIndex >= 0) summary = summary.substring(0, metadataIndex).trim()
         summary.split(',').collect { it.trim() }.findAll { it }.each { item ->
             int separator = item.indexOf('=')
             if (separator > 0) {
@@ -105,25 +103,6 @@ def previousAutoBuildState(def previousBuild, List<String> allowedServices) {
     return null
 }
 
-// 测试范围必须相对成功门禁，而非失败/取消轮次；否则补跑可能遗漏前次未通过的变更。
-def previousSuccessfulTestCommit(def previousBuild, List<String> requiredServices) {
-    def candidate = previousBuild
-    int inspected = 0
-    while (candidate != null && inspected < 30) {
-        String description = candidate.description ?: ''
-        String marker = ' | TESTS=PASSED '
-        int markerIndex = description.lastIndexOf(marker)
-        if (candidate.result == 'SUCCESS' && markerIndex >= 0) {
-            List metadata = description.substring(markerIndex + marker.length()).trim().split(' ')
-            if (metadata.size() == 2 && metadata[0] ==~ /[0-9a-fA-F]{7,40}/ &&
-                requiredServices.every { metadata[1].split(',').contains(it) }) return metadata[0]
-        }
-        candidate = candidate.previousBuild
-        inspected++
-    }
-    return ''
-}
-
 def environmentChoicesForJob(String jobBaseName) {
     return [fixedEnvironmentForJob(jobBaseName) ?: 'test']
 }
@@ -182,9 +161,7 @@ pipeline {
         choice(name: 'ENVIRONMENT', choices: environmentChoicesForJob(env.JOB_BASE_NAME), description: '部署环境')
         booleanParam(name: 'DEPLOY', defaultValue: false, description: '各服务构建成功后是否独立部署')
         booleanParam(name: 'SKIP_TESTS', defaultValue: false, description: '是否跳过测试执行（仍编译测试源码）')
-        choice(name: 'TEST_SCOPE', choices: ['AUTO', 'MODULE'], description: 'AUTO 对已支持的局部变更执行关联测试；公共/未知变更自动完整模块回归；MODULE 显式完整模块回归')
+        string(name: 'IMAGE_REPOSITORY', defaultValue: '', description: '必须填写已核实的共享镜像仓库地址 host[:port]/owner/image')
-        // 地址由当前 Job 配置提供；参数声明刷新时保留已配置值，不将环境地址写入源码。
-        string(name: 'IMAGE_REPOSITORY', defaultValue: params.IMAGE_REPOSITORY ?: '', description: '沿用当前 Job 已配置的镜像仓库地址；首次配置或更换仓库时填写 host[:port]/owner/image')
         string(name: 'DOCKER_BASE_IMAGE', defaultValue: 'eclipse-temurin:17-jre-alpine', description: 'Java 17 基础镜像')
         choice(name: 'DOWNSTREAM_JOB_PREFIX', choices: downstreamJobPrefixChoicesForJob(env.JOB_BASE_NAME), description: '由当前总控 Job 固定的单服务 Job 前缀')
     }
@@ -291,7 +268,6 @@ pipeline {
                     selected = selected.unique()
 
                     env.SELECTED_SERVICES = selected.join(',')
-                    env.TEST_BASE_COMMIT = previousSuccessfulTestCommit(currentBuild.previousBuild, selected)
                     env.NO_SERVICE_CHANGE = selected ? 'false' : 'true'
                     if (!selected) {
                         currentBuild.description = params.BUILD_MODE == 'AUTO'
@@ -358,22 +334,16 @@ pipeline {
                         .findAll { it }
                         .join(',')
                     echo "统一测试本次选中的服务及其公共依赖: ${selectedModules}"
-                    String testPlan = "${pwd(tmp: true)}/ci-test-plan.json"
                     lock(resource: 'firstleg-test-maven') {
                         timeout(time: 50, unit: 'MINUTES') {
                             sh """
                                 test \"\$(git rev-parse HEAD)\" = \"${env.SOURCE_COMMIT}\"
                                 find . -type f -path '*/target/surefire-reports/TEST-*.xml' -delete
-                                node deploy/scripts/ci-test-scope.mjs plan --modules '${selectedModules}' --base '${env.TEST_BASE_COMMIT ?: ''}' --mode '${env.RESOLVED_ENVIRONMENT == 'test' ? (params.TEST_SCOPE ?: 'AUTO') : 'MODULE'}' --plan '${testPlan}'
+                                sh deploy/scripts/run-ci-maven.sh --settings deploy/maven/settings-ci.xml --batch-mode --errors -pl ${selectedModules} -am test
-                                node deploy/scripts/ci-test-scope.mjs checks --plan '${testPlan}'
-                                test_arguments=\"\$(node deploy/scripts/ci-test-scope.mjs args --plan '${testPlan}')\"
-                                sh deploy/scripts/run-ci-maven.sh --settings deploy/maven/settings-ci.xml --batch-mode --errors -pl ${selectedModules} -am test \$test_arguments
-                                node deploy/scripts/ci-test-scope.mjs verify --plan '${testPlan}'
                             """
                         }
                     }
                     echo "统一测试门禁通过: ${env.SOURCE_COMMIT}；下游单服务任务不再重复执行测试"
-                    env.TEST_GATE_PASSED = 'true'
                 }
             }
             post {
@@ -430,9 +400,6 @@ pipeline {
                     currentBuild.description = params.BUILD_MODE == 'AUTO'
                         ? "AUTO ${env.IMAGE_TAG} | RESULTS ${summary}"
                         : "${env.IMAGE_TAG} | ${summary}"
-                    if (env.TEST_GATE_PASSED == 'true') {
-                        currentBuild.description += " | TESTS=PASSED ${env.SOURCE_COMMIT} ${env.SELECTED_SERVICES}"
-                    }
                     if (failed) {
                         unstable("部分服务执行失败，但其他服务已独立完成：${failed.join(', ')}")
                     }

Jenkinsfile.service

@@ -49,8 +49,7 @@ pipeline {
         booleanParam(name: 'ALLOW_SAME_CONTRACT_ROLLBACK', defaultValue: false, description: '仅确认相同协议与Schema时允许回滚；架构切换保持关闭')
         booleanParam(name: 'DEPLOY', defaultValue: false, description: '构建成功后是否部署本服务')
         booleanParam(name: 'SKIP_TESTS', defaultValue: false, description: '是否跳过测试')
-        // 独立构建沿用本 Job 配置，总控调度时保留其明确传入的地址。
+        string(name: 'IMAGE_REPOSITORY', defaultValue: '', description: '必须填写已核实的共享镜像仓库基础路径，不包含服务名和标签')
-        string(name: 'IMAGE_REPOSITORY', defaultValue: params.IMAGE_REPOSITORY ?: '', description: '沿用当前 Job 已配置的镜像仓库基础路径，不包含服务名和标签；首次配置或更换仓库时填写')
         string(name: 'DOCKER_BASE_IMAGE', defaultValue: 'eclipse-temurin:17-jre-alpine', description: 'Java 17 基础镜像')
     }
 

README.md

@@ -23,16 +23,11 @@
 ## 本地构建
 
 ```powershell
-# 日常按受影响模块检查；跨服务变更显式列入消费者。
+mvn -DskipTests validate
-.\scripts\backend-check.ps1 -Modules order -Mode Compile
+node --test scripts/java-topology-contract.test.mjs
-.\scripts\backend-check.ps1 -Modules order
+mvn test
-# 根构建/拓扑变化等全量触发条件见 AGENTS.md。
-.\scripts\local-check.ps1 -Command @('node', '--test', 'scripts/java-topology-contract.test.mjs')
-.\scripts\backend-full-regression.ps1
 ```
 
-开发中可通过 `backend-check.ps1 -Mode Focused -Modules <模块> -Tests <精确测试类名>` 快速反馈；参数、DryRun 和结果边界见 [后端分层检查](scripts/README.md#后端分层检查)。单服务修改收尾执行模块回归，不默认执行上面的全仓命令。
-
 GitLab 在独立 Node 镜像中自动执行拓扑合同，随后才允许服务制品打包。Maven `verify` 会为执行过测试且产生覆盖率数据的模块生成 `target/site/jacoco/index.html` 与 `jacoco.xml`；当前只生成报告，不设置覆盖率阈值，也不改变测试选择。Jenkins 的 `java-builder` 尚未在仓库中声明 Node 运行时，因此暂不重复执行该 Node 合同，以 GitLab 门禁和上述本地命令为准。
 
 2026-07-30 订单与客户前端联调缺口已完成真实回归：19 个 Reactor 项目构建成功，75 项单元及组件测试、68 项认证与 IAM 真实 API、37 项订单与仓库真实 API 全部通过。详细证据见 `docs/phase1-business-maturity-regression-report.md`。

common-event-contract/src/main/java/com/baiyue/common/event/ContainerNumbers.java

@@ -2,11 +2,15 @@ package com.baiyue.common.event;
 
 import java.util.Locale;
 
-/** 跨服务业务事实使用的真实集装箱号，只规范化空白和大小写，不校验 ISO 格式。 */
+/** Canonical physical container number used by cross-region business facts. */
 public final class ContainerNumbers {
+    private static final int[] LETTER_VALUES = {
+        10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24,
+        25, 26, 27, 28, 29, 30, 31, 32, 34, 35, 36, 37, 38
+    };
+
     private ContainerNumbers() { }
 
-    /** 柜号必须非空；统一移除格式空白并转大写，保留业务录入值。 */
     public static String normalizeRequired(String value) {
         if (value == null || value.isBlank()) {
             throw new IllegalArgumentException("containerNo is required");
@@ -15,13 +19,21 @@ public final class ContainerNumbers {
         value.codePoints().filter(codePoint -> !Character.isWhitespace(codePoint)
             && !Character.isSpaceChar(codePoint)).forEach(compact::appendCodePoint);
         String normalized = compact.toString().toUpperCase(Locale.ROOT);
-        if (normalized.isEmpty()) {
+        if (!normalized.matches("[A-Z]{3}[UJZ][0-9]{7}")) {
-            throw new IllegalArgumentException("containerNo is required");
+            throw new IllegalArgumentException("containerNo must comply with ISO 6346");
+        }
+        int sum = 0;
+        for (int index = 0; index < 10; index++) {
+            char current = normalized.charAt(index);
+            int number = Character.isDigit(current) ? current - '0' : LETTER_VALUES[current - 'A'];
+            sum += number * (1 << index);
+        }
+        if (normalized.charAt(10) - '0' != sum % 11 % 10) {
+            throw new IllegalArgumentException("containerNo must comply with ISO 6346 check digit");
         }
         return normalized;
     }
 
-    /** 冻结事实必须已规范化，避免生产与消费端的快照或哈希发生漂移。 */
     public static String requireCanonical(String value) {
         String normalized = normalizeRequired(value);
         if (!normalized.equals(value)) {

common-event-contract/src/main/java/com/baiyue/common/event/WalletSettlementReference.java

@@ -1,13 +1,4 @@
 package com.baiyue.common.event;
 
-/** 成功扣款凭据；资金业务身份独立于费用对应的实际服务订单。 */
+/** Finance-issued identity of a successful consumption, carried by its immutable fee source. */
-public record WalletSettlementReference(String commandEventId, String holdId, String ledgerId,
+public record WalletSettlementReference(String commandEventId, String holdId, String ledgerId) { }
-    @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL)
-    String walletBusinessType,
-    @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL)
-    String walletBusinessNo) {
-    /** 原有资金身份与服务订单一致的来源继续使用原三项凭据。 */
-    public WalletSettlementReference(String commandEventId, String holdId, String ledgerId) {
-        this(commandEventId, holdId, ledgerId, null, null);
-    }
-}

common-event-contract/src/main/java/com/baiyue/common/event/package-info.java

@@ -1,11 +1,4 @@
 /**
  * 国内与海外业务单元共享的稳定事件契约。
- *
- * <p>海外费用的 walletSettlement 引用成功扣款的 commandEventId、holdId、ledgerId。
- * 独立资金流程另外携带 walletBusinessType、walletBusinessNo：人工费用为
- * OVERSEAS_MANUAL_FEE / 来源费用ID-冻结次数，仓租为 STORAGE_RENT / 出库预占ID。
- * 外层 businessType、businessNo 始终表示实际服务订单，不能替换为资金流程编号。
- * Finance 同时核对冻结、实扣流水、成功指令结果及客户金额，一个 hold 只能关联一个费用来源。
- * 资金身份与服务订单一致的既有引用省略这两个字段，保持既有快照哈希。</p>
  */
 package com.baiyue.common.event;

common-event-contract/src/test/java/com/baiyue/common/event/ContainerNumbersTest.java

@@ -1,41 +1,20 @@
 package com.baiyue.common.event;
 
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.NullAndEmptySource;
-import org.junit.jupiter.params.provider.ValueSource;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 class ContainerNumbersTest {
-    /** 规范化仍保持确定性，事件只能接受已冻结的规范值。 */
     @Test
-    void normalizesWhitespaceAndCaseButCanonicalFactsRequireExactValue() {
+    void normalizesWhitespaceAndCaseButCanonicalFactsRequireExactIso6346Value() {
         assertThat(ContainerNumbers.normalizeRequired(" zcsu 7881970 ")).isEqualTo("ZCSU7881970");
+        assertThat(ContainerNumbers.requireCanonical("ZCSU7881970")).isEqualTo("ZCSU7881970");
         assertThatThrownBy(() -> ContainerNumbers.requireCanonical("zcsu7881970"))
             .hasMessageContaining("normalized");
-        assertThatThrownBy(() -> ContainerNumbers.requireCanonical(" JZXH10231043 "))
+        assertThatThrownBy(() -> ContainerNumbers.normalizeRequired("ZCSU7881971"))
-            .hasMessageContaining("normalized");
+            .hasMessageContaining("check digit");
-    }
+        assertThatThrownBy(() -> ContainerNumbers.normalizeRequired("CAB-260831-0001"))
-
+            .hasMessageContaining("ISO 6346");
-    /** 非 ISO 柜号可以作为事件事实，不在下游重新阻断。 */
-    @ParameterizedTest
-    @ValueSource(strings = {"JZXH10231043", "ZCSU7881971", "MSCA6639870", "ABC", "ABCU123456789012", "LOCAL-2026-001"})
-    void acceptsNonIsoNumber(String containerNo) {
-        assertThat(ContainerNumbers.normalizeRequired(" " + containerNo.toLowerCase(java.util.Locale.ROOT) + " "))
-            .isEqualTo(containerNo);
-        assertThat(ContainerNumbers.requireCanonical(containerNo)).isEqualTo(containerNo);
-    }
-
-    /** 规范化前后均不得将空白柜号作为业务事实。 */
-    @ParameterizedTest
-    @NullAndEmptySource
-    @ValueSource(strings = {"   ", "\u00a0\u3000"})
-    void rejectsMissingNumber(String containerNo) {
-        assertThatThrownBy(() -> ContainerNumbers.normalizeRequired(containerNo))
-            .isInstanceOf(IllegalArgumentException.class).hasMessageContaining("required");
-        assertThatThrownBy(() -> ContainerNumbers.requireCanonical(containerNo))
-            .isInstanceOf(IllegalArgumentException.class).hasMessageContaining("required");
     }
 }

common-event-contract/src/test/java/com/baiyue/common/event/WalletSettlementReferenceTest.java

@@ -1,22 +0,0 @@
-package com.baiyue.common.event;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.jupiter.api.Test;
-import static org.assertj.core.api.Assertions.assertThat;
-
-class WalletSettlementReferenceTest {
-    private final ObjectMapper json = new ObjectMapper();
-
-    @Test
-    void oldReferencesRetainExactHashShape() throws Exception {
-        String original = "{\"commandEventId\":\"c1\",\"holdId\":\"9\",\"ledgerId\":\"72\"}";
-        var reference = json.readValue(original, WalletSettlementReference.class);
-        assertThat(json.readTree(json.writeValueAsString(reference))).isEqualTo(json.readTree(original));
-    }
-
-    @Test
-    void dedicatedFundingIdentitySurvivesRoundTrip() throws Exception {
-        var reference = new WalletSettlementReference("c1", "9", "72", "STORAGE_RENT", "445");
-        assertThat(json.readValue(json.writeValueAsString(reference), WalletSettlementReference.class)).isEqualTo(reference);
-    }
-}

common-web/src/main/java/com/baiyue/common/web/GlobalExceptionHandler.java

@@ -40,14 +40,8 @@ public class GlobalExceptionHandler {
     @Autowired(required = false)
     private MeterRegistry meterRegistry;
 
-    /** 系统类业务失败必须记录链路和异常，普通业务校验仍只返回统一响应。 */
     @ExceptionHandler(BizException.class)
     public ResponseEntity<ApiResponse<Void>> handleBusiness(BizException exception, HttpServletRequest request) {
-        if (exception.getResultCode().httpStatus().is5xxServerError()) {
-            log.error("系统业务请求失败 method={} path={} code={} requestId={} traceId={}",
-                    request.getMethod(), request.getRequestURI(), exception.getResultCode().code(),
-                    CorrelationContext.requestId(request), CorrelationContext.traceId(request), exception);
-        }
         return failure(exception.getResultCode(), exception.getMessage(), request);
     }
 

common-web/src/test/java/com/baiyue/common/web/GlobalExceptionHandlerTest.java

@@ -5,9 +5,6 @@ import com.baiyue.common.core.exception.BizException;
 import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.springframework.boot.test.system.CapturedOutput;
-import org.springframework.boot.test.system.OutputCaptureExtension;
 import org.springframework.mock.web.MockHttpServletRequest;
 import org.springframework.core.MethodParameter;
 import org.springframework.validation.BeanPropertyBindingResult;
@@ -42,37 +39,6 @@ class GlobalExceptionHandlerTest {
         assertThat(response.getBody().requestId()).isEqualTo("r1");
     }
 
-    /** 系统类业务失败留下路径、关联标识和根因，但不打印请求参数或令牌。 */
-    @Test
-    @ExtendWith(OutputCaptureExtension.class)
-    void systemBusinessFailureLogsCorrelationAndCause(CapturedOutput output) {
-        MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/platform/v1/orders/status-counts");
-        request.setAttribute(CorrelationContext.REQUEST_ID, "status-count-request");
-        request.setAttribute(CorrelationContext.TRACE_ID, "status-count-trace");
-        request.setQueryString("keyword=private-query");
-        request.addHeader("X-Internal-Service-Token", "private-service-token");
-        BizException exception = new BizException(ResultCode.SERVICE_UNAVAILABLE, "统计暂不可用");
-        exception.initCause(new IllegalStateException("缺少尾程来源"));
-
-        var response = handler.handleBusiness(exception, request);
-
-        assertThat(response.getStatusCode().value()).isEqualTo(200);
-        assertThat(response.getBody().code()).isEqualTo("S0503");
-        assertThat(response.getBody().message()).isEqualTo("统计暂不可用");
-        assertThat(output.getOut()).contains("ERROR", "GET", "/api/platform/v1/orders/status-counts",
-                "S0503", "status-count-request", "status-count-trace", "缺少尾程来源")
-                .doesNotContain("private-query", "private-service-token");
-    }
-
-    /** 预期的业务冲突不应升级为系统错误日志。 */
-    @Test
-    @ExtendWith(OutputCaptureExtension.class)
-    void normalBusinessFailureDoesNotLogSystemError(CapturedOutput output) {
-        handler.handleBusiness(new BizException(ResultCode.CONFLICT, "normal-business-conflict"),
-                new MockHttpServletRequest());
-        assertThat(output.getAll()).doesNotContain("系统业务请求失败", "normal-business-conflict");
-    }
-
     @Test
     void invalidQueryParameterTypeMapsToBadRequest() throws Exception {
         MockHttpServletRequest request = new MockHttpServletRequest();

config/nacos/test/finance-service.yml

@@ -5,8 +5,7 @@ spring:
     password: ${FINANCE_DB_PASSWORD}
     driver-class-name: com.mysql.cj.jdbc.Driver
 baiyue.clients.warehouse.url: ${WAREHOUSE_SERVICE_URL:}
-# TEST 流程验收复用 Client 的示例图片，图片标注不可付款且不含真实收款信息。
+baiyue.finance.recharge.qr-code-url: ${FINANCE_RECHARGE_QR_CODE_URL:}
-baiyue.finance.recharge.qr-code-url: ${FINANCE_RECHARGE_QR_CODE_URL:/customer-recharge-qr.svg}
 baiyue.finance.wallet.default-credit-limit: ${FINANCE_WALLET_DEFAULT_CREDIT_LIMIT:0.00}
 baiyue.event-delivery.operations-token: ${EVENT_OPERATIONS_TOKEN:}
 baiyue.event-delivery.connect-timeout-ms: ${EVENT_CONNECT_TIMEOUT_MS:3000}

deploy/scripts/ci-test-scope.mjs

@@ -1,226 +0,0 @@
-#!/usr/bin/env node
-import { readFileSync, readdirSync, writeFileSync, statSync } from 'node:fs'
-import { resolve, relative, basename } from 'node:path'
-import { execFileSync } from 'node:child_process'
-import { fileURLToPath } from 'node:url'
-
-const moduleName = 'lastleg-service'
-const testClass = /(?:^Test.+|.+(?:Test|Tests|TestCase))\.java$/
-const words = source => new Set(source.match(/[A-Za-z_$][A-Za-z0-9_$]*/g) || [])
-const tables = source => new Set(source.match(/\bll_[a-z0-9_]+\b/g) || [])
-const writtenTables = source => new Set([...source.matchAll(/\b(?:UPDATE|INSERT\s+(?:IGNORE\s+)?INTO|DELETE\s+FROM)\s+(ll_[a-z0-9_]+)/gi)].map(match => match[1]))
-
-// 按完整注解比较 SQL，避免只改 SELECT 时把同一 Mapper 内未改的全部写语句扩大为全域回归。
-function writeStatements(source) {
-  const result = []
-  for (const match of source.matchAll(/@(?:Insert|Update|Delete)\s*\(/g)) {
-    let depth = 1, quote = '', index = match.index + match[0].length
-    for (; index < source.length && depth; index++) {
-      if (quote) {
-        if (source.startsWith(quote, index)) { index += quote.length - 1; quote = '' }
-        else if (source[index] === '\\' && quote.length === 1) index++
-      } else if (source.startsWith('"""', index)) { quote = '"""'; index += 2 }
-      else if (source[index] === '"' || source[index] === "'") quote = source[index]
-      else if (source[index] === '(') depth++
-      else if (source[index] === ')') depth--
-    }
-    if (depth) throw new Error('Cannot parse SQL annotation; use MODULE test scope')
-    result.push(source.slice(match.index, index))
-  }
-  return result
-}
-
-function changedWrites(node) {
-  if (node.previousSource === undefined) return writtenTables(node.source)
-  const before = writeStatements(node.previousSource), after = writeStatements(node.source)
-  const changed = [...before.filter(sql => !after.includes(sql)), ...after.filter(sql => !before.includes(sql))]
-  const oldRest = before.reduce((text, sql) => text.replace(sql, ''), node.previousSource)
-  const newRest = after.reduce((text, sql) => text.replace(sql, ''), node.source)
-  if (oldRest !== newRest) changed.push(oldRest, newRest)
-  return writtenTables(changed.join('\n'))
-}
-
-/** 宁可扩大范围，不用文件名猜测唯一测试；未识别的输入保留完整模块门禁。 */
-export function planTests({ modules, mode = 'AUTO', changes = [], sources = [], baseline = '' }) {
-  const architectureScript = `${moduleName}/scripts/analyze-lastleg-dependencies`
-  const staticChecks = changes.some(path => path.startsWith(architectureScript))
-    ? [`${architectureScript}.test.mjs`] : []
-  const full = reason => ({ scope: 'MODULE', reason, modules, baseline, tests: [], staticChecks })
-  if (mode !== 'AUTO' && mode !== 'MODULE') throw new Error('TEST_SCOPE must be AUTO or MODULE')
-  if (mode === 'MODULE') return full('显式完整模块回归')
-  if (!baseline) return full('没有成功测试基线')
-  if (modules.length !== 1 || modules[0] !== moduleName) return full('多服务或尚未核对的服务采用完整模块回归')
-  const prefix = `${moduleName}/`
-  const relevant = changes.filter(path => path.startsWith(prefix))
-  const shared = changes.some(path => path !== 'scripts/agents-index-contract.ps1' && !path.startsWith(prefix)
-    && /^(?:common-[^/]+\/|platform-bom\/|pom\.xml$|Jenkinsfile|deploy\/|config\/|scripts\/.*\.(?:mjs|sh|ps1)$)/.test(path))
-  if (shared) return full('公共能力、发布或测试基础设施变更')
-  if (!relevant.length) return full('补跑服务没有可验证的业务差异')
-  const java = `${prefix}src/main/java/com/baiyue/lastleg/`
-  const supported = path => path.startsWith(`${prefix}src/test/java/`)
-    || path.startsWith(`${prefix}src/main/resources/openapi/`)
-    || path.startsWith(architectureScript)
-    || (path.startsWith(java) && path.slice(java.length).includes('/')
-      && !/^(?:config|security|entity|dto|model|mapper|repository|service|client)\//.test(path.slice(java.length)))
-    || /\.(?:md)$/.test(path)
-  if (relevant.some(path => !supported(path))) return full('共享模型、配置、SQL、资源或未识别路径变更')
-
-  const nodes = sources.map(({ path, source, previousSource }) => ({ path, source, previousSource,
-    symbol: basename(path, '.java'), tokens: words(source), tables: tables(source),
-    test: path.startsWith(`${prefix}src/test/java/`),
-    name: `${source.match(/\bpackage\s+([\w.]+)\s*;/)?.[1] || ''}.${basename(path, '.java')}` }))
-  const byPath = new Map(nodes.map(node => [node.path, node]))
-  const bySymbol = new Map()
-  for (const node of nodes) {
-    if (!bySymbol.has(node.symbol)) bySymbol.set(node.symbol, [])
-    bySymbol.get(node.symbol).push(node)
-  }
-  const reverse = new Map(nodes.map(node => [node.path, new Set()]))
-  for (const node of nodes) {
-    // 包含反射字符串、静态 import、同包引用及测试夹具；重名类全部纳入。
-    for (const token of node.tokens) for (const dependency of bySymbol.get(token) || []) {
-      if (dependency !== node) reverse.get(dependency.path).add(node.path)
-    }
-    // 实现变化也要覆盖只依赖接口/基类的调用者，不能仅沿显式 import 反查。
-    for (const match of node.source.matchAll(/\b(?:implements|extends)\s+([^{};]+)/g)) {
-      for (const token of words(match[1])) for (const contract of bySymbol.get(token) || []) {
-        if (contract !== node) reverse.get(node.path).add(contract.path)
-      }
-    }
-  }
-  const seeds = new Set()
-  const changedTables = new Set()
-  for (const path of relevant.filter(path => path.endsWith('.java'))) {
-    const node = byPath.get(path)
-    if (node) {
-      seeds.add(path)
-      // 读查询变化不改变其他查询的数据；潜在写入变化则纳入同表读写消费者。
-      if (!node.test) for (const table of changedWrites(node)) changedTables.add(table)
-    } else {
-      // 删除/移动旧类型时，仍按旧类名查现存消费者。
-      const symbol = basename(path, '.java')
-      const consumers = nodes.filter(consumer => consumer.tokens.has(symbol))
-      if (!consumers.length) return full('删除类型缺少可追踪的现存消费者')
-      for (const consumer of consumers) seeds.add(consumer.path)
-    }
-  }
-  if (!seeds.size) return full('没有可追踪的 Java 行为差异')
-  for (const node of nodes) if ([...node.tables].some(table => changedTables.has(table))) seeds.add(node.path)
-  const affected = new Set(seeds)
-  const queue = [...seeds]
-  for (let index = 0; index < queue.length; index++) {
-    for (const consumer of reverse.get(queue[index]) || []) if (!affected.has(consumer)) {
-      affected.add(consumer); queue.push(consumer)
-    }
-  }
-  const allTests = nodes.filter(node => node.test && testClass.test(basename(node.path))
-    && /@(?:Test|ParameterizedTest|RepeatedTest|TestFactory|TestTemplate)\b/.test(node.source))
-  const contractChange = relevant.some(path => path.startsWith(`${prefix}src/main/resources/openapi/`))
-  const candidates = allTests.filter(node => affected.has(node.path)
-    || /(?:Security|Isolation|MapperRegistrationArchitecture|QueryBinding)/.test(node.symbol)
-    || (contractChange && /(?:Contract|OpenApi|Schema|Architecture|Permission)/.test(node.symbol)))
-  // 显式依赖真实环境的类仍由 MODULE/专项授权入口负责，不能把它们默认跳过算作执行成功。
-  const optIn = node => /@(?:EnabledIf(?:SystemProperty|EnvironmentVariable)|Disabled(?:IfSystemProperty|IfEnvironmentVariable)?\b)/
-    .test(node.source.slice(0, node.source.indexOf(`class ${node.symbol}`)))
-  const tests = candidates.filter(node => !optIn(node))
-  if (!tests.some(node => affected.has(node.path))) return full('没有匹配到行为测试，拒绝零测试通过')
-  if (tests.some(node => !/^com\.[\w.$]+$/.test(node.name))) return full('测试类名无法安全传入 Maven')
-  return { scope: 'AFFECTED', reason: 'Java 反向引用、接口实现、测试夹具、共享 SQL 表和相关静态合同',
-    modules, baseline, tests: tests.map(node => node.name).sort(), totalTests: allTests.length, staticChecks,
-    optInTests: candidates.filter(optIn).map(node => node.name).sort() }
-}
-
-function walk(root) {
-  const files = []
-  for (const item of readdirSync(root, { withFileTypes: true })) {
-    const path = resolve(root, item.name)
-    if (item.isDirectory()) files.push(...walk(path))
-    else if (item.isFile() && item.name.endsWith('.java')) files.push(path)
-  }
-  return files
-}
-
-/** 每个所选类必须有本轮实际执行的报告；允许上游零匹配不能变成整个门禁零测试。 */
-export function verifyReports(plan, reports) {
-  if (plan.scope !== 'AFFECTED') return
-  for (const name of plan.tests) {
-    const matches = reports.filter(report => report.name === name || report.name.startsWith(`${name}$`))
-    if (!matches.length || matches.some(report => report.failures || report.errors
-      || ['tests', 'skipped', 'failures', 'errors'].some(key => !Number.isInteger(report[key]) || report[key] < 0)
-      || report.skipped > report.tests)
-      || matches.reduce((sum, report) => sum + report.tests - report.skipped, 0) <= 0) {
-      throw new Error(`Missing, skipped or failed fresh test report: ${name}`)
-    }
-  }
-}
-
-function main(args) {
-  const [action, ...options] = args
-  const values = {}
-  for (let i = 0; i < options.length; i += 2) {
-    if (!options[i].startsWith('--') || options[i + 1] === undefined) throw new Error('Expected --name value')
-    values[options[i].slice(2)] = options[i + 1]
-  }
-  const root = process.cwd()
-  const planFile = values.plan
-  if (!planFile) throw new Error('--plan is required')
-  if (action === 'plan') {
-    const modules = (values.modules || '').split(',')
-    if (modules.some(module => !/^[a-z][a-z0-9-]+$/.test(module))) throw new Error('Invalid modules')
-    let baseline = values.base || ''
-    let changes = []
-    if (baseline) {
-      if (!/^[0-9a-f]{7,40}$/i.test(baseline)) throw new Error('Invalid baseline commit')
-      try {
-        execFileSync('git', ['merge-base', '--is-ancestor', baseline, 'HEAD'], { stdio: 'pipe' })
-        changes = execFileSync('git', ['diff', '--name-only', '-z', baseline, 'HEAD'], { encoding: 'utf8' }).split('\0').filter(Boolean)
-      } catch { baseline = '' }
-    }
-    const sources = modules.length === 1 && modules[0] === moduleName
-      ? ['main', 'test'].flatMap(set => walk(resolve(root, moduleName, 'src', set, 'java')))
-        .map(path => {
-          const key = relative(root, path).replaceAll('\\', '/')
-          const entry = { path: key, source: readFileSync(path, 'utf8') }
-          if (baseline && changes.includes(key)) {
-            try { entry.previousSource = execFileSync('git', ['show', `${baseline}:${key}`], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }) }
-            catch { entry.previousSource = '' }
-          }
-          return entry
-        }) : []
-    const plan = { ...planTests({ modules, mode: values.mode || 'AUTO', baseline, changes, sources }), startedAt: Date.now() }
-    writeFileSync(planFile, JSON.stringify(plan))
-    console.log(`CI test scope: ${plan.scope}; ${plan.reason}`)
-    if (plan.scope === 'AFFECTED') console.log(`Selected ${plan.tests.length}/${plan.totalTests} test classes:\n${plan.tests.join('\n')}`)
-    if (plan.optInTests?.length) console.log(`Explicit environment tests remain opt-in (not counted as passed): ${plan.optInTests.join(',')}`)
-    return
-  }
-  const plan = JSON.parse(readFileSync(planFile, 'utf8'))
-  if (action === 'args') {
-    if (plan.scope === 'AFFECTED') process.stdout.write(`-Dtest=${plan.tests.join(',')} -Dsurefire.failIfNoSpecifiedTests=false -Dci.sql-semantic.skip=true`)
-  } else if (action === 'checks') {
-    for (const check of plan.staticChecks || []) {
-      if (check !== `${moduleName}/scripts/analyze-lastleg-dependencies.test.mjs`) throw new Error('Unsupported static check')
-      execFileSync(process.execPath, ['--test', '--test-concurrency=2', check], { stdio: 'inherit' })
-    }
-  } else if (action === 'verify') {
-    const reports = []
-    if (plan.scope === 'AFFECTED') for (const module of plan.modules) {
-      const directory = resolve(root, module, 'target/surefire-reports')
-      for (const filename of readdirSync(directory)) {
-        if (!/^TEST-.*\.xml$/.test(filename)) continue
-        const path = resolve(directory, filename)
-        if (statSync(path).mtimeMs < plan.startedAt - 2000) continue
-        const xml = readFileSync(path, 'utf8').match(/<testsuite\b([^>]+)>/)?.[1]
-        if (!xml) continue
-        const attrs = Object.fromEntries([...xml.matchAll(/([\w-]+)="([^"]*)"/g)].map(match => [match[1], match[2]]))
-        reports.push({ name: attrs.name || '', ...Object.fromEntries(['tests', 'failures', 'errors', 'skipped'].map(key => [key, Number(attrs[key] || 0)])) })
-      }
-    }
-    verifyReports(plan, reports)
-    console.log(`CI test reports verified: ${plan.scope}`)
-  } else throw new Error(`Unknown action: ${action}`)
-}
-
-if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  try { main(process.argv.slice(2)) } catch (error) { console.error(error.message); process.exitCode = 1 }
-}

deploy/sql/20261022-海外费用仓租数据库变更汇总.md

@@ -1,39 +0,0 @@
-# 海外费用与仓租数据库定义汇总
-
-本次功能的数据库定义已统一到下面两份 SQL，五份重复版本脚本和两份专项汇总 SQL 已移除。仅整理文件，未连接数据库、执行 SQL 或部署。
-
-## 两个统一入口
-
-| 文件 | 相关数据库 | 本次内容 |
-|---|---|---|
-| [头程数据库统一增量-MySQL8.sql](头程数据库统一增量-MySQL8.sql) | `baiyue_iam` | 海外费用管理菜单及默认平台管理员授权；保留既有财务编辑、审核按钮和授权 |
-| [海外区域统一增量-MySQL8.sql](海外区域统一增量-MySQL8.sql) | `baiyue_lastleg` | 资金与仓租四表、费用关联及换标快照、审核人名称、采购退款请求幂等字段与唯一索引 |
-
-两份文件虽然名称包含“增量”，仍只用于对应区域的空库初始化。新增列、索引和约束直接维护在最终 `CREATE TABLE` 中，菜单及授权使用初始化种子；不追加存量改造、权限版本回填或动态迁移段。目标 schema 必须为空，按文件原有初始化流程执行；不能向已有业务库重放。
-
-本次不再提供这项功能的独立升级脚本。已有库升级必须按实际结构和明确授权另行准备、审阅受控增量，不能把删除重复文件理解为已有库已完成升级。
-
-## 海外表和字段
-
-| 类型 | 表 / 字段 | 用途 |
-|---|---|---|
-| 新表 | `ll_finance_fee_funding` | 人工费用冻结、审核扣款、释放及财务流水引用 |
-| 新表 | `ll_storage_rent_lot` | 实际入库计租原批次、数量及入库时间 |
-| 新表 | `ll_storage_rent_inbound` | 头程每次实收凭证去重，关联同单同仓计租批次 |
-| 新表 | `ll_storage_rent_share` | 库存与原计租批次份额关联，保留原库龄 |
-| 新表 | `ll_storage_rent_preparation` | 出库计租快照、汇率、资金预占及实际出库记录 |
-| 可空字段 | `ll_destuff_pallet_cost_allocation.fee_source_id` | `BIGINT NULL`，允许人工审核后关联海外费用来源 |
-| 字段 | `ll_return_sku_conversion.storage_rent_shares_json` | `LONGTEXT NULL`，退货 SKU 换标的原仓租份额快照 |
-| 字段 | `ll_finance_fee_source.reviewer_name` | `VARCHAR(255) NULL`，审核人名称快照 |
-| 字段 | `ll_overseas_procurement_fee.idempotency_key` | `VARCHAR(128) NULL`，采购退款请求幂等键 |
-| 唯一索引 | `uk_ll_procurement_refund_request(order_id,purpose,idempotency_key)` | 同一采购订单、用途和退款请求去重 |
-
-## 国内菜单和权限
-
-海外业务 → 海外费用管理，菜单 ID `5117200`、权限 `platform:overseas-fee:list`、路由 `/overseas-business/fees`；默认仅授予 `PLATFORM_ADMIN`。编辑和审核分别复用 `platform:finance:fee-source:edit` 与 `platform:finance:fee-source:review`，列表权限不包含写操作。国内基线已包含两项既有按钮及管理员授权。
-
-已有库的 [费用写权限修复](overseas-fee-canonical-write-permissions-repair.sql) 是单独的定向补丁，继续保留原适用条件和授权边界，不是结构升级或菜单初始化入口。其他独立修复脚本与历史迁移不在本次清理范围。
-
-费用项目继续使用 Firstleg 现有目录及 `FEE_TYPE_077 / 仓储费`，不重复插入项目、不批量覆盖客户专价、不回填历史仓租或费用、不修改钱包余额。
-
-配套服务、页面、配置及验收边界见 [首版发布验收](../../lastleg-service/docs/overseas-fees-storage-rent-release.md)。

deploy/sql/README.md

@@ -1,19 +1,5 @@
 # 单测试环境数据库空库初始化
 
-放舱后预计到港窄维护需要配套更新 `trg_ocean_booking_before_update`：仅从冻结比较中移除 `estimated_arrival_at`，其余运输、预报、关系方及柜型冻结不变。定义已同步 `firstleg/src/main/resources/db/phase3-ocean-booking-schema.sql` 与国内统一基线；已有 TEST 需另行审阅并授权替换该触发器，不重放空库文件，不回填数据。本轮只准备定义，未执行 SQL 或部署。
-
-货柜关联已放舱订舱时不再限制 ISO 柜号格式，Firstleg 模块基线与国内统一空库基线已移除 `chk_container_booking_iso6346`，保留同订舱柜号唯一键。既有 TEST 发布前需核对并单独授权移除该约束：`ALTER TABLE baiyue_firstleg.fl_container_booking DROP CHECK chk_container_booking_iso6346;`。配套发布 Firstleg 与 Admin；不重放空库初始化、不修改业务数据。本次仅准备源码与 SQL 定义，未执行环境 SQL 或部署。
-
-`overseas-storage-rent-zero-fee-repair.sql` 为免费仓租的定向结构修复，固定 `baiyue_lastleg.ll_finance_fee_source`：先检查列类型、既有金额约束及存量行，再以单次原子 ALTER 仅放行自动应收仓租的原币及结算双零金额和空汇率，其余费用仍须正额及有效汇率。不更新费用、余额或库存；禁止重放空库初始化。源码基线与海外统一空库基线同步。脚本待审阅执行，文件存在不代表已执行。
-
-`overseas-fee-remark-add.sql` 为海外人工费用说明的独立结构增量，固定目标 `baiyue_lastleg.ll_finance_fee_source`，仅在缺失时增加允许为空的 `fee_remark VARCHAR(500)`，保留旧费用与审核记录，不回填、不扣款、不改菜单。Lastleg 源基线与海外统一空库基线已同步；已有开发库须逐项授权执行本脚本后才能加载配套 Lastleg 版本。文件准备不表示已执行。
-
-`finance-overseas-fee-hash-width-repair.sql` 用于明确授权的本机开发环境海外费用推送修复，固定目标 `baiyue_finance`。先核对 `fin_inbox_event.payload_hash`、`fin_fee_source.source_hash` 两列；仅将不足71位的长度扩至71位，兼容 `sha256:` 前缀，保留空值约束和字符集排序规则，不更新业务数据。缺列、异常类型或小于64位时停止；已有足够长度则跳过。使用独立连接、遇错停止，执行后回查结构，再通过原费用事件重试验证，禁止重新生成费用或扣款。脚本包含执行后移除的专用校验过程；创建或执行失败须停止，不扩大修复范围。文件准备不表示已执行。
-
-`warehouse-supplier-query-structure-repair.sql` 用于明确授权的本机开发环境供应商查询结构修复，固定目标 `baiyue_warehouse`：仅在缺失时新增 `wh_supplier.trucking_scope`，并按当前模块基线创建缺失的 `wh_supplier_carrier` 空表。结构存在则跳过，不更新供应商类别、费用或资金，不推断历史拖车的国内/海外归属。使用独立连接、遇错停止，执行后回查结构并通过正式供应商列表 API 验证；不需要重启服务。文件准备不表示已获授权或已执行。
-
-仓储转运到仓取货、本土卡车接入现有排车的**可重复执行汇总SQL**为 `lastleg-dispatch-transport-tasks.sql`，文件内固定 `USE baiyue_lastleg`，对已存在字段、表安全跳过。新增 `ll_dispatch_order.task_type` 字段、`ll_dispatch_truck_task`、`ll_dispatch_transport_create`、`ll_dispatch_transport_command` 三张表，并确保既有正式排车单号日流水表存在；不回填或删除业务数据。前置是目标库已具备现有整车排车主表、FleetTrip、取货任务及本土卡车原单结构。按序先执行此 SQL，再配套发布 Lastleg 与 Admin；取消释放有效原单关联、完成保留关联。`migrations/overseas/baiyue_lastleg/V32__dispatch_transport_tasks.sql` 是迁移系统中的新增结构记录。本次仅在已授权本机执行并验收，不代表远端已部署。
-
 排车单号使用`PCyyyyMMdd0001`，日期取`Asia/Shanghai`，全平台跨客户/仓库共用独立日流水。`ll_dispatch_daily_sequence`同步Lastleg源基线与海外空库基线；已有结构的定向新增入口为`lastleg-dispatch-daily-sequence.sql`，只建序列表，不改已有业务号、不回填历史、不重放空库初始化。源码和DDL须配套发布；文件存在不表示已执行或部署。流水在独立短事务分配，回滚或取消不复用，四位范围每日0001至9999，准确单量以主单统计为准。
 
 自有业务运营视图的结构在 Lastleg 源基线及海外统一空库基线新增四张附加表：`ll_fleet_owned_business_ownership/record/command/history`，分别保存原排车装车完成时的车辆归属证据、运营信息、命令与不可变历史；不新增排车主单或第二套运输状态。权限为 IAM `lastleg-permissions.sql` 中的自有业务 list/edit/upload，并同步国内统一空库基线。业务唯一规则见工作区 `docs/海外仓业务/自有业务首版开发契约.md`。本次仅准备源码基线，无 SQL 执行、存量回填或部署；旧已装车 TEST 数据不倒推历史归属，匹配版本按新原生样本验收。
@@ -64,10 +50,6 @@
 
 换标直接出库的实物体积快照在 `ll_outbound_order.volume_cbm`、`ll_outbound_pallet_item.volume_cbm`、`ll_delivery_order.total_volume_cbm` 三列均允许 NULL，表示来源尚未确认；已有实盘尺寸按箱计算，不能用默认 0 代替未知，也不按 SKU 件数重复累计。两份初始化基线同步此定义，已有 TEST 只能在核对结构和授权后精确调整这三列，不重放空库文件或回填历史行。
 
-排车内部散板需求发布选项由 `lastleg-service/src/main/resources/db/dispatch-capacity-demand.sql` 提供精确结构变更：仅向 `ll_dispatch_order` 新增默认勾选的 `publish_looseboard_demand` 列，Lastleg与海外空库基线同步。该文件不是自动启动脚本；执行须单独授权，不能重放完整空库文件，不新增业务数据回填或清理。实际执行与部署状态仍归测试环境主契约。
-
-订舱委/实资料在 `firstleg/src/main/resources/db/phase3-ocean-booking-schema.sql` 与国内统一空库基线同步维护：订舱主表增加条款、包装、品名、唛头和委/实三项货量，关系方增加邮箱、税号；已放舱主表触发器仅允许实际货量及更新审计元数据变化，运输、预报和创建信息冻结。匹配发布单元为 Firstleg 与 Admin；Print 继续使用现有模板。本轮只准备初始化定义，不执行 SQL、不回填测试存量、不提供新旧兼容。已有测试库须另行审阅、授权结构更新，不能重放完整空库基线。
-
 ## 唯一入口与区域边界
 
 V13 收货覆盖由 `lastleg-service/src/main/resources/db/appointment-receiving.sql` 提供四表：独立收货预约、当前/历史客户成员、待确认变化和不可变覆盖版本；同步 Lastleg 与海外空库基线。有效外部约号唯一性归收货预约的目的仓与约号，批次头表不再独立占用约号。部署前必须核对四表及旧头表唯一索引；本批只准备基线，不提供测试存量回填或自动重置。旧 `reset-test-fba-appointments.sql` 已拒绝存在这些新表的环境，不能用于重放 V13 初始化。实际 SQL 与部署须逐项授权。
@@ -77,7 +59,7 @@ V13 收货覆盖由 `lastleg-service/src/main/resources/db/appointment-receiving
 | 区域 | 完整入口 | 服务 schema | 表数 |
 |---|---|---|---:|
 | 国内 | `头程数据库统一增量-MySQL8.sql` | `baiyue_auth`、`baiyue_iam`、`baiyue_order`、`baiyue_warehouse`、`baiyue_firstleg`、`baiyue_file`、`baiyue_audit`、`baiyue_finance` | 229 |
-| 海外 | `海外区域统一增量-MySQL8.sql` | `baiyue_lastleg`、`baiyue_lastlag_warehouse` | 238 |
+| 海外 | `海外区域统一增量-MySQL8.sql` | `baiyue_lastleg`、`baiyue_lastlag_warehouse` | 234 |
 
 
 - 所有服务位于同一测试环境；两份文件只分组组织服务 schema，不代表两个部署区域。`baiyue_lastlag_warehouse` 保留当前正式的 `lastlag` 拼写。
@@ -100,7 +82,7 @@ V13 收货覆盖由 `lastleg-service/src/main/resources/db/appointment-receiving
 5. DDL 隐式提交，不可整体回滚。失败后停止并保留错误；经另行授权准备空库后从头执行，不针对半初始化库追加迁移或从失败行续跑。
 6. Firstleg 测量项与拆分项互为外键：建空表期间暂设会话 `foreign_key_checks=0`，随后立即恢复 `1`，再插入种子。失败时关闭连接。两边外键完整保留在 CREATE TABLE 内。
 
-成功时只在最末输出一行 `initialization_status=PASS`，并带 `region=CN/OVERSEAS`、`initialized_tables=229/238`。必须同时确认客户端退出码 0；忽略错误后出现的 PASS 不算成功。
+成功时只在最末输出一行 `initialization_status=PASS`，并带 `region=CN/OVERSEAS`、`initialized_tables=229/234`。必须同时确认客户端退出码 0；忽略错误后出现的 PASS 不算成功。
 
 ## 平台管理员密码
 
@@ -200,9 +182,3 @@ node --test scripts/admin-test-env-modules/initialization-baseline-contract.test
 ## 统一业务单号
 
 编号规则见 `../../../docs/业务单据编号契约.md`。Order、Warehouse、Lastleg 空库基线新增各自的 `ord_document_sequence`、`wh_document_sequence`、`ll_document_sequence`；Firstleg 与 Finance 复用本库编号表。Lastleg 空库基线移除无生产调用的客户日序列、逻辑秒时钟及旧尾程日序列表，保留排车日序列。采购费用新增可空 `idempotency_key` 及订单/用途/请求键唯一约束，用于退款重放，业务号统一使用 PF。此处只准备基线，不执行 SQL、回填或删除测试存量。
-
-海外费用与仓租首版统一维护在 `头程数据库统一增量-MySQL8.sql` 的 IAM 菜单/管理员授权种子及 `海外区域统一增量-MySQL8.sql` 的最终建表定义中。海外基线包含资金与仓租四表、拆柜成本可空费用引用、退货 SKU 换标仓租快照、审核人名称，以及采购退款请求幂等字段和唯一索引；同步模块源基线、国内权限种子及海外空库 238 表，复用现有 `FEE_TYPE_077 / 仓储费`，不新增费用项目种子。发布须同时更新 Firstleg、Lastleg、Admin 与海外 PDA；规则、配置及资金验收见 [首版发布验收](../../lastleg-service/docs/overseas-fees-storage-rent-release.md)。仅整理文件，未执行 SQL 或部署。
-
-本次重复的五份版本脚本和两份专项汇总 SQL 已移除，内容清单见 [20261022-海外费用仓租数据库变更汇总](20261022-海外费用仓租数据库变更汇总.md)。两份统一文件仍只用于空库初始化，不能向已有业务库重放；本次不再提供这项功能的独立升级脚本，已有库升级须另按实际结构和明确授权准备、审阅增量。其他独立修复补丁及历史迁移保持各自适用边界。
-
-采购方向扩展：`migrations/overseas/baiyue_lastleg/V34__procurement_direction.sql` 先于匹配 Lastleg 版本执行，为采购单增加 `procurement_direction`；历史订单默认海外采购回国内，不修改既有实物和资金记录。国内采购通过既有国内仓目录选起运收货仓；源基线与统一空库基线同步。本地验证不表示测试库已执行或服务已发布。

deploy/sql/finance-overseas-fee-hash-width-repair.sql

@@ -1,75 +0,0 @@
--- 本机开发环境海外费用推送结构修复。固定目标：baiyue_finance。
--- 仅将两个既有摘要字段不足 71 位的长度扩至 71；不改数据、费用、账单或余额。
--- 保留原字段的空值约束、字符集及排序规则；缺表、缺列或异常字段类型时拒绝执行。
--- 执行须单独授权。使用独立连接、遇错停止；不得以本文件代替完整数据库初始化。
-USE baiyue_finance;
-
--- 执行前只读核对；sha256: 前缀 7 位加摘要 64 位，共 71 位。
-SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, COLUMN_TYPE, IS_NULLABLE,
-       CHARACTER_SET_NAME, COLLATION_NAME
-FROM information_schema.COLUMNS
-WHERE TABLE_SCHEMA = 'baiyue_finance'
-  AND ((TABLE_NAME = 'fin_inbox_event' AND COLUMN_NAME = 'payload_hash')
-    OR (TABLE_NAME = 'fin_fee_source' AND COLUMN_NAME = 'source_hash'));
-
-DELIMITER $$
-CREATE PROCEDURE finance_fee_hash_width_repair_20261023()
-BEGIN
-    DECLARE checked_columns INT DEFAULT 0;
-    DECLARE column_index INT DEFAULT 0;
-    DECLARE target_table VARCHAR(64);
-    DECLARE target_column VARCHAR(64);
-    DECLARE current_length BIGINT;
-    DECLARE nullable_value VARCHAR(3);
-    DECLARE charset_value VARCHAR(64);
-    DECLARE collation_value VARCHAR(64);
-    DECLARE comment_value TEXT;
-
-    IF DATABASE() <> 'baiyue_finance' THEN
-        SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = '目标必须是 baiyue_finance';
-    END IF;
-    SELECT COUNT(*) INTO checked_columns
-    FROM information_schema.COLUMNS
-    WHERE TABLE_SCHEMA = 'baiyue_finance' AND DATA_TYPE IN ('char', 'varchar')
-      AND CHARACTER_MAXIMUM_LENGTH >= 64
-      AND COLUMN_DEFAULT IS NULL AND EXTRA = ''
-      AND ((TABLE_NAME = 'fin_inbox_event' AND COLUMN_NAME = 'payload_hash')
-        OR (TABLE_NAME = 'fin_fee_source' AND COLUMN_NAME = 'source_hash'));
-    IF checked_columns <> 2 THEN
-        SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = '摘要字段缺失或类型异常，停止修复';
-    END IF;
-
-    WHILE column_index < 2 DO
-        SET target_table = IF(column_index = 0, 'fin_inbox_event', 'fin_fee_source');
-        SET target_column = IF(column_index = 0, 'payload_hash', 'source_hash');
-        SELECT CHARACTER_MAXIMUM_LENGTH, IS_NULLABLE, CHARACTER_SET_NAME, COLLATION_NAME, COLUMN_COMMENT
-          INTO current_length, nullable_value, charset_value, collation_value, comment_value
-        FROM information_schema.COLUMNS
-        WHERE TABLE_SCHEMA = 'baiyue_finance' AND TABLE_NAME = target_table
-          AND COLUMN_NAME = target_column;
-        IF current_length < 71 THEN
-            SET @finance_fee_hash_width_ddl = CONCAT(
-                'ALTER TABLE baiyue_finance.`', target_table, '` MODIFY COLUMN `', target_column,
-                '` VARCHAR(71) CHARACTER SET ', charset_value, ' COLLATE ', collation_value,
-                IF(nullable_value = 'YES', ' NULL', ' NOT NULL'),
-                ' COMMENT ', QUOTE(comment_value));
-            PREPARE finance_fee_hash_width_stmt FROM @finance_fee_hash_width_ddl;
-            EXECUTE finance_fee_hash_width_stmt;
-            DEALLOCATE PREPARE finance_fee_hash_width_stmt;
-        END IF;
-        SET column_index = column_index + 1;
-    END WHILE;
-END$$
-DELIMITER ;
-
-CALL finance_fee_hash_width_repair_20261023();
-DROP PROCEDURE finance_fee_hash_width_repair_20261023;
-SET @finance_fee_hash_width_ddl = NULL;
-
--- 执行后两列长度均应至少为 71；结构已正确时不执行 ALTER。
-SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, COLUMN_TYPE, IS_NULLABLE,
-       CHARACTER_MAXIMUM_LENGTH >= 71 AS width_ok
-FROM information_schema.COLUMNS
-WHERE TABLE_SCHEMA = 'baiyue_finance'
-  AND ((TABLE_NAME = 'fin_inbox_event' AND COLUMN_NAME = 'payload_hash')
-    OR (TABLE_NAME = 'fin_fee_source' AND COLUMN_NAME = 'source_hash'));

deploy/sql/lastleg-dispatch-transport-tasks.sql

@@ -1,108 +0,0 @@
--- MySQL 8 可重复执行增量：仓储转运到仓取货与本土卡车接入现有排车。
--- 目标数据库固定为 baiyue_lastleg；仅新增运输类型、原单关联及请求账本，不回填或删除业务数据。
--- 前置：已完成 Lastleg 现有整车排车结构升级；如部署为缺少每日流水表的旧库，也创建正式排车流水表。
-USE baiyue_lastleg;
-
-SET @dispatch_transport_column_ddl = IF(
-  EXISTS (
-    SELECT 1 FROM information_schema.columns
-    WHERE table_schema = DATABASE() AND table_name = 'll_dispatch_order' AND column_name = 'task_type'
-  ),
-  'SELECT 1',
-  'ALTER TABLE ll_dispatch_order ADD COLUMN task_type VARCHAR(32) NOT NULL DEFAULT ''DELIVERY'' COMMENT ''任务类型：仓库派送、到仓取货、本土卡车'' AFTER dispatch_no'
-);
-PREPARE dispatch_transport_column_stmt FROM @dispatch_transport_column_ddl;
-EXECUTE dispatch_transport_column_stmt;
-DEALLOCATE PREPARE dispatch_transport_column_stmt;
-
--- 旧库兼容：整车主单跨客户，原来单客户排车头字段不再要求填写。
--- 如目标库已删除旧字段则跳过；已有客户值保留，不置空、不修改。
-SET @dispatch_transport_legacy_ddl = IF(
-  EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'll_dispatch_order' AND column_name = 'customer_id' AND is_nullable = 'NO'),
-  'ALTER TABLE ll_dispatch_order MODIFY COLUMN customer_id VARCHAR(128) NULL COMMENT ''旧客户排车归属，整车主单不使用''',
-  'SELECT 1'
-);
-PREPARE dispatch_transport_legacy_stmt FROM @dispatch_transport_legacy_ddl;
-EXECUTE dispatch_transport_legacy_stmt;
-DEALLOCATE PREPARE dispatch_transport_legacy_stmt;
-
--- 旧本土卡车结构兼容：新单沿用已有的起终点联系人及pickup_at/delivery_at字段。
--- 旧单字段保留原值，仅放宽空值约束，避免新单被已弃用字段阻断。
-SET @dispatch_transport_legacy_ddl = IF(
-  EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'll_us_truck_order' AND column_name = 'contact_name' AND is_nullable = 'NO'),
-  'ALTER TABLE ll_us_truck_order MODIFY COLUMN contact_name VARCHAR(128) NULL COMMENT ''旧本土卡车联系人，新单使用起终点联系人''',
-  'SELECT 1'
-);
-PREPARE dispatch_transport_legacy_stmt FROM @dispatch_transport_legacy_ddl;
-EXECUTE dispatch_transport_legacy_stmt;
-DEALLOCATE PREPARE dispatch_transport_legacy_stmt;
-
-SET @dispatch_transport_legacy_ddl = IF(
-  EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'll_us_truck_order' AND column_name = 'contact_info' AND is_nullable = 'NO'),
-  'ALTER TABLE ll_us_truck_order MODIFY COLUMN contact_info VARCHAR(128) NULL COMMENT ''旧本土卡车联系方式，新单使用起终点联系方式''',
-  'SELECT 1'
-);
-PREPARE dispatch_transport_legacy_stmt FROM @dispatch_transport_legacy_ddl;
-EXECUTE dispatch_transport_legacy_stmt;
-DEALLOCATE PREPARE dispatch_transport_legacy_stmt;
-
-SET @dispatch_transport_legacy_ddl = IF(
-  EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'll_us_truck_order' AND column_name = 'requested_date' AND is_nullable = 'NO'),
-  'ALTER TABLE ll_us_truck_order MODIFY COLUMN requested_date DATE NULL COMMENT ''旧本土卡车请求日期，新单使用取货和送货时间''',
-  'SELECT 1'
-);
-PREPARE dispatch_transport_legacy_stmt FROM @dispatch_transport_legacy_ddl;
-EXECUTE dispatch_transport_legacy_stmt;
-DEALLOCATE PREPARE dispatch_transport_legacy_stmt;
-
-CREATE TABLE IF NOT EXISTS ll_dispatch_daily_sequence (
-  business_date DATE NOT NULL COMMENT '排车编号业务日期（Asia/Shanghai）',
-  last_sequence INT NOT NULL COMMENT '当日已分配排车流水号，范围0001至9999',
-  PRIMARY KEY (business_date)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车单号每日独立原子流水';
-
-CREATE TABLE IF NOT EXISTS ll_dispatch_truck_task (
-  dispatch_no VARCHAR(64) NOT NULL COMMENT '排车业务号',
-  trip_no VARCHAR(64) NOT NULL COMMENT '本次运输资源记录号',
-  customer_id VARCHAR(128) NOT NULL COMMENT '本土卡车原单客户标识',
-  order_no VARCHAR(64) NOT NULL COMMENT '本土卡车原单业务号',
-  active_order VARCHAR(193) NULL COMMENT '有效原单唯一键；取消置空，完成保留',
-  PRIMARY KEY (dispatch_no),
-  UNIQUE KEY uk_transport_trip (trip_no),
-  UNIQUE KEY uk_transport_source (active_order),
-  KEY idx_transport_order (customer_id, order_no)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车与本土卡车原单关联';
-
-CREATE TABLE IF NOT EXISTS ll_dispatch_transport_create (
-  trip_no VARCHAR(64) NOT NULL COMMENT '本次运输资源记录号',
-  request_hash CHAR(64) NOT NULL COMMENT '首次安排请求摘要',
-  PRIMARY KEY (trip_no)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='本土卡车排车创建请求账本';
-
-CREATE TABLE IF NOT EXISTS ll_dispatch_transport_command (
-  dispatch_no VARCHAR(64) NOT NULL COMMENT '排车业务号',
-  request_key VARCHAR(128) NOT NULL COMMENT '客户端幂等请求键',
-  request_hash CHAR(64) NOT NULL COMMENT '执行命令请求摘要',
-  evidence_json JSON NULL COMMENT '已确认运输完成凭证标识列表',
-  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '业务命令提交时间',
-  PRIMARY KEY (dispatch_no, request_key)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车运输执行命令与凭证账本';
-
--- 当前承运占用查询还依赖散板来源标识（与V33一致）；仅补结构，不创建散板业务记录。
-SET @dispatch_transport_pool_ddl = IF(
-  EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'll_fleet_external_booking' AND column_name = 'source_looseboard_order_id'),
-  'SELECT 1',
-  'ALTER TABLE ll_fleet_external_booking ADD COLUMN source_looseboard_order_id BIGINT NULL COMMENT ''客户原始散板商业单ID，取消后保留来源'''
-);
-PREPARE dispatch_transport_pool_stmt FROM @dispatch_transport_pool_ddl;
-EXECUTE dispatch_transport_pool_stmt;
-DEALLOCATE PREPARE dispatch_transport_pool_stmt;
-
-SET @dispatch_transport_pool_ddl = IF(
-  EXISTS (SELECT 1 FROM information_schema.statistics WHERE table_schema = DATABASE() AND table_name = 'll_fleet_external_booking' AND index_name = 'idx_booking_looseboard_source'),
-  'SELECT 1',
-  'ALTER TABLE ll_fleet_external_booking ADD KEY idx_booking_looseboard_source (customer_id, source_looseboard_order_id, status)'
-);
-PREPARE dispatch_transport_pool_stmt FROM @dispatch_transport_pool_ddl;
-EXECUTE dispatch_transport_pool_stmt;
-DEALLOCATE PREPARE dispatch_transport_pool_stmt;

deploy/sql/migrations/overseas/baiyue_lastleg/V32__dispatch_transport_tasks.sql

@@ -1,23 +0,0 @@
--- 仓储取货与本土卡车接入现有排车；保留旧排车用途默认值。
-ALTER TABLE ll_dispatch_order ADD COLUMN task_type VARCHAR(32) NOT NULL DEFAULT 'DELIVERY' COMMENT '任务类型：仓库派送、到仓取货、本土卡车' AFTER dispatch_no;
-CREATE TABLE ll_dispatch_truck_task (
-  dispatch_no VARCHAR(64) NOT NULL COMMENT '排车业务号',
-  trip_no VARCHAR(64) NOT NULL COMMENT '本次运输资源记录号',
-  customer_id VARCHAR(128) NOT NULL COMMENT '本土卡车原单客户标识',
-  order_no VARCHAR(64) NOT NULL COMMENT '本土卡车原单业务号',
-  active_order VARCHAR(193) NULL COMMENT '有效原单唯一键；取消置空，完成保留',
-  PRIMARY KEY(dispatch_no), UNIQUE KEY uk_transport_trip(trip_no), UNIQUE KEY uk_transport_source(active_order),
-  KEY idx_transport_order(customer_id,order_no)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车与本土卡车原单关联';
-CREATE TABLE ll_dispatch_transport_create (
-  trip_no VARCHAR(64) NOT NULL PRIMARY KEY COMMENT '本次运输资源记录号',
-  request_hash CHAR(64) NOT NULL COMMENT '首次安排请求摘要'
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='本土卡车排车创建请求账本';
-CREATE TABLE ll_dispatch_transport_command (
-  dispatch_no VARCHAR(64) NOT NULL COMMENT '排车业务号',
-  request_key VARCHAR(128) NOT NULL COMMENT '客户端幂等请求键',
-  request_hash CHAR(64) NOT NULL COMMENT '执行命令请求摘要',
-  evidence_json JSON NULL COMMENT '已确认运输完成凭证标识列表',
-  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '业务命令提交时间',
-  PRIMARY KEY(dispatch_no,request_key)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车运输执行命令与凭证账本';

deploy/sql/migrations/overseas/baiyue_lastleg/V33__looseboard_pool_demand.sql

@@ -1,13 +0,0 @@
--- Region: OVERSEAS
--- Schema: baiyue_lastleg
--- Purpose: 客户散板原单接入拼车需求池，未确认登记不占位。
--- Preconditions: MySQL 8；已选择 baiyue_lastleg；预订表已存在。
--- Postconditions: 预订原单来源列及客户来源索引存在，不回填历史来源。
-SET @looseboard_demand_ddl = IF(EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE() AND table_name='ll_fleet_external_booking' AND column_name='source_looseboard_order_id'), 'SELECT 1', 'ALTER TABLE ll_fleet_external_booking ADD COLUMN source_looseboard_order_id BIGINT NULL COMMENT ''客户原始散板商业单ID，取消后保留来源''');
-PREPARE looseboard_demand_stmt FROM @looseboard_demand_ddl;
-EXECUTE looseboard_demand_stmt;
-DEALLOCATE PREPARE looseboard_demand_stmt;
-SET @looseboard_demand_ddl = IF(EXISTS (SELECT 1 FROM information_schema.statistics WHERE table_schema=DATABASE() AND table_name='ll_fleet_external_booking' AND index_name='idx_booking_looseboard_source'), 'SELECT 1', 'ALTER TABLE ll_fleet_external_booking ADD KEY idx_booking_looseboard_source (customer_id,source_looseboard_order_id,status)');
-PREPARE looseboard_demand_stmt FROM @looseboard_demand_ddl;
-EXECUTE looseboard_demand_stmt;
-DEALLOCATE PREPARE looseboard_demand_stmt;

deploy/sql/migrations/overseas/baiyue_lastleg/V34__procurement_direction.sql

@@ -1,9 +0,0 @@
--- 先于新版本 Lastleg 上线执行。历史订单保持海外采购回国内，不改数量、资金或交寄事实。
-SET @procurement_direction_ddl = IF(
-  (SELECT COUNT(*) FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = DATABASE()
-    AND TABLE_NAME = 'll_overseas_procurement_order' AND COLUMN_NAME = 'procurement_direction') = 0,
-  'ALTER TABLE ll_overseas_procurement_order ADD COLUMN procurement_direction VARCHAR(32) NOT NULL DEFAULT ''OVERSEAS_TO_DOMESTIC'' COMMENT ''采购方向：海外采购回国内/国内采购发海外''',
-  'SELECT 1');
-PREPARE procurement_direction_stmt FROM @procurement_direction_ddl;
-EXECUTE procurement_direction_stmt;
-DEALLOCATE PREPARE procurement_direction_stmt;

deploy/sql/overseas-fee-canonical-write-permissions-repair.sql

@@ -1,121 +0,0 @@
--- 海外费用既有写按钮最小修复；MySQL 8，目标只能是 baiyue_iam。
--- 仅恢复基线 5105024/5105025 及既有 4000001 PLATFORM_ADMIN 缺失授权。
--- 不创建角色/成员，不授予其他角色，不新增 overseas-fee:edit/review 别名。
--- 在支持 DELIMITER、遇错停止的客户端同连接整份执行；执行期间暂停相关角色权限维护。
--- 不在其他未提交事务中调用。所有业务DML及subject版本变更同事务，任何异常回滚。
-USE baiyue_iam;
-SET NAMES utf8mb4;
-SELECT DATABASE() AS target_database;
-
-DROP PROCEDURE IF EXISTS repair_overseas_fee_canonical_write;
-DELIMITER $$
-CREATE PROCEDURE repair_overseas_fee_canonical_write()
-BEGIN
-  DECLARE locked_role BIGINT;
-  DECLARE changed_rows BIGINT DEFAULT 0;
-  DECLARE EXIT HANDLER FOR SQLEXCEPTION
-  BEGIN
-    ROLLBACK;
-    RESIGNAL;
-  END;
-
-  START TRANSACTION;
-  IF DATABASE()<>'baiyue_iam' THEN
-    SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='Wrong schema: expected baiyue_iam';
-  END IF;
-  IF (SELECT COUNT(*) FROM iam_role WHERE id=4000001 AND tenant_id=0 AND app_code='PLATFORM'
-      AND role_code='PLATFORM_ADMIN' AND role_type='SYSTEM' AND status='ACTIVE' AND deleted=0)<>1
-      OR EXISTS(SELECT 1 FROM iam_role WHERE role_code='PLATFORM_ADMIN' AND id<>4000001) THEN
-    SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='Existing PLATFORM_ADMIN identity/status mismatch; no role will be created';
-  END IF;
-  SELECT id INTO locked_role FROM iam_role WHERE id=4000001 FOR UPDATE;
-
-  -- 新建缺失按钮使用当前客户应收父菜单；只接受已核对的既有财务菜单，不修复其他菜单。
-  IF (SELECT COUNT(*) FROM iam_permission WHERE id=5105041 AND tenant_id=0 AND app_code='PLATFORM'
-      AND permission_type='MENU' AND permission_code='platform:finance:customer-arap:list'
-      AND status='ACTIVE' AND deleted=0)<>1
-      OR EXISTS(SELECT 1 FROM iam_permission WHERE permission_code='platform:finance:customer-arap:list' AND id<>5105041) THEN
-    SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='Existing customer AR/AP parent menu is missing or mismatched';
-  END IF;
-  IF EXISTS(SELECT 1 FROM iam_permission WHERE
-      (id=5105024 AND NOT(permission_code<=>'platform:finance:fee-source:review'))
-      OR (id=5105025 AND NOT(permission_code<=>'platform:finance:fee-source:edit'))
-      OR (permission_code='platform:finance:fee-source:review' AND id<>5105024)
-      OR (permission_code='platform:finance:fee-source:edit' AND id<>5105025)
-      OR (id IN(5105024,5105025) AND (tenant_id<>0 OR app_code<>'PLATFORM'
-          OR permission_type<>'BUTTON' OR built_in<>1 OR parent_id NOT IN(5105000,5105041)
-          OR route_path IS NOT NULL
-          OR NOT(http_method<=>IF(id=5105024,'POST','PUT'))))) THEN
-    SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='Canonical fee button identity/type/metadata conflict';
-  END IF;
-  IF EXISTS(SELECT 1 FROM iam_permission child LEFT JOIN iam_permission parent ON parent.id=child.parent_id
-      WHERE child.id IN(5105024,5105025) AND (parent.id IS NULL OR parent.tenant_id<>0
-      OR parent.app_code<>'PLATFORM' OR parent.permission_type<>'MENU' OR parent.status<>'ACTIVE' OR parent.deleted<>0
-      OR NOT(parent.permission_code<=>IF(child.parent_id=5105000,'platform:finance','platform:finance:customer-arap:list')))) THEN
-    SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='Existing fee button parent is invalid';
-  END IF;
-  IF EXISTS(SELECT 1 FROM iam_role_permission WHERE permission_id IN(5105024,5105025) AND tenant_id<>0)
-      OR EXISTS(SELECT 1 FROM iam_membership_role mr LEFT JOIN iam_membership m ON m.id=mr.membership_id
-          WHERE mr.role_id=4000001 AND (mr.tenant_id<>0 OR m.id IS NULL OR m.tenant_id<>0)) THEN
-    SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='Existing canonical permission or administrator membership scope mismatch';
-  END IF;
-  -- 恢复停用/缺失资源也会恢复其他角色的旧授权；这种情况必须单独核对，不能随本补丁扩权。
-  IF EXISTS(SELECT 1 FROM iam_role_permission rp LEFT JOIN iam_permission p ON p.id=rp.permission_id
-      WHERE rp.permission_id IN(5105024,5105025) AND rp.role_id<>4000001
-      AND (p.id IS NULL OR p.status<>'ACTIVE' OR p.deleted<>0)) THEN
-    SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='Restoring fee button would affect another role; review separately';
-  END IF;
-
-  INSERT INTO iam_permission
-    (id,tenant_id,app_code,permission_type,parent_id,permission_code,permission_name,route_path,http_method,sort_no,status,built_in,deleted)
-  SELECT 5105024,0,'PLATFORM','BUTTON',5105041,'platform:finance:fee-source:review','审核财务费用来源',NULL,'POST',150,'ACTIVE',1,0
-  WHERE NOT EXISTS(SELECT 1 FROM iam_permission WHERE id=5105024);
-  SET changed_rows=changed_rows+ROW_COUNT();
-  INSERT INTO iam_permission
-    (id,tenant_id,app_code,permission_type,parent_id,permission_code,permission_name,route_path,http_method,sort_no,status,built_in,deleted)
-  SELECT 5105025,0,'PLATFORM','BUTTON',5105041,'platform:finance:fee-source:edit','编辑财务费用来源',NULL,'PUT',160,'ACTIVE',1,0
-  WHERE NOT EXISTS(SELECT 1 FROM iam_permission WHERE id=5105025);
-  SET changed_rows=changed_rows+ROW_COUNT();
-  UPDATE iam_permission SET status='ACTIVE',deleted=0
-  WHERE id IN(5105024,5105025) AND (status<>'ACTIVE' OR deleted<>0);
-  SET changed_rows=changed_rows+ROW_COUNT();
-  INSERT INTO iam_role_permission(tenant_id,role_id,permission_id,created_at)
-  SELECT 0,4000001,p.id,CURRENT_TIMESTAMP(3) FROM iam_permission p WHERE p.id IN(5105024,5105025)
-    AND NOT EXISTS(SELECT 1 FROM iam_role_permission rp WHERE rp.role_id=4000001 AND rp.permission_id=p.id);
-  SET changed_rows=changed_rows+ROW_COUNT();
-
-  -- 只有真实变更才推进版本；枚举所有既有管理员成员，不依赖当前登录用户，也不遗漏停用成员。
-  IF changed_rows>0 THEN
-    INSERT INTO iam_security_subject_version(auth_user_id,permission_version)
-    SELECT DISTINCT u.auth_user_id,1 FROM iam_user u
-    JOIN iam_membership m ON m.user_id=u.id AND m.tenant_id=0
-    JOIN iam_membership_role mr ON mr.membership_id=m.id AND mr.tenant_id=m.tenant_id AND mr.role_id=4000001
-    WHERE u.auth_user_id IS NOT NULL
-    ON DUPLICATE KEY UPDATE permission_version=permission_version+1;
-  END IF;
-  IF (SELECT COUNT(*) FROM iam_role_permission rp JOIN iam_permission p ON p.id=rp.permission_id
-      WHERE rp.role_id=4000001 AND rp.tenant_id=0 AND p.id IN(5105024,5105025)
-      AND p.tenant_id=0 AND p.app_code='PLATFORM' AND p.permission_type='BUTTON'
-      AND p.status='ACTIVE' AND p.deleted=0)<>2 THEN
-    SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='Canonical fee write grants incomplete; repair rolled back';
-  END IF;
-  COMMIT;
-  SELECT changed_rows AS repaired_catalog_or_grant_rows;
-END$$
-DELIMITER ;
-CALL repair_overseas_fee_canonical_write();
-DROP PROCEDURE repair_overseas_fee_canonical_write;
-
--- 核验1：必须恰好两行，角色4000001、tenant=0、BUTTON、ACTIVE、deleted=0。
-SELECT r.id AS role_id,r.role_code,rp.tenant_id,p.id AS permission_id,p.permission_code,
-       p.permission_type,p.status,p.deleted
-FROM iam_role r JOIN iam_role_permission rp ON rp.role_id=r.id
-JOIN iam_permission p ON p.id=rp.permission_id
-WHERE r.id=4000001 AND p.id IN(5105024,5105025) ORDER BY p.id;
--- 核验2：仅查看既有管理员主体与当前版本，不创建或切换任何成员角色。
-SELECT DISTINCT u.auth_user_id,m.id AS membership_id,u.status AS user_status,m.status AS membership_status,
-       COALESCE(sv.permission_version,0) AS permission_version
-FROM iam_user u JOIN iam_membership m ON m.user_id=u.id AND m.tenant_id=0
-JOIN iam_membership_role mr ON mr.membership_id=m.id AND mr.tenant_id=m.tenant_id AND mr.role_id=4000001
-LEFT JOIN iam_security_subject_version sv ON sv.auth_user_id=u.auth_user_id
-ORDER BY u.auth_user_id,m.id;

deploy/sql/overseas-fee-remark-add.sql

@@ -1,19 +0,0 @@
--- 海外人工费用说明字段。仅修改 baiyue_lastleg.ll_finance_fee_source 的结构。
--- 执行需单独授权；使用独立连接、遇错停止。先执行本脚本，再加载配套 Lastleg 代码。
--- 无业务数据回填、费用重建、资金操作或菜单变更。已有字段时跳过新增。
-USE baiyue_lastleg;
-
-SET @overseas_fee_remark_ddl = (
-  SELECT IF(EXISTS(
-    SELECT 1 FROM information_schema.columns
-    WHERE table_schema = DATABASE() AND table_name = 'll_finance_fee_source' AND column_name = 'fee_remark'
-  ), 'SELECT ''fee_remark already exists'' AS result',
-     'ALTER TABLE ll_finance_fee_source ADD COLUMN fee_remark VARCHAR(500) NULL COMMENT ''费用说明，补收或重复作业原因'' AFTER fee_item_name')
-);
-PREPARE overseas_fee_remark_stmt FROM @overseas_fee_remark_ddl;
-EXECUTE overseas_fee_remark_stmt;
-DEALLOCATE PREPARE overseas_fee_remark_stmt;
-
-SELECT table_schema, table_name, column_name, column_type, is_nullable, column_comment
-FROM information_schema.columns
-WHERE table_schema = 'baiyue_lastleg' AND table_name = 'll_finance_fee_source' AND column_name = 'fee_remark';

deploy/sql/overseas-storage-rent-zero-fee-repair.sql

@@ -1,73 +0,0 @@
--- 固定目标本机 baiyue_lastleg，只修复自动免费仓租结构，不更新业务数据。
--- 使用独立连接、遇错停止；先核对既有表结构，不能重放空库初始化。
-USE baiyue_lastleg;
-SELECT COLUMN_NAME,COLUMN_TYPE,IS_NULLABLE FROM information_schema.COLUMNS
-WHERE TABLE_SCHEMA=DATABASE() AND TABLE_NAME='ll_finance_fee_source'
-  AND COLUMN_NAME IN ('amount','original_amount','exchange_rate','created_by','fee_item_code','direction');
-
--- 上次 CALL 前置检查失败可能遗留本专用过程，仅清理本脚本自己的过程后重建。
-DROP PROCEDURE IF EXISTS storage_rent_zero_fee_repair_20261023;
-DELIMITER $$
-CREATE PROCEDURE storage_rent_zero_fee_repair_20261023()
-BEGIN
-    DECLARE checked_columns INT DEFAULT 0;
-    DECLARE checked_constraints INT DEFAULT 0;
-    DECLARE rate_type VARCHAR(64);
-    DECLARE rate_comment TEXT;
-    DECLARE rate_default TEXT;
-    DECLARE rate_default_sql TEXT;
-    IF DATABASE()<>'baiyue_lastleg' THEN
-        SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='目标必须为 baiyue_lastleg';
-    END IF;
-    SELECT COUNT(*) INTO checked_columns FROM information_schema.COLUMNS
-    WHERE TABLE_SCHEMA=DATABASE() AND TABLE_NAME='ll_finance_fee_source'
-      AND ((COLUMN_NAME IN ('amount','original_amount') AND DATA_TYPE='decimal' AND IS_NULLABLE='NO')
-        OR (COLUMN_NAME='exchange_rate' AND DATA_TYPE='decimal' AND EXTRA='')
-        OR (COLUMN_NAME IN ('created_by','fee_item_code','direction') AND DATA_TYPE='varchar' AND IS_NULLABLE='NO'));
-    SELECT COUNT(*) INTO checked_constraints FROM information_schema.TABLE_CONSTRAINTS
-    WHERE CONSTRAINT_SCHEMA=DATABASE() AND TABLE_NAME='ll_finance_fee_source'
-      AND CONSTRAINT_NAME='chk_ll_finance_fee_amount' AND CONSTRAINT_TYPE='CHECK';
-    IF checked_columns<>6 OR checked_constraints<>1 THEN
-        SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='费用源表字段或金额约束异常，停止修复';
-    END IF;
-    -- 增加新约束前只读检查；人工费用仍须正额且有效汇率，防止意外放宽。
-    IF EXISTS (SELECT 1 FROM ll_finance_fee_source
-        WHERE NOT ((amount>0 OR (amount=0 AND original_amount=0 AND created_by='STORAGE_RENT' AND fee_item_code='FEE_TYPE_077' AND direction='RECEIVABLE'))
-          AND ((exchange_rate IS NOT NULL AND exchange_rate>0) OR (exchange_rate IS NULL AND amount=0 AND original_amount=0 AND created_by='STORAGE_RENT' AND fee_item_code='FEE_TYPE_077' AND direction='RECEIVABLE')))) THEN
-        SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='存在不满足新约束的费用，停止且不改数据';
-    END IF;
-    SELECT COUNT(*) INTO checked_constraints FROM information_schema.TABLE_CONSTRAINTS
-    WHERE CONSTRAINT_SCHEMA=DATABASE() AND TABLE_NAME='ll_finance_fee_source'
-      AND CONSTRAINT_NAME='chk_ll_finance_fee_exchange_rate' AND CONSTRAINT_TYPE='CHECK';
-    IF checked_constraints=0 THEN
-        -- 保留真实已有列的精度和备注，不把存量 DECIMAL(18,8) 收窄到基线精度。
-        SELECT COLUMN_TYPE,COLUMN_COMMENT,COLUMN_DEFAULT INTO rate_type,rate_comment,rate_default
-        FROM information_schema.COLUMNS
-        WHERE TABLE_SCHEMA=DATABASE() AND TABLE_NAME='ll_finance_fee_source' AND COLUMN_NAME='exchange_rate';
-        IF rate_type NOT REGEXP '^decimal[(][0-9]+,[0-9]+[)]$' THEN
-            SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='汇率列不是预期定点数类型，停止修复';
-        END IF;
-        IF LOCATE('自动零元仓租可空',rate_comment)=0 THEN
-            SET rate_comment=CONCAT(rate_comment,'，自动零元仓租可空');
-        END IF;
-        -- 保留既有数值默认值（例如1.00000000）；拒绝表达式或非数值默认值。
-        IF rate_default IS NOT NULL AND rate_default NOT REGEXP '^-?[0-9]+([.][0-9]+)?$' THEN
-            SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='汇率默认值不是预期数值，停止修复';
-        END IF;
-        SET rate_default_sql=IF(rate_default IS NULL,' DEFAULT NULL',CONCAT(' DEFAULT ',rate_default));
-        -- 单次原子 ALTER 同步调整可空性与两项约束，原币及结算列完全不改。
-        SET @storage_rent_zero_fee_ddl=CONCAT(
-          'ALTER TABLE baiyue_lastleg.ll_finance_fee_source DROP CHECK chk_ll_finance_fee_amount, ',
-          'MODIFY COLUMN exchange_rate ',rate_type,' NULL',rate_default_sql,' COMMENT ',QUOTE(rate_comment),', ',
-          'ADD CONSTRAINT chk_ll_finance_fee_amount CHECK(amount>0 OR (amount=0 AND original_amount=0 AND created_by=''STORAGE_RENT'' AND fee_item_code=''FEE_TYPE_077'' AND direction=''RECEIVABLE'')), ',
-          'ADD CONSTRAINT chk_ll_finance_fee_exchange_rate CHECK((exchange_rate IS NOT NULL AND exchange_rate>0) OR (exchange_rate IS NULL AND amount=0 AND original_amount=0 AND created_by=''STORAGE_RENT'' AND fee_item_code=''FEE_TYPE_077'' AND direction=''RECEIVABLE''))');
-        PREPARE storage_rent_zero_fee_stmt FROM @storage_rent_zero_fee_ddl;
-        EXECUTE storage_rent_zero_fee_stmt;
-        DEALLOCATE PREPARE storage_rent_zero_fee_stmt;
-        SET @storage_rent_zero_fee_ddl=NULL;
-    END IF;
-END$$
-DELIMITER ;
-CALL storage_rent_zero_fee_repair_20261023();
-DROP PROCEDURE storage_rent_zero_fee_repair_20261023;
-SHOW CREATE TABLE ll_finance_fee_source;

deploy/sql/warehouse-supplier-query-structure-repair.sql

@@ -1,40 +0,0 @@
--- 供应商查询缺失结构修复。MySQL 8；仅用于本次明确授权的本机开发库。
--- 固定目标 baiyue_warehouse；不修改供应商、费用、余额或授信数据。
--- 已有结构安全跳过；不推断历史拖车供应商的国内/海外类别。
--- DDL 会隐式提交，请在独立连接以遇错停止模式整份执行。
-USE baiyue_warehouse;
-SET NAMES utf8mb4;
-SELECT DATABASE() AS target_database;
-
--- 先确认正式供应商主表存在；不存在时 ALTER 会报错并停止，不创建第二份主档。
-SET @supplier_query_column_ddl = IF(
-  EXISTS (SELECT 1 FROM information_schema.columns
-          WHERE table_schema = 'baiyue_warehouse'
-            AND table_name = 'wh_supplier' AND column_name = 'trucking_scope'),
-  'SELECT ''trucking_scope 已存在，跳过'' AS structure_result',
-  'ALTER TABLE baiyue_warehouse.wh_supplier ADD COLUMN trucking_scope VARCHAR(16) NULL COMMENT ''拖车类型：DOMESTIC国内拖车、OVERSEAS海外车队；非拖车为空'' AFTER category'
-);
-PREPARE supplier_query_statement FROM @supplier_query_column_ddl;
-EXECUTE supplier_query_statement;
-DEALLOCATE PREPARE supplier_query_statement;
-
--- 正式列表还会读取船司关联；若未初始化，仅按当前模块基线建立空表。
-CREATE TABLE IF NOT EXISTS wh_supplier_carrier (
-  supplier_id BIGINT UNSIGNED NOT NULL COMMENT 'BOOKING供应商ID',
-  tenant_id BIGINT UNSIGNED NOT NULL DEFAULT 0 COMMENT '平台公共作用域，固定为0',
-  carrier_code VARCHAR(16) NOT NULL COMMENT '船司标准编码',
-  created_by BIGINT UNSIGNED NULL COMMENT '创建人ID',
-  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '创建时间',
-  PRIMARY KEY (supplier_id,carrier_code),
-  KEY idx_wh_supplier_carrier_code (tenant_id,carrier_code,supplier_id),
-  CONSTRAINT chk_wh_supplier_carrier_tenant CHECK (tenant_id = 0),
-  CONSTRAINT chk_wh_supplier_carrier_code CHECK (carrier_code IN ('MATSON','SML','ZIM','COSCO','EMC','HEDE','OTHER'))
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='BOOKING供应商与标准船司编码多对多关联';
-
--- 执行后只核对结构，不读取供应商联系信息。
-SELECT table_name, column_name, column_type, is_nullable
-FROM information_schema.columns
-WHERE table_schema = 'baiyue_warehouse'
-  AND ((table_name = 'wh_supplier' AND column_name = 'trucking_scope')
-       OR table_name = 'wh_supplier_carrier')
-ORDER BY table_name, ordinal_position;

deploy/sql/头程数据库统一增量-MySQL8.sql

@@ -1,5 +1,4 @@
 -- CN 当前纯空库初始化入口（文件名沿用原入口，不提供增量升级语义）。
--- 海外费用菜单及平台管理员授权统一在本文件 IAM 种子中维护，不再单列本次版本或专项菜单脚本。
 -- MySQL 8.0+；只允许目标测试环境的服务 schema 为空，已有表立即报错；禁止 --force/遇错继续。
 -- 字段、索引、约束及注释直接定义在 CREATE TABLE 内；不回填、不清理、不改造存量。
 -- 国内 IAM 管理两区域权限；海外不访问国内库。执行方法及系统种子清单见同目录 README.md。
@@ -1485,6 +1484,7 @@ CREATE TABLE fl_container_booking (
   KEY idx_container_booking_voyage (voyage_no,updated_at),
   KEY idx_container_booking_transit_summary (actual_sailing_at,actual_warehouse_arrival_at,ocean_booking_id,container_type),
   CONSTRAINT chk_container_booking_capacity CHECK (((capacity_cbm is null) or (capacity_cbm > 0))),
+  CONSTRAINT chk_container_booking_iso6346 CHECK (((container_no is null) or regexp_like(container_no,_utf8mb4'^[A-Z]{3}[UJZ][0-9]{7}$'))),
   CONSTRAINT chk_container_booking_pickup_code CHECK (((pickup_code is null) or regexp_like(pickup_code,_utf8mb4'^[0-9]{1,64}$'))),
   CONSTRAINT chk_container_booking_record_status CHECK ((record_status in (_utf8mb4'ACTIVE',_utf8mb4'MERGED'))),
   CONSTRAINT chk_container_booking_source CHECK ((source_type in (_utf8mb4'SIMULATION',_utf8mb4'OCEAN_BOOKING'))),
@@ -3442,7 +3442,7 @@ CREATE TABLE fl_mojia_measurement_receipt (
 CREATE TABLE fl_ocean_booking (
   id bigint unsigned NOT NULL COMMENT '海运订舱ID',
   booking_no varchar(40) NOT NULL COMMENT '平台海运订舱编号',
-  status varchar(24) NOT NULL DEFAULT 'DRAFT' COMMENT '订舱状态：DRAFT草稿、RELEASED已放舱，运输快照冻结且实货量受控补录',
+  status varchar(24) NOT NULL DEFAULT 'DRAFT' COMMENT '订舱状态：DRAFT草稿、RELEASED已发布且永久只读',
   customer_id bigint unsigned DEFAULT NULL COMMENT '客户ID和数据隔离键',
   customer_name varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '客户名称快照',
   channel_code varchar(64) DEFAULT NULL COMMENT '订舱计划物流渠道组编码快照',
@@ -3465,17 +3465,6 @@ CREATE TABLE fl_ocean_booking (
   estimated_sailing_at datetime(3) DEFAULT NULL COMMENT '当前确认预计开船时间',
   estimated_arrival_at datetime(3) DEFAULT NULL COMMENT '当前确认预计到港时间',
   remark varchar(1000) DEFAULT NULL COMMENT '平台内部备注',
-  freight_term VARCHAR(64) NULL COMMENT '运费条款',
-  service_term VARCHAR(64) NULL COMMENT '运输条款',
-  package_unit VARCHAR(16) NULL COMMENT '包装单位：CARTONS、PCS或PALLETS',
-  cargo_description VARCHAR(1000) NULL COMMENT '货物品名及托运要求',
-  marks_and_nos VARCHAR(1000) NULL COMMENT '唛头和号码',
-  declared_package_count INT UNSIGNED NULL COMMENT '订舱预报件数（委）',
-  declared_gross_weight_kg DECIMAL(15,3) NULL COMMENT '订舱预报毛重kg（委）',
-  declared_volume_cbm DECIMAL(15,3) NULL COMMENT '订舱预报体积cbm（委）',
-  actual_package_count INT UNSIGNED NULL COMMENT '客服手工实货件数',
-  actual_gross_weight_kg DECIMAL(15,3) NULL COMMENT '客服手工实货毛重kg',
-  actual_volume_cbm DECIMAL(15,3) NULL COMMENT '客服手工实货体积cbm',
   created_by bigint unsigned NOT NULL COMMENT '创建操作人ID',
   created_by_name varchar(64) DEFAULT NULL COMMENT '创建操作人姓名快照',
   created_at datetime(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '订舱记录创建时间',
@@ -3490,14 +3479,6 @@ CREATE TABLE fl_ocean_booking (
   KEY idx_ocean_booking_voyage (vessel_name,voyage_no,updated_at),
   CONSTRAINT chk_ocean_booking_carrier_code CHECK (((carrier_code is null) or (carrier_code in (_utf8mb4'MATSON',_utf8mb4'SML',_utf8mb4'ZIM',_utf8mb4'COSCO',_utf8mb4'EMC',_utf8mb4'HEDE',_utf8mb4'OTHER')))),
   CONSTRAINT chk_ocean_booking_customer CHECK ((customer_id > 0)),
-  CONSTRAINT chk_ocean_booking_cargo CHECK (
-    (package_unit IS NULL OR package_unit IN ('CARTONS','PCS','PALLETS'))
-    AND (declared_package_count IS NULL OR declared_package_count BETWEEN 1 AND 999999999)
-    AND (actual_package_count IS NULL OR actual_package_count BETWEEN 1 AND 999999999)
-    AND (declared_gross_weight_kg IS NULL OR declared_gross_weight_kg > 0)
-    AND (actual_gross_weight_kg IS NULL OR actual_gross_weight_kg > 0)
-    AND (declared_volume_cbm IS NULL OR declared_volume_cbm > 0)
-    AND (actual_volume_cbm IS NULL OR actual_volume_cbm > 0)),
   CONSTRAINT chk_ocean_booking_schedule CHECK (((estimated_sailing_at is null) or (estimated_arrival_at is null) or (estimated_arrival_at >= estimated_sailing_at))),
   CONSTRAINT chk_ocean_booking_status CHECK ((status in (_utf8mb4'DRAFT',_utf8mb4'RELEASED')))
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='独立海运订舱聚合；柜次仍由fl_container_booking承载';
@@ -3584,8 +3565,6 @@ CREATE TABLE fl_ocean_booking_party (
   address varchar(1000) DEFAULT NULL COMMENT '关系方地址快照',
   contact_name varchar(128) DEFAULT NULL COMMENT '关系方联系人快照',
   contact_phone varchar(64) DEFAULT NULL COMMENT '关系方联系电话快照',
-  contact_email VARCHAR(255) NULL COMMENT '关系方联系邮箱',
-  tax_no VARCHAR(128) NULL COMMENT '关系方税号',
   PRIMARY KEY (id),
   UNIQUE KEY uk_ocean_booking_party (ocean_booking_id,party_type),
   CONSTRAINT fk_ocean_booking_party FOREIGN KEY (ocean_booking_id) REFERENCES fl_ocean_booking (id) ON DELETE CASCADE,
@@ -4458,6 +4437,20 @@ CREATE TABLE fl_inbound_split_item (
 
 SET SESSION foreign_key_checks = 1;
 
+-- 客户独立确认计费重，不回填既有费用确认。
+CREATE TABLE fl_chargeable_weight_confirmation (
+ id BIGINT NOT NULL COMMENT '确认记录ID',
+ tenant_id BIGINT NOT NULL COMMENT '客户隔离ID',
+ inbound_id BIGINT NOT NULL COMMENT '独立来源入仓单ID',
+ operator_id BIGINT NOT NULL COMMENT '确认客户成员ID',
+ command_key VARCHAR(128) NOT NULL COMMENT '成员确认幂等键',
+ fingerprint CHAR(64) NOT NULL COMMENT '计费重及测量轮次摘要',
+ chargeable_weight_kg DECIMAL(18,4) NOT NULL COMMENT '客户确认计费重千克',
+ confirmed_at DATETIME(3) NOT NULL COMMENT '客户确认时间',
+ PRIMARY KEY(id), UNIQUE KEY uk_weight_confirmation_command(tenant_id,operator_id,command_key),
+ KEY idx_weight_confirmation_inbound(tenant_id,inbound_id,id)
+) ENGINE=InnoDB COMMENT='客户计费重独立确认历史';
+
 -- 服务 schema：baiyue_file
 CREATE DATABASE IF NOT EXISTS baiyue_file DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;
 USE baiyue_file;
@@ -6047,48 +6040,9 @@ CREATE TRIGGER trg_ocean_allocation_before_insert BEFORE INSERT ON fl_ocean_book
   END IF;
 END$$
 
-CREATE TRIGGER trg_ocean_booking_before_update BEFORE UPDATE ON fl_ocean_booking FOR EACH ROW
+CREATE TRIGGER trg_ocean_booking_before_update BEFORE UPDATE ON fl_ocean_booking FOR EACH ROW BEGIN
-BEGIN
+  IF OLD.status = 'RELEASED' THEN
-  -- 已放舱只允许预计到港、实货量及审计元数据变化，其余运输和预报快照保持冻结。
+    SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='已放舱订舱不可修改';
-  IF OLD.status = 'RELEASED' AND NOT (
-    (NEW.id <=> OLD.id)
-    AND (NEW.booking_no <=> OLD.booking_no)
-    AND (NEW.status <=> OLD.status)
-    AND (NEW.customer_id <=> OLD.customer_id)
-    AND (NEW.customer_name <=> OLD.customer_name)
-    AND (NEW.channel_code <=> OLD.channel_code)
-    AND (NEW.channel_name <=> OLD.channel_name)
-    AND (NEW.warehouse_id <=> OLD.warehouse_id)
-    AND (NEW.warehouse_name <=> OLD.warehouse_name)
-    AND (NEW.bill_of_lading_no <=> OLD.bill_of_lading_no)
-    AND (NEW.shipping_company_id <=> OLD.shipping_company_id)
-    AND (NEW.shipping_company_name <=> OLD.shipping_company_name)
-    AND (NEW.carrier_code <=> OLD.carrier_code)
-    AND (NEW.booking_agent_id <=> OLD.booking_agent_id)
-    AND (NEW.booking_agent_name <=> OLD.booking_agent_name)
-    AND (NEW.vessel_name <=> OLD.vessel_name)
-    AND (NEW.voyage_no <=> OLD.voyage_no)
-    AND (NEW.departure_port_code <=> OLD.departure_port_code)
-    AND (NEW.departure_port_name <=> OLD.departure_port_name)
-    AND (NEW.destination_port_code <=> OLD.destination_port_code)
-    AND (NEW.destination_port_name <=> OLD.destination_port_name)
-    AND (NEW.place_of_delivery <=> OLD.place_of_delivery)
-    AND (NEW.estimated_sailing_at <=> OLD.estimated_sailing_at)
-    AND (NEW.remark <=> OLD.remark)
-    AND (NEW.freight_term <=> OLD.freight_term)
-    AND (NEW.service_term <=> OLD.service_term)
-    AND (NEW.package_unit <=> OLD.package_unit)
-    AND (NEW.cargo_description <=> OLD.cargo_description)
-    AND (NEW.marks_and_nos <=> OLD.marks_and_nos)
-    AND (NEW.declared_package_count <=> OLD.declared_package_count)
-    AND (NEW.declared_gross_weight_kg <=> OLD.declared_gross_weight_kg)
-    AND (NEW.declared_volume_cbm <=> OLD.declared_volume_cbm)
-    AND (NEW.created_by <=> OLD.created_by)
-    AND (NEW.created_by_name <=> OLD.created_by_name)
-    AND (NEW.created_at <=> OLD.created_at)
-    AND NEW.version = OLD.version + 1
-  ) THEN
-    SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='已放舱仅允许维护预计到港及补录实货量';
   END IF;
   IF OLD.status <> NEW.status AND NOT (
        (OLD.status='DRAFT' AND NEW.status='RELEASED')) THEN
@@ -8459,8 +8413,4 @@ CREATE TABLE wh_document_sequence (
   CONSTRAINT chk_wh_document_sequence_value CHECK (current_value > 0)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='业务单据每日独立原子流水';
 
--- 海外费用查询菜单；编辑、审核继续使用独立财务按钮授权。
+SELECT 'PASS' AS initialization_status, 'CN' AS region, 230 AS initialized_tables;
-USE baiyue_iam;
-INSERT INTO iam_permission (id,tenant_id,app_code,permission_type,parent_id,permission_code,permission_name,route_path,http_method,sort_no,status,built_in,created_at,updated_at,deleted) VALUES (5117200,0,'PLATFORM','MENU',0,'platform:overseas-fee:list','海外费用管理','/overseas-business/fees','GET',890,'ACTIVE',1,CURRENT_TIMESTAMP(3),CURRENT_TIMESTAMP(3),0);
-INSERT INTO iam_role_permission (role_id,permission_id,tenant_id,created_at) VALUES (4000001,5117200,0,CURRENT_TIMESTAMP(3));
-SELECT 'PASS' AS initialization_status, 'CN' AS region, 229 AS initialized_tables;

deploy/sql/排车运输接入-数据库变更汇总.md

@@ -1,21 +0,0 @@
-# 排车运输接入数据库变更汇总
-
-执行文件：[lastleg-dispatch-transport-tasks.sql](lastleg-dispatch-transport-tasks.sql)。目标为 **MySQL 8 / baiyue_lastleg**，文件内已有 `USE baiyue_lastleg`。可整份重复执行；按 information_schema 判断字段及索引，按 IF NOT EXISTS 创建表。已在本机既有业务数据环境连续执行两次通过；未在远端环境执行。
-
-| 对象 | 新增或调整 | 用途 |
-|---|---|---|
-| ll_dispatch_order.task_type | 新增 VARCHAR(32) NOT NULL DEFAULT DELIVERY | 区分仓库派送、到仓取货、本土卡车；旧单保留派送类型 |
-| ll_dispatch_truck_task | 新表；dispatch_no、trip_no、customer_id、order_no、active_order | 真实排车关联原单；运输记录唯一、有效原单唯一；取消释放有效键，完成保留 |
-| ll_dispatch_transport_create | 新表；trip_no、request_hash | 原安排请求摘要，避免重复建单及同键更换原单 |
-| ll_dispatch_transport_command | 新表；dispatch_no、request_key、request_hash、evidence_json、created_at | 执行命令幂等、已确认完成凭证持久化 |
-| ll_dispatch_daily_sequence | 既有正式日流水表，缺失时补建 | 统一 PC 日期与四位流水；不修改历史单号 |
-| ll_dispatch_order.customer_id | 仅旧库存在且为 NOT NULL 时改为允许 NULL | 兼容整车跨客户主单；保留原值，不回填或置空 |
-| ll_us_truck_order.contact_name / contact_info / requested_date | 仅旧库仍为 NOT NULL 时改为允许 NULL | 兼容现有原单起终点联系人及取送时间模型，保留历史字段和数据 |
-| ll_fleet_external_booking.source_looseboard_order_id | 缺失时补 BIGINT NULL | 当前承运占用查询依赖，等同 V33；不创建散板业务 |
-| ll_fleet_external_booking.idx_booking_looseboard_source | 缺失时补客户、原散板ID、状态联合索引 | 原单承运占用查询 |
-
-所有新增表、字段均有中文注释。SQL不创建账号、不改角色权限、不删除表或记录、不改库存及历史单号，也不回填旧任务。
-
-前置：目标库已具备当前整车排车、FleetTrip、仓储转运取货及本土卡车业务结构；本文件是本次运输接入增量，不替代这些模块的完整升级。执行完成后配套发布 Lastleg 和 Admin。迁移系统记录为 V32，承运占用依赖结构为 V33；直接交付执行时使用本份汇总 SQL 即可，不再重复手动执行两个版本文件。
-
-本机验收中发现的旧字段约束与缺少日流水表已一并纳入。业务数据由正式 Gateway HTTP 创建，结构验证未写业务SQL。

deploy/sql/海外区域统一增量-MySQL8.sql

@@ -1,5 +1,4 @@
 -- OVERSEAS 当前纯空库初始化入口（文件名沿用原入口，不提供增量升级语义）。
--- 海外费用资金、仓租四表、审核人名称快照、采购退款请求幂等字段及唯一索引均在本文件最终建表定义中维护。
 -- MySQL 8.0+；只允许目标测试环境的服务 schema 为空，已有表立即报错；禁止 --force/遇错继续。
 -- 字段、索引、约束及注释直接定义在 CREATE TABLE 内；不回填、不清理、不改造存量。
 -- 国内 IAM 管理两区域权限；海外不访问国内库。执行方法及系统种子清单见同目录 README.md。
@@ -315,7 +314,7 @@ CREATE TABLE ll_destuff_pallet_cost_allocation (
   customer_id varchar(128) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '客户ID',
   actual_volume_cbm decimal(20,6) NOT NULL COMMENT '客户实收体积',
   allocated_amount decimal(20,2) NOT NULL COMMENT '客户分摊金额',
-  fee_source_id bigint DEFAULT NULL COMMENT '人工审核后关联的海外费用来源ID',
+  fee_source_id bigint NOT NULL COMMENT '海外费用来源ID',
   created_at datetime(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '创建时间',
   PRIMARY KEY (id),
   UNIQUE KEY uk_ll_destuff_customer (cost_id,customer_id),
@@ -417,8 +416,6 @@ CREATE TABLE ll_dispatch_item (
 CREATE TABLE ll_dispatch_order (
   id BIGINT NOT NULL COMMENT '整车排车主单内部主键',
   dispatch_no VARCHAR(64) NOT NULL COMMENT '真实排车业务号',
-  task_type VARCHAR(32) NOT NULL DEFAULT 'DELIVERY' COMMENT '任务类型：仓库派送、到仓取货、本土卡车',
-  publish_looseboard_demand TINYINT(1) NOT NULL DEFAULT 0 COMMENT '是否向内部散板需求池发布余位',
   trip_id BIGINT NOT NULL COMMENT '本趟唯一车辆资源记录ID',
   overseas_warehouse_id VARCHAR(128) NOT NULL COMMENT '真实起运海外仓ID',
   overseas_warehouse_code VARCHAR(128) NULL COMMENT '起运海外仓编码快照',
@@ -431,7 +428,6 @@ CREATE TABLE ll_dispatch_order (
   review_state VARCHAR(32) NOT NULL DEFAULT 'DRAFT' COMMENT '审核子流程当前状态',
   review_round BIGINT NOT NULL DEFAULT 0 COMMENT '当前审核轮次',
   review_basis_hash CHAR(64) NULL COMMENT '本审核轮次核对的货物和资源依据摘要',
-  exceptions_json JSON NULL COMMENT '派送异常登记记录及图片引用，不改变派送及库存状态',
   dispatch_review_json JSON NULL COMMENT '当前调度审核事实快照',
   loading_review_json JSON NULL COMMENT '当前理货审核事实快照',
   resources_json JSON NULL COMMENT '本趟主档或临时车辆司机的真实资源快照',
@@ -948,7 +944,6 @@ CREATE TABLE ll_finance_fee_source (
   warehouse_id bigint DEFAULT NULL COMMENT '关联海外仓ID',
   fee_item_code varchar(64) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '费用项目编码快照',
   fee_item_name varchar(200) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '费用项目名称快照',
-  fee_remark varchar(500) COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '费用说明，补收或重复作业原因',
   direction varchar(16) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT 'RECEIVABLE应收或PAYABLE应付',
   supplier_id bigint DEFAULT NULL COMMENT '应付供应商ID',
   supplier_name varchar(200) COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '应付供应商名称快照',
@@ -964,7 +959,7 @@ CREATE TABLE ll_finance_fee_source (
   amount decimal(20,6) NOT NULL COMMENT '人民币结算金额',
   original_currency char(3) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '业务原币种，支持CNY或USD',
   original_amount decimal(20,6) NOT NULL COMMENT '业务原币金额',
-  exchange_rate decimal(20,6) DEFAULT NULL COMMENT '原币折算人民币汇率，人民币固定为1，自动零元仓租可空',
+  exchange_rate decimal(20,6) NOT NULL COMMENT '原币折算人民币汇率，人民币固定为1',
   exchange_rate_month char(7) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '汇率月份yyyy-MM',
   chargeable_quantity decimal(20,6) DEFAULT NULL COMMENT '计费数量，如箱数、托数、体积或天数',
   quantity_unit varchar(32) COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '计费数量单位',
@@ -976,7 +971,6 @@ CREATE TABLE ll_finance_fee_source (
   source_status varchar(16) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT 'ACTIVE、SUPERSEDED或VOIDED',
   review_reason varchar(500) COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '审核或作废原因',
   reviewer_id varchar(128) COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '审核人ID',
-  reviewer_name varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '审核人名称快照',
   reviewed_at datetime(3) DEFAULT NULL COMMENT '审核时间',
   created_by varchar(128) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '创建人ID',
   updated_by varchar(128) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '最后更新人ID',
@@ -987,8 +981,7 @@ CREATE TABLE ll_finance_fee_source (
   KEY idx_ll_finance_fee_customer (customer_id,source_status,created_at),
   KEY idx_ll_finance_fee_business (business_type,business_no,created_at),
   KEY idx_ll_finance_fee_container_customer (container_booking_id,customer_id,source_status,created_at),
-  CONSTRAINT chk_ll_finance_fee_exchange_rate CHECK((exchange_rate IS NOT NULL AND exchange_rate>0) OR (exchange_rate IS NULL AND amount=0 AND original_amount=0 AND created_by='STORAGE_RENT' AND fee_item_code='FEE_TYPE_077' AND direction='RECEIVABLE')),
+  CONSTRAINT chk_ll_finance_fee_amount CHECK ((amount > 0)),
-  CONSTRAINT chk_ll_finance_fee_amount CHECK(amount>0 OR (amount=0 AND original_amount=0 AND created_by='STORAGE_RENT' AND fee_item_code='FEE_TYPE_077' AND direction='RECEIVABLE')),
   CONSTRAINT chk_ll_finance_fee_currency CHECK ((currency = _utf8mb4'CNY')),
   CONSTRAINT chk_ll_finance_fee_direction CHECK ((direction in (_utf8mb4'RECEIVABLE',_utf8mb4'PAYABLE'))),
   CONSTRAINT chk_ll_finance_fee_original_currency CHECK ((original_currency in (_utf8mb4'CNY',_utf8mb4'USD'))),
@@ -1663,6 +1656,12 @@ CREATE TABLE ll_monthly_exchange_rate_history (
   KEY idx_ll_exchange_rate_history (exchange_rate_id,created_at)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='月度汇率变更历史';
 
+CREATE TABLE IF NOT EXISTS ll_dispatch_daily_sequence (
+  business_date DATE NOT NULL COMMENT '排车编号业务日期（Asia/Shanghai）',
+  last_sequence INT NOT NULL COMMENT '当日已分配排车流水号，范围0001至9999',
+  PRIMARY KEY(business_date)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车单号每日独立原子流水';
+
 CREATE TABLE ll_order (
   id bigint NOT NULL COMMENT '雪花 ID',
   order_no varchar(32) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '尾程单号',
@@ -2126,7 +2125,6 @@ CREATE TABLE ll_overseas_procurement_file (
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='海外采购签收文件及费用凭证';
 
 CREATE TABLE ll_overseas_procurement_order (
-  procurement_direction VARCHAR(32) NOT NULL DEFAULT 'OVERSEAS_TO_DOMESTIC' COMMENT '采购方向：海外采购回国内/国内采购发海外',
   id bigint NOT NULL COMMENT '主键ID',
   customer_id varchar(128) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '客户租户ID',
   customer_name varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '客户名称快照',
@@ -3218,7 +3216,6 @@ CREATE TABLE ll_fleet_external_booking (
   binding_key VARCHAR(128) NULL COMMENT '关联发运请求键',
   binding_hash CHAR(64) NULL COMMENT '关联发运摘要',
   offer_id BIGINT NULL COMMENT '来源运力发布，普通车次预订为空',
-  source_looseboard_order_id BIGINT NULL COMMENT '客户原始散板商业单ID，取消后保留来源',
   sales_owner_user_id VARCHAR(64) NULL COMMENT '登录身份冻结的销售负责人',
   business_type VARCHAR(32) NULL COMMENT '本土商业类型LOCAL_LOOSEBOARD或US_TRUCK',
   delivery_mode VARCHAR(32) NULL COMMENT '客户送仓或人工安排提货回仓',
@@ -3233,7 +3230,6 @@ CREATE TABLE ll_fleet_external_booking (
   KEY idx_fleet_booking_sales(sales_owner_user_id,offer_id,id),
   CONSTRAINT fk_fleet_booking_offer FOREIGN KEY(offer_id) REFERENCES ll_fleet_capacity_offer(id),
   CONSTRAINT chk_fleet_booking_expected_pallet CHECK(expected_pallet_count IS NULL OR expected_pallet_count > 0),
-  KEY idx_booking_looseboard_source (customer_id,source_looseboard_order_id,status),
   PRIMARY KEY(id),
   UNIQUE KEY uk_fleet_booking_no(booking_no),
   UNIQUE KEY uk_fleet_booking_create(trip_id,created_by,idempotency_key),
@@ -4598,7 +4594,6 @@ CREATE TABLE ll_return_sku_conversion (
  quantity BIGINT NOT NULL COMMENT '实际完成转换件数',
  status VARCHAR(32) NOT NULL COMMENT 'APPLIED待客户确认/CONFIRMED已确认/REVERSED退回冲回',
  ownership_json LONGTEXT NOT NULL COMMENT '本次转换件数的来源退货单快照，供精确冲回',
- storage_rent_shares_json LONGTEXT NULL COMMENT '原仓租批次迁移快照',
  completed_at DATETIME(3) NOT NULL COMMENT '实物SKU转换时间',
  confirmed_at DATETIME(3) NULL COMMENT '客户确认时间',
  reversed_at DATETIME(3) NULL COMMENT '退回冲回时间',
@@ -4881,8 +4876,7 @@ CREATE TABLE ll_fleet_pickup_history (
   KEY idx_pickup_history_trip(trip_no,id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='取货不可变操作历史';
 
--- 自有业务仅保存原排车的归属证据和附加运营信息，不复制履约主单。
+CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_ownership (
-CREATE TABLE ll_fleet_owned_business_ownership (
   dispatch_id BIGINT NOT NULL COMMENT '原排车内部主键',
   resource_mode VARCHAR(16) NOT NULL COMMENT '原排车资源模式MASTER或EXTERNAL',
   vehicle_id BIGINT NULL COMMENT '真实车辆档案主键，临时外配为空',
@@ -4900,7 +4894,7 @@ CREATE TABLE ll_fleet_owned_business_ownership (
     OR (resource_mode='EXTERNAL' AND vehicle_id IS NULL AND vehicle_record_version IS NULL AND vehicle_ownership='DISPATCHED'))
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='原排车装车完成时的车辆归属证据';
 
-CREATE TABLE ll_fleet_owned_business_record (
+CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_record (
   id BIGINT NOT NULL COMMENT '附加运营记录内部主键',
   dispatch_id BIGINT NOT NULL COMMENT '所属原排车内部主键',
   record_version BIGINT NOT NULL COMMENT '附加运营记录并发版本，独立于原排车版本',
@@ -4925,7 +4919,7 @@ CREATE TABLE ll_fleet_owned_business_record (
   CONSTRAINT ck_owned_business_fuel CHECK (fuel_consumption_litres_per_100km IS NULL OR fuel_consumption_litres_per_100km>=0)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='原排车自有业务附加运营信息';
 
-CREATE TABLE ll_fleet_owned_business_command (
+CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_command (
   id BIGINT NOT NULL COMMENT '附加运营命令内部主键',
   dispatch_id BIGINT NOT NULL COMMENT '所属原排车内部主键',
   operator_id VARCHAR(64) NOT NULL COMMENT '原命令操作人标识',
@@ -4946,7 +4940,7 @@ CREATE TABLE ll_fleet_owned_business_command (
   CONSTRAINT ck_owned_business_command_status CHECK (status IN ('PENDING','SUCCEEDED','REJECTED','UNKNOWN_RESULT'))
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='原排车附加运营写命令及可恢复结果';
 
-CREATE TABLE ll_fleet_owned_business_history (
+CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_history (
   id BIGINT NOT NULL COMMENT '附加运营历史内部主键',
   dispatch_id BIGINT NOT NULL COMMENT '所属原排车内部主键',
   record_version BIGINT NOT NULL COMMENT '成功写入后的附加记录版本',
@@ -4961,30 +4955,6 @@ CREATE TABLE ll_fleet_owned_business_history (
   CONSTRAINT ck_owned_business_history_version CHECK (record_version>0)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='原排车自有业务附加运营不可变历史';
 
--- 运输原单接入现有排车，不产生仓内库存事实。
-USE baiyue_lastleg;
-CREATE TABLE ll_dispatch_truck_task (
-  dispatch_no VARCHAR(64) NOT NULL COMMENT '排车业务号',
-  trip_no VARCHAR(64) NOT NULL COMMENT '本次运输资源记录号',
-  customer_id VARCHAR(128) NOT NULL COMMENT '本土卡车原单客户标识',
-  order_no VARCHAR(64) NOT NULL COMMENT '本土卡车原单业务号',
-  active_order VARCHAR(193) NULL COMMENT '有效原单唯一键；取消置空，完成保留',
-  PRIMARY KEY(dispatch_no), UNIQUE KEY uk_transport_trip(trip_no), UNIQUE KEY uk_transport_source(active_order),
-  KEY idx_transport_order(customer_id,order_no)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车与本土卡车原单关联';
-CREATE TABLE ll_dispatch_transport_create (
-  trip_no VARCHAR(64) NOT NULL PRIMARY KEY COMMENT '本次运输资源记录号',
-  request_hash CHAR(64) NOT NULL COMMENT '首次安排请求摘要'
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='本土卡车排车创建请求账本';
-CREATE TABLE ll_dispatch_transport_command (
-  dispatch_no VARCHAR(64) NOT NULL COMMENT '排车业务号',
-  request_key VARCHAR(128) NOT NULL COMMENT '客户端幂等请求键',
-  request_hash CHAR(64) NOT NULL COMMENT '执行命令请求摘要',
-  evidence_json JSON NULL COMMENT '已确认运输完成凭证标识列表',
-  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '业务命令提交时间',
-  PRIMARY KEY(dispatch_no,request_key)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车运输执行命令与凭证账本';
-
 USE baiyue_lastleg;
 CREATE TABLE ll_document_sequence (
   sequence_key VARCHAR(32) NOT NULL COMMENT '业务前缀与北京时间日期组成的全局序列键',
@@ -4993,117 +4963,4 @@ CREATE TABLE ll_document_sequence (
   CONSTRAINT chk_ll_document_sequence_value CHECK (current_value > 0)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='业务单据每日独立原子流水';
 
--- 海外费用资金及实收仓租。
+SELECT 'PASS' AS initialization_status, 'OVERSEAS' AS region, 232 AS initialized_tables;
--- 海外人工费用资金编排。金额与余额以 Finance 钱包为唯一事实，本表仅记录指令及回执状态。
-CREATE TABLE ll_finance_fee_funding (
-  source_fee_id BIGINT NOT NULL COMMENT '关联海外费用稳定来源ID',
-  customer_id VARCHAR(128) NOT NULL COMMENT '费用所属客户隔离标识',
-  collection_mode VARCHAR(16) NOT NULL COMMENT '客户收费方式：BILL账单结算，WALLET余额及授信',
-  wallet_status VARCHAR(32) NOT NULL COMMENT '资金进度：待冻结、已冻结、待扣款、已扣款、待释放及失败状态',
-  wallet_business_no VARCHAR(128) NULL COMMENT '本次冻结使用的独立业务编号，重提使用新编号',
-  command_event_id VARCHAR(64) NULL COMMENT '当前待处理资金指令事件ID',
-  wallet_hold_id VARCHAR(64) NULL COMMENT 'Finance确认的资金冻结记录ID',
-  wallet_ledger_id VARCHAR(64) NULL COMMENT 'Finance确认的已扣资金流水ID',
-  command_version BIGINT NOT NULL DEFAULT 0 COMMENT '资金指令单调递增版本，防止重试重复入账',
-  error_message VARCHAR(500) NULL COMMENT '最新资金失败原因，成功后清空',
-  command_history JSON NOT NULL COMMENT '已发资金指令及核验结果哈希，识别重复和错序回执',
-  created_at DATETIME(3) NOT NULL COMMENT '资金编排创建UTC时间',
-  updated_at DATETIME(3) NOT NULL COMMENT '资金编排最近变更UTC时间',
-  PRIMARY KEY (source_fee_id),
-  KEY idx_ll_fee_funding_customer_state (customer_id, wallet_status),
-  KEY idx_ll_fee_funding_command (command_event_id)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='海外人工费用资金冻结、审核扣款及释放编排';
-
-CREATE TABLE IF NOT EXISTS ll_storage_rent_inbound (
-  receipt_id bigint NOT NULL COMMENT '实际入库凭证主键，防止重复累计计租数量',
-  lot_id bigint NOT NULL COMMENT '头程同单同仓计租批次主键',
-  quantity decimal(24,12) NOT NULL COMMENT '本次实收追加计租箱数',
-  created_at datetime(3) NOT NULL COMMENT '计租登记时间，采用协调世界时',
-  PRIMARY KEY (receipt_id),
-  KEY idx_storage_rent_inbound_lot (lot_id)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='头程实收计租幂等登记';
-
-CREATE TABLE ll_storage_rent_lot (
-  id bigint NOT NULL COMMENT '原批次主键',
-  source_key varchar(80) NOT NULL COMMENT '实收来源幂等键',
-  customer_id varchar(32) NOT NULL COMMENT '客户标识',
-  customer_name varchar(255) DEFAULT NULL COMMENT '客户名称',
-  warehouse_id varchar(32) NOT NULL COMMENT '海外仓标识',
-  warehouse_name varchar(255) DEFAULT NULL COMMENT '海外仓名称',
-  business_type varchar(32) NOT NULL COMMENT '原入库业务类型',
-  business_id bigint NOT NULL COMMENT '原入库业务主键',
-  business_no varchar(128) NOT NULL COMMENT '原入库业务单号',
-  order_id bigint DEFAULT NULL COMMENT '尾程订单主键',
-  inbound_code varchar(128) DEFAULT NULL COMMENT '入仓码',
-  balance_id bigint DEFAULT NULL COMMENT '普通库存余额主键',
-  batch_no varchar(128) DEFAULT NULL COMMENT '原实收批次',
-  sku_code varchar(128) DEFAULT NULL COMMENT '商品编码',
-  rule_code varchar(32) NOT NULL COMMENT '仓租规则',
-  original_quantity decimal(24,12) NOT NULL COMMENT '实收原始数量',
-  remaining_quantity decimal(24,12) NOT NULL COMMENT '未出库原始数量',
-  original_units decimal(24,12) DEFAULT NULL COMMENT '原批次计费体积或托数',
-  inbound_at datetime(3) NOT NULL COMMENT '实际入库时间',
-  created_at datetime(3) NOT NULL COMMENT '创建时间',
-  updated_at datetime(3) NOT NULL COMMENT '更新时间',
-  PRIMARY KEY (id),
-  UNIQUE KEY uk_storage_rent_lot_source (source_key),
-  KEY idx_storage_rent_stock (balance_id,batch_no),
-  KEY idx_storage_rent_customer (customer_id,warehouse_id,inbound_at)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='实收计租原批次';
-
-CREATE TABLE ll_storage_rent_share (
-  balance_id bigint DEFAULT NULL COMMENT '普通库存当前余额，退货箱份额为空',
-  batch_no varchar(128) DEFAULT NULL COMMENT '普通库存当前批次，换标搬移保持原计租批次引用',
-  id bigint NOT NULL COMMENT '份额主键',
-  lot_id bigint NOT NULL COMMENT '原计租批次主键',
-  customer_id varchar(32) NOT NULL COMMENT '客户标识',
-  warehouse_id varchar(32) NOT NULL COMMENT '海外仓标识',
-  carton_mark varchar(255) DEFAULT NULL COMMENT '当前箱唛',
-  sku_code varchar(128) DEFAULT NULL COMMENT '商品编码',
-  quantity decimal(24,12) NOT NULL COMMENT '剩余商品数量',
-  PRIMARY KEY (id),
-  UNIQUE KEY uk_storage_rent_return_share (lot_id,carton_mark,sku_code),
-  UNIQUE KEY uk_storage_rent_stock_share (lot_id,balance_id,batch_no),
-  KEY idx_storage_rent_carton (customer_id,warehouse_id,carton_mark),
-  KEY idx_storage_rent_share_stock (customer_id,warehouse_id,balance_id,batch_no)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='当前库存与原计租批次份额';
-
-CREATE TABLE ll_storage_rent_preparation (
-  id bigint NOT NULL COMMENT '预校验主键',
-  warehouse_id varchar(32) NOT NULL COMMENT '作业海外仓',
-  customer_id varchar(32) NOT NULL COMMENT '费用客户',
-  mode varchar(32) NOT NULL COMMENT '扫码类型',
-  execution_no varchar(128) NOT NULL COMMENT '实际作业单号',
-  request_key varchar(255) NOT NULL COMMENT '原扫码幂等键',
-  request_hash varchar(64) NOT NULL COMMENT '原扫码内容哈希',
-  attempt int NOT NULL COMMENT '冻结尝试次数',
-  business_type varchar(32) NOT NULL COMMENT '本次应收业务类型',
-  business_id bigint NOT NULL COMMENT '本次应收业务主键',
-  business_no varchar(128) NOT NULL COMMENT '本次应收业务单号',
-  status varchar(32) NOT NULL COMMENT '资金与扫码状态',
-  plan_json json NOT NULL COMMENT '原批次计费不可变快照',
-  original_amount decimal(24,12) NOT NULL COMMENT '原币仓租金额，币种见计费快照',
-  amount decimal(24,12) NOT NULL COMMENT '人民币结算金额',
-  exchange_rate decimal(24,12) NULL COMMENT '冻结确认汇率，免费出库为空',
-  exchange_rate_month varchar(7) NOT NULL COMMENT '汇率月份',
-  freeze_event_id varchar(128) DEFAULT NULL COMMENT '冻结指令事件',
-  settle_event_id varchar(128) DEFAULT NULL COMMENT '扣款指令事件',
-  release_event_id varchar(128) DEFAULT NULL COMMENT '解冻指令事件',
-  release_status varchar(32) DEFAULT NULL COMMENT '解冻回执状态，失败后由恢复任务重发',
-  wallet_version bigint NOT NULL COMMENT '同一预占资金命令版本，重试使用新版本保留审计',
-  hold_id varchar(128) DEFAULT NULL COMMENT '财务冻结主键',
-  ledger_id varchar(128) DEFAULT NULL COMMENT '财务扣款流水',
-  error_message varchar(1000) DEFAULT NULL COMMENT '资金处理结果',
-  source_fee_id bigint DEFAULT NULL COMMENT '财务费用来源主键',
-  created_at datetime(3) NOT NULL COMMENT '预校验时间',
-  consumed_at datetime(3) DEFAULT NULL COMMENT '实际扫描出库时间',
-  updated_at datetime(3) NOT NULL COMMENT '更新时间',
-  PRIMARY KEY (id),
-  UNIQUE KEY uk_storage_rent_request (warehouse_id,mode,request_key,attempt),
-  KEY idx_storage_rent_execution (mode,execution_no,status),
-  KEY idx_storage_rent_business (customer_id,business_no),
-  KEY idx_storage_rent_recovery (status,updated_at),
-  KEY idx_storage_rent_release (release_status,updated_at)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='仓租扫码资金预占与结算快照';
-
-SELECT 'PASS' AS initialization_status, 'OVERSEAS' AS region, 239 AS initialized_tables;

file/src/main/java/com/baiyue/file/service/BusinessFileCategory.java

@@ -11,8 +11,6 @@ enum BusinessFileCategory {
     FLEET_TRIP_OPERATION_EVIDENCE(false, FormatPolicy.PDF_IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
     OVERSEAS_DISPATCH_VEHICLE_EVIDENCE(false, FormatPolicy.PDF_IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
     OVERSEAS_DISPATCH_DRIVER_EVIDENCE(false, FormatPolicy.PDF_IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
-    OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE(false, FormatPolicy.IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
-    OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE(false, FormatPolicy.IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
     OVERSEAS_DISPATCH_LOADING_PHOTO(false, FormatPolicy.IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
     OVERSEAS_DISPATCH_FUEL_PHOTO(false, FormatPolicy.IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
     FLEET_VEHICLE_RECORD_PHOTO(false, FormatPolicy.IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
@@ -80,9 +78,9 @@ enum BusinessFileCategory {
                 && tenantId != 0) {
             throw new BizException(ResultCode.BAD_REQUEST, "排车运营照片必须归属平台");
         }
-        if ((this == OVERSEAS_DISPATCH_VEHICLE_EVIDENCE || this == OVERSEAS_DISPATCH_DRIVER_EVIDENCE || this == OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE || this == OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE)
+        if ((this == OVERSEAS_DISPATCH_VEHICLE_EVIDENCE || this == OVERSEAS_DISPATCH_DRIVER_EVIDENCE)
                 && tenantId != 0) {
-            throw new BizException(ResultCode.BAD_REQUEST, "排车证据必须归属平台");
+            throw new BizException(ResultCode.BAD_REQUEST, "排车车辆及司机证据必须归属平台");
         }
         if (this == FLEET_TRIP_OPERATION_EVIDENCE && tenantId != 0) {
             throw new BizException(ResultCode.BAD_REQUEST, "出车实测凭证必须归属平台");

file/src/main/resources/openapi/dispatch-evidence-v1.yaml

@@ -4,9 +4,9 @@ info:
   version: 1.0.0
   description: >-
     复用 InternalBusinessFileController 的现有通用内部入口，不新增公开文件路由。
-    三类证据均固定平台 tenantId=0，businessId 为排车内部正数 Long ID 的十进制表示，
+    两类证据均固定平台 tenantId=0，businessId 为排车内部正数 Long ID 的十进制表示，
     不使用车辆 ID、司机 ID、车牌或客户 ID。车辆与司机证据分别使用
-    OVERSEAS_DISPATCH_VEHICLE_EVIDENCE、OVERSEAS_DISPATCH_DRIVER_EVIDENCE、OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE，不可互换。司机本人照片DRIVER_PHOTO和排车异常图片EXCEPTION仅支持JPG/PNG；其他两类沿PDF/JPG/PNG。
+    OVERSEAS_DISPATCH_VEHICLE_EVIDENCE、OVERSEAS_DISPATCH_DRIVER_EVIDENCE，不可互换。
     File 校验内部服务令牌、平台归属、正数业务 ID、文件非空、最大 10MiB（10485760 字节，包含边界）、
     PDF/JPG/PNG MIME 及对应内容签名。元数据和下载按 tenantId、businessType、businessId、fileId
     联合查询 ACTIVE 且未删除文件，错车或错类别均视为归属不匹配，下载前完成归属校验。
@@ -126,7 +126,7 @@ components:
       description: 正数Long的十进制字符串，值不得超过9223372036854775807
     DispatchEvidenceType:
       type: string
-      enum: [OVERSEAS_DISPATCH_VEHICLE_EVIDENCE, OVERSEAS_DISPATCH_DRIVER_EVIDENCE, OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE, OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE]
+      enum: [OVERSEAS_DISPATCH_VEHICLE_EVIDENCE, OVERSEAS_DISPATCH_DRIVER_EVIDENCE]
     MetadataEnvelope:
       type: object
       required: [code, data]

file/src/test/java/com/baiyue/file/service/DispatchEvidenceFileTest.java

@@ -30,8 +30,6 @@ import static org.mockito.Mockito.*;
 
 class DispatchEvidenceFileTest {
     private static final String VEHICLE = "OVERSEAS_DISPATCH_VEHICLE_EVIDENCE";
-    private static final String EXCEPTION = "OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE";
-    private static final String PHOTO = "OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE";
     private static final String DRIVER = "OVERSEAS_DISPATCH_DRIVER_EVIDENCE";
     private static final int MAX_BYTES = 10 * 1024 * 1024;
     @TempDir Path root;
@@ -42,9 +40,9 @@ class DispatchEvidenceFileTest {
             FileObjectEntity.class);
     }
 
-    /** 三类证据只接受平台与有效排车内部 ID，非法输入不得访问数据库或磁盘。 */
+    /** 两类证据只接受平台与有效排车内部 ID，非法输入不得访问数据库或磁盘。 */
     @ParameterizedTest
-    @ValueSource(strings = {VEHICLE, DRIVER, PHOTO, EXCEPTION})
+    @ValueSource(strings = {VEHICLE, DRIVER})
     void requiresPlatformAndPositiveDispatchIdBeforeAccess(String type) {
         var files = mock(FileObjectMapper.class);
         var storage = mock(BusinessFileStorage.class);
@@ -66,19 +64,6 @@ class DispatchEvidenceFileTest {
         verifyNoInteractions(files, storage);
     }
 
-    /** 司机照片与异常图片使用独立平台类别，拒绝PDF和伪造图片。 */
-    @ParameterizedTest @ValueSource(strings = {PHOTO, EXCEPTION})
-    void photoAcceptsOnlyRealImages(String type) throws Exception {
-        var storage=storage();var category=BusinessFileCategory.require(type);
-        for(var format:new String[]{"jpeg","png"}) {
-            var upload=new MockMultipartFile("file","driver."+format,"image/"+format,image(format));
-            var saved=storage.store(0,"71",upload,category);
-            assertThat(storage.read(saved.objectKey())).isEqualTo(upload.getBytes());
-        }
-        assertThatThrownBy(()->storage.store(0,"71",pdf(),category)).isInstanceOf(BizException.class);
-        assertThatThrownBy(()->storage.store(0,"71",new MockMultipartFile("file","driver.png","image/png",pdf().getBytes()),category)).isInstanceOf(BizException.class);
-    }
-
     /** 真实 PDF、JPG、PNG 均可写入并保持内容；上传不以扩展名代替 MIME 和签名。 */
     @ParameterizedTest
     @ValueSource(strings = {VEHICLE, DRIVER})
@@ -164,7 +149,7 @@ class DispatchEvidenceFileTest {
 
     /** 元数据和下载均逐列带全复合键；错车、错类别、错文件不得读取存储内容。 */
     @ParameterizedTest
-    @ValueSource(strings = {VEHICLE, DRIVER, PHOTO, EXCEPTION})
+    @ValueSource(strings = {VEHICLE, DRIVER})
     void metadataAndDownloadEnforceEveryScopeKeyBeforeReading(String type) throws Exception {
         var files = mock(FileObjectMapper.class);
         var storage = mock(BusinessFileStorage.class);

finance/AGENTS.md

@@ -23,7 +23,7 @@
 | 客户只读账单、收款与应收 API | `controller/ClientFinanceController.java`，统一前缀 `/api/client/finance/v1` |
 | 订单与客户账户、费用来源审核与结算纳入 | `controller/FinancePhase1OperationController.java`、`service/FinancePhase1OperationService.java` |
 | 客户财务账户汇总 | `service/FinanceCustomerAccountService.java`、`client/IamCustomerClient.java`；客户主档事实仍归 IAM |
-| 客户资金账户、授信与充值 | `controller/ClientFinanceWalletController.java`、`controller/PlatformFinanceWalletController.java`、`controller/InternalFinanceWalletController.java`、`service/FinanceWalletService.java`、`dto/FinanceWalletDtos.java`；支持静态收款码、截图申请、平台审核、手工充扣、授信配置及供业务模块使用的冻结/结算/释放；原消费关联退款契约见 `src/main/resources/openapi/finance-wallet-refund-v1.yaml`，第三方支付回调尚未接入 |
+| 客户资金账户、授信与充值 | `controller/ClientFinanceWalletController.java`、`controller/PlatformFinanceWalletController.java`、`controller/InternalFinanceWalletController.java`、`service/FinanceWalletService.java`、`dto/FinanceWalletDtos.java`；支持静态收款码、截图申请、平台审核、手工充扣、授信配置及供业务模块使用的冻结/结算/释放，第三方支付回调尚未接入 |
 | 客户对账单 | `controller/ReconciliationStatementController.java`、`service/ReconciliationStatementService.java` |
 | 应收款月度统计 | `controller/ReceivableStatisticsController.java`、`service/ReceivableStatisticsService.java`、`dto/ReceivableStatisticsDtos.java`；按结算单生成月份和客户汇总 CNY 正式应收结算单 |
 | 应收/应付结算单 | `controller/FinanceSettlementController.java`、`service/FinanceSettlementService.java` |

finance/src/main/java/com/baiyue/finance/controller/PlatformFinanceWalletController.java

@@ -7,16 +7,11 @@ import com.baiyue.finance.dto.FinanceWalletDtos.CreditLimitRequest;
 import com.baiyue.finance.dto.FinanceWalletDtos.RechargeReviewRequest;
 import com.baiyue.finance.dto.FinancePhase1Dtos.PageEnvelope;
 import com.baiyue.finance.dto.FinanceWalletDtos.RechargeRequest;
-import com.baiyue.finance.dto.FinanceWalletDtos.WalletRefundRequest;
 import com.baiyue.finance.service.FinanceWalletService;
-import java.nio.charset.StandardCharsets;
-import java.util.UUID;
-import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.security.core.annotation.AuthenticationPrincipal;
 import org.springframework.web.bind.annotation.*;
-import org.springframework.web.server.ResponseStatusException;
 
 @RestController
 @RequestMapping("/api/platform/finance/v1")
@@ -67,25 +62,4 @@ public class PlatformFinanceWalletController {
     @GetMapping("/recharge-requests/{requestId}/voucher")
     @PreAuthorize("hasAuthority('platform:finance:customer-account:list')")
     public ResponseEntity<byte[]> voucher(@PathVariable long requestId) { return service.voucher(requestId); }
-
-    /** 退款必须由平台财务针对原消费发起，复用资金服务的账户锁及累计可退上限。 */
-    @PostMapping("/accounts/{customerId}/ledger/{ledgerId}/refunds")
-    @PreAuthorize("hasAuthority('platform:finance:customer-account:adjust')")
-    public ApiResponse<?> refund(@AuthenticationPrincipal AuthenticatedUser user,
-                                 @PathVariable long customerId, @PathVariable long ledgerId,
-                                 @RequestHeader("Idempotency-Key") String idempotencyKey,
-                                 @RequestBody WalletRefundRequest request) {
-        if (user == null || user.userId() == null || !"PLATFORM".equals(user.appCode()) || !Long.valueOf(0L).equals(user.tenantId())) {
-            throw new ResponseStatusException(HttpStatus.FORBIDDEN, "仅平台财务可操作退款");
-        }
-        if (request == null || idempotencyKey == null || idempotencyKey.isBlank()
-            || idempotencyKey.trim().length() > 128) throw new IllegalArgumentException("退款请求及幂等键必填且幂等键不超过128字符");
-        if (request.reason() == null || request.reason().isBlank() || request.reason().length() > 500)
-            throw new IllegalArgumentException("退款原因必填且不超过500字符");
-        // 技术退款引用由客户和幂等键确定；资金流水号仍由正式 AC 编号生成器分配。
-        String refundNo = "MANUAL_REFUND:" + UUID.nameUUIDFromBytes(
-            (customerId + ":" + idempotencyKey.trim()).getBytes(StandardCharsets.UTF_8));
-        return FinanceResponses.success(service.refundConsumption(customerId, ledgerId, refundNo,
-            idempotencyKey.trim(), request.amount(), user.userId(), user.displayName(), request.reason().trim()));
-    }
 }

finance/src/main/java/com/baiyue/finance/dto/FinanceSettlementDtos.java

@@ -37,7 +37,7 @@ public final class FinanceSettlementDtos {
                                  BigDecimal quantity, BigDecimal unitPrice, BigDecimal amount, String currency,
                                  String reviewStatus, String sourceStatus,
                                  boolean statementGenerated) {}
-    public record SettlementTransaction(long transactionId, String transactionNo, String transactionType, LocalDate transactionDate,
+    public record SettlementTransaction(long transactionId, String transactionType, LocalDate transactionDate,
                                         BigDecimal amount, String method, String referenceNo,
                                         List<String> voucherFileIds, long createdBy, String createdByName,
                                         LocalDateTime createdAt,

finance/src/main/java/com/baiyue/finance/dto/FinanceWalletDtos.java

@@ -54,9 +54,6 @@ public final class FinanceWalletDtos {
 
     public record WalletHoldActionRequest(String remark) { }
 
-    /** 关联原消费退款，原因必填，原流水保持不可变。 */
-    public record WalletRefundRequest(BigDecimal amount, String reason) { }
-
     public record WalletHold(long holdId, long customerId, String businessType,
                              String businessNo, BigDecimal amount,
                              BigDecimal actualFrozenAmount, BigDecimal creditFrozenAmount,

finance/src/main/java/com/baiyue/finance/mapper/FinanceFeeSourceReadMapper.java

@@ -1,60 +0,0 @@
-package com.baiyue.finance.mapper;
-
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Param;
-import org.apache.ibatis.annotations.Select;
-import java.util.List;
-import java.util.Map;
-
-/** 费用池按稳定来源读取当前版本，历史快照保留在同一费用的操作记录中。 */
-@Mapper
-public interface FinanceFeeSourceReadMapper {
-    String GENERATED = "(EXISTS(SELECT 1 FROM fin_bill_line bl WHERE bl.source_id=f.id AND bl.source_version=f.source_fee_version))";
-    String STATUS = "CASE WHEN f.status='AVAILABLE' AND " + GENERATED + " THEN 'BILLED' ELSE f.status END";
-    String BUSINESS_DATE = "CAST(JSON_UNQUOTE(JSON_EXTRACT(f.source_snapshot,'$.businessDate')) AS DATE)";
-    String FILTER = " FROM fin_fee_source f WHERE 1=1 " +
-        "<if test=\"status == null or status != 'SUPERSEDED'\">" +
-        " AND f.status&lt;&gt;'SUPERSEDED' AND NOT EXISTS(SELECT 1 FROM fin_fee_source newer" +
-        " WHERE newer.source_system=f.source_system AND newer.source_type=f.source_type" +
-        " AND newer.source_fee_id=f.source_fee_id AND newer.source_fee_version&gt;f.source_fee_version)" +
-        "</if>" +
-        "<if test='customerId != null'> AND f.customer_id=#{customerId}</if>" +
-        "<if test='direction != null'> AND f.direction=#{direction}</if>" +
-        "<if test='reviewStatus != null'> AND f.review_status=#{reviewStatus}</if>" +
-        "<if test='status != null'> AND " + STATUS + "=#{status}</if>" +
-        "<if test='statementGenerated != null'> AND " + GENERATED + "=#{statementGenerated}</if>" +
-        "<if test='dateFrom != null'> AND " + BUSINESS_DATE + "&gt;=#{dateFrom}</if>" +
-        "<if test='dateTo != null'> AND " + BUSINESS_DATE + "&lt;=#{dateTo}</if>" +
-        "<if test='keyword != null'> AND (f.source_no LIKE CONCAT('%',#{keyword},'%')" +
-        " OR f.fee_item_name LIKE CONCAT('%',#{keyword},'%')" +
-        " OR JSON_UNQUOTE(JSON_EXTRACT(f.source_snapshot,'$.customerName')) LIKE CONCAT('%',#{keyword},'%')" +
-        " OR JSON_UNQUOTE(JSON_EXTRACT(f.source_snapshot,'$.inboundCode')) LIKE CONCAT('%',#{keyword},'%')" +
-        " OR JSON_UNQUOTE(JSON_EXTRACT(f.source_snapshot,'$.containerNo')) LIKE CONCAT('%',#{keyword},'%')" +
-        " OR JSON_UNQUOTE(JSON_EXTRACT(f.source_snapshot,'$.supplierName')) LIKE CONCAT('%',#{keyword},'%'))</if>";
-
-    /** 筛选和计数共用当前版本条件，不能先分页再去重。 */
-    @Select("<script>SELECT COUNT(*)" + FILTER + "</script>")
-    long count(Map<String, Object> filters);
-
-    /** 应收、应付分别展示当前快照；同名但来源费用号不同的费用不合并。 */
-    @Select("<script>SELECT f.*," + GENERATED + " statement_generated," + STATUS + " effective_status" + FILTER +
-        " ORDER BY " + BUSINESS_DATE + " DESC,f.id DESC LIMIT #{limit} OFFSET #{offset}</script>")
-    List<Map<String, Object>> list(Map<String, Object> filters);
-
-    String LINEAGE = " FROM fin_fee_source anchor JOIN fin_fee_source f ON f.source_system=anchor.source_system" +
-        " AND f.source_type=anchor.source_type AND f.source_fee_id=anchor.source_fee_id" +
-        " AND f.customer_id=anchor.customer_id AND f.direction=anchor.direction" +
-        " AND f.source_fee_version&lt;=anchor.source_fee_version";
-
-    /** 旧版本链接只读取当时及此前快照，不把后续调整倒灌到历史单据。 */
-    @Select("<script>SELECT f.id,f.source_fee_version,f.amount,f.currency_code,f.created_at" + LINEAGE +
-        " WHERE anchor.id=#{id} AND anchor.customer_id=#{customerId}" +
-        " AND f.source_system IN ('FIRSTLEG','LASTLEG') ORDER BY f.source_fee_version,f.id</script>")
-    List<Map<String, Object>> versions(@Param("customerId") long customerId, @Param("id") long id);
-
-    /** 按来源身份串起历次审核和操作，客户与方向边界不能被同名费用跨越。 */
-    @Select("<script>SELECT a.id,a.created_at,a.action,a.operator_name_snapshot,a.reason,a.before_data,a.after_data" + LINEAGE +
-        " JOIN fin_audit_log a ON a.tenant_id=f.customer_id AND a.resource_type='FIN_FEE_SOURCE' AND a.resource_id=f.id" +
-        " WHERE anchor.id=#{id} AND anchor.customer_id=#{customerId} ORDER BY a.created_at DESC,a.id DESC</script>")
-    List<Map<String, Object>> audits(@Param("customerId") long customerId, @Param("id") long id);
-}

finance/src/main/java/com/baiyue/finance/mapper/FinanceSettlementDetailMapper.java

@@ -1,43 +0,0 @@
-package com.baiyue.finance.mapper;
-
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Param;
-import org.apache.ibatis.annotations.Select;
-import java.util.List;
-import java.util.Map;
-
-/** 结算详情只读SQL；子查询均保留所属客户和原结算范围。 */
-@Mapper
-public interface FinanceSettlementDetailMapper {
-    String SUMMARY_SELECT =
-        "SELECT s.id,s.tenant_id,s.settlement_no,s.direction,s.customer_name_snapshot,s.supplier_id," +
-            "s.supplier_name_snapshot,s.reconciliation_statement_id,b.bill_no reconciliation_statement_no," +
-            "s.business_period,(SELECT GROUP_CONCAT(DISTINCT fs.fee_item_name ORDER BY fs.fee_item_name SEPARATOR '、') " +
-            "FROM fin_settlement_line sl JOIN fin_fee_source fs ON fs.id=sl.fee_source_id " +
-            "WHERE sl.tenant_id=s.tenant_id AND sl.settlement_id=s.id) fee_item_summary," +
-            "s.currency_code,s.total_amount,s.paid_amount,s.outstanding_amount,s.generated_date,s.due_date," +
-            "s.payment_status,s.status,s.created_by,(SELECT a.operator_name_snapshot FROM fin_audit_log a " +
-            "WHERE a.tenant_id=s.tenant_id AND a.resource_type='FIN_SETTLEMENT' AND a.resource_id=s.id " +
-            "AND a.action='CREATE' ORDER BY a.created_at,a.id LIMIT 1) created_by_name,s.created_at,s.updated_at," +
-            "CASE WHEN s.direction='RECEIVABLE' THEN (SELECT MAX(r.created_at) FROM fin_receipt_bill rb " +
-            "JOIN fin_receipt r ON r.id=rb.receipt_id AND r.tenant_id=rb.tenant_id " +
-            "WHERE rb.tenant_id=s.tenant_id AND rb.bill_id=s.reconciliation_statement_id AND r.status='CONFIRMED') " +
-            "ELSE (SELECT MAX(p.created_at) FROM fin_settlement_payment p WHERE p.tenant_id=s.tenant_id " +
-            "AND p.settlement_id=s.id) END last_payment_at,s.version FROM fin_settlement s " +
-            "LEFT JOIN fin_bill b ON b.tenant_id=s.tenant_id AND b.id=s.reconciliation_statement_id ";
-    /** 读取平台结算主单及来源摘要。 */
-    @Select(SUMMARY_SELECT + "WHERE s.id=#{settlementId}")
-    List<Map<String, Object>> summary(@Param("settlementId") long settlementId);
-    /** 读取该客户该结算的费用明细。 */
-    @Select("SELECT f.id fee_source_id,f.source_type,f.source_fee_id,f.source_fee_version,f.direction,f.customer_id,f.order_id,f.inbound_id,f.container_id,f.fee_item_name,f.amount,f.currency_code,f.review_status,f.status,f.source_snapshot FROM fin_settlement_line sl JOIN fin_fee_source f ON f.id=sl.fee_source_id WHERE sl.tenant_id=#{customerId} AND sl.settlement_id=#{settlementId} ORDER BY sl.id")
-    List<Map<String, Object>> lines(@Param("customerId") long customerId, @Param("settlementId") long settlementId);
-    /** 读取该客户付款流水及落库业务号，不能用ID替代。 */
-    @Select("SELECT id,transaction_no,transaction_type,transaction_date,amount,method,reference_no,voucher_file_ids,created_by,created_by_name,created_at,remark FROM fin_settlement_payment WHERE tenant_id=#{customerId} AND settlement_id=#{settlementId} ORDER BY created_at,id")
-    List<Map<String, Object>> payments(@Param("customerId") long customerId, @Param("settlementId") long settlementId);
-    /** 读取对账单已确认收款；收款凭证号不是PAY业务号。 */
-    @Select("SELECT r.id,'RECEIPT' transaction_type,DATE(r.received_at) transaction_date,rb.applied_amount amount,r.payment_method method,r.voucher_no reference_no,r.voucher_file_ids,r.created_by,r.created_by_name,r.created_at,r.remark FROM fin_receipt_bill rb JOIN fin_receipt r ON r.id=rb.receipt_id AND r.tenant_id=rb.tenant_id WHERE rb.tenant_id=#{customerId} AND rb.bill_id=#{statementId} AND r.status='CONFIRMED' ORDER BY r.created_at,r.id")
-    List<Map<String, Object>> receipts(@Param("customerId") long customerId, @Param("statementId") long statementId);
-    /** 读取该客户结算修订历史。 */
-    @Select("SELECT action,reason,before_data,after_data,operator_id,operator_name_snapshot,created_at FROM fin_audit_log WHERE tenant_id=#{customerId} AND resource_type='FIN_SETTLEMENT' AND resource_id=#{settlementId} ORDER BY created_at,id")
-    List<Map<String, Object>> audits(@Param("customerId") long customerId, @Param("settlementId") long settlementId);
-}

finance/src/main/java/com/baiyue/finance/repository/FinanceFeeSourceReadRepository.java

@@ -1,145 +0,0 @@
-package com.baiyue.finance.repository;
-
-import com.baiyue.finance.dto.FinancePhase1Dtos.FeeSourceSummary;
-import com.baiyue.finance.dto.FinancePhase1Dtos.OperationLog;
-import com.baiyue.finance.mapper.FinanceFeeSourceReadMapper;
-import com.baiyue.finance.service.FinanceEventException;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.springframework.stereotype.Repository;
-import org.springframework.util.LinkedCaseInsensitiveMap;
-
-import java.math.BigDecimal;
-import java.math.RoundingMode;
-import java.sql.Timestamp;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/** 费用当前投影及操作历史；版本记录只读，不覆盖账单引用的不可变快照。 */
-@Repository
-public class FinanceFeeSourceReadRepository {
-    private final FinanceFeeSourceReadMapper mapper;
-    private final ObjectMapper json;
-
-    /** 注入正式持久化入口与费用快照解析器。 */
-    public FinanceFeeSourceReadRepository(FinanceFeeSourceReadMapper mapper, ObjectMapper json) {
-        this.mapper = mapper;
-        this.json = json;
-    }
-
-    /** 组装统一查询参数，让计数和分页使用相同来源身份与筛选条件。 */
-    public Map<String, Object> filters(Long customerId, String direction, String status, String reviewStatus,
-                                      Boolean generated, LocalDate from, LocalDate to, String keyword, int page, int size) {
-        Map<String, Object> values = new HashMap<>();
-        values.put("customerId", customerId); values.put("direction", direction); values.put("status", status);
-        values.put("reviewStatus", reviewStatus); values.put("statementGenerated", generated);
-        values.put("dateFrom", from); values.put("dateTo", to); values.put("keyword", keyword);
-        values.put("limit", size); values.put("offset", (page - 1) * size);
-        return values;
-    }
-
-    /** 计数只包含所筛选的当前费用，历史状态专项查询除外。 */
-    public long count(Map<String, Object> filters) { return mapper.count(filters); }
-
-    /** 当前费用映射沿用原币、数量、客户等正式字段。 */
-    public List<FeeSourceSummary> list(Map<String, Object> filters) {
-        return mapper.list(filters).stream().map(this::summary).toList();
-    }
-
-    /** 由不可变版本追加同步历史，并串联同一费用所有既有审计记录。 */
-    public List<OperationLog> logs(long customerId, long id) {
-        List<OperationLog> result = new ArrayList<>();
-        Map<String, Object> previous = null;
-        for (Map<String, Object> raw : mapper.versions(customerId, id)) {
-            Map<String, Object> row = row(raw);
-            String version = "来源版本 " + row.get("source_fee_version");
-            String amount = amount(row) + " " + row.get("currency_code");
-            // 同步时间与原业务操作者不能混用，原业务审批仍以来源系统记录为准。
-            result.add(new OperationLog(time(row.get("created_at")),
-                previous == null ? "FEE_SOURCE_PUBLISHED" : "FEE_SOURCE_VERSION_ADJUST",
-                "系统同步", "SUCCESS", previous == null ? version + "；金额 " + amount
-                    : "来源版本 " + previous.get("source_fee_version") + " → " + row.get("source_fee_version")
-                        + "；金额 " + amount(previous) + " → " + amount));
-            previous = row;
-        }
-        // 金额差分仍按版本升序计算；展示先反转版本，同毫秒时稳定排序保留新版本在前。
-        java.util.Collections.reverse(result);
-        for (Map<String, Object> raw : mapper.audits(customerId, id)) {
-            Map<String, Object> row = row(raw);
-            String remark = text(row.get("reason"));
-            JsonNode before = parse(row.get("before_data"));
-            JsonNode after = parse(row.get("after_data"));
-            if (before.hasNonNull("amount") && after.hasNonNull("amount")
-                && before.path("amount").decimalValue().compareTo(after.path("amount").decimalValue()) != 0) {
-                remark = (remark == null ? "" : remark + "；") + "金额 " + before.path("amount").asText()
-                    + " → " + after.path("amount").asText() + " " + after.path("currency").asText("CNY");
-            }
-            result.add(new OperationLog(time(row.get("created_at")), text(row.get("action")),
-                text(row.get("operator_name_snapshot")), "SUCCESS", remark));
-        }
-        // 时间排序保持同毫秒版本的新到旧顺序，以及 Mapper 返回的审计 ID 倒序。
-        result.sort(Comparator.comparing(OperationLog::occurredAt, Comparator.nullsLast(Comparator.reverseOrder())));
-        return List.copyOf(result);
-    }
-
-    /** 将持久化快照转换为费用列表 DTO，不从其他客户或来源补齐业务事实。 */
-    private FeeSourceSummary summary(Map<String, Object> raw) {
-        Map<String, Object> row = row(raw);
-        JsonNode snapshot = parse(row.get("source_snapshot"));
-        BigDecimal amount = decimal(row.get("amount"));
-        BigDecimal originalAmount = first(decimal(text(snapshot, "originalAmount")), amount);
-        BigDecimal quantity = decimal(text(snapshot, "chargeableQuantity"));
-        BigDecimal unitPrice = first(decimal(text(snapshot, "unitPrice")), quantity != null && quantity.signum() > 0
-            ? originalAmount.divide(quantity, 6, RoundingMode.HALF_UP) : null);
-        return new FeeSourceSummary(number(row.get("id")), text(row.get("source_system")), text(row.get("source_type")),
-            first(text(row.get("source_no")), text(snapshot, "sourceBusinessId")), number(row.get("source_fee_id")),
-            ((Number) row.get("source_fee_version")).intValue(), text(row.get("direction")), number(row.get("customer_id")),
-            text(snapshot, "customerName"), positiveLong(text(snapshot, "supplierId")), text(snapshot, "supplierName"),
-            nullableLong(row.get("order_id")), nullableLong(row.get("inbound_id")), text(snapshot, "inboundCode"),
-            nullableLong(row.get("container_id")), text(snapshot, "containerNo"),
-            first(date(text(snapshot, "businessDate")), LocalDate.of(1970, 1, 1)), text(row.get("fee_item_name")),
-            quantity, text(snapshot, "quantityUnit"), unitPrice, date(text(snapshot, "periodStart")), date(text(snapshot, "periodEnd")),
-            amount, text(row.get("currency_code")), first(text(snapshot, "originalCurrency"), text(row.get("currency_code"))),
-            originalAmount, first(decimal(text(snapshot, "exchangeRate")), BigDecimal.ONE), text(snapshot, "exchangeRateMonth"),
-            first(text(row.get("review_status")), "DRAFT"), text(row.get("effective_status")),
-            Boolean.TRUE.equals(row.get("statement_generated")) || row.get("statement_generated") instanceof Number value && value.intValue() != 0);
-    }
-
-    /** 保留不同数据库驱动的列名大小写读取语义。 */
-    private static Map<String, Object> row(Map<String, Object> source) {
-        Map<String, Object> result = new LinkedCaseInsensitiveMap<>(); result.putAll(source); return result;
-    }
-    /** 解析不可变快照，损坏数据失败关闭。 */
-    private JsonNode parse(Object value) {
-        try { return value == null ? json.createObjectNode() : json.readTree(value.toString()); }
-        catch (Exception failure) { throw new FinanceEventException("FIN-DATA-500", "费用来源快照损坏"); }
-    }
-    /** 格式化记录金额，保留定点精度。 */
-    private static String amount(Map<String, Object> row) { return decimal(row.get("amount")).toPlainString(); }
-    /** 读取驱动返回的标准时间。 */
-    private static LocalDateTime time(Object value) { return value instanceof Timestamp time ? time.toLocalDateTime() : (LocalDateTime) value; }
-    /** 读取数字主键，仅用于数据引用。 */
-    private static long number(Object value) { return ((Number) value).longValue(); }
-    /** 保留未关联的可空引用。 */
-    private static Long nullableLong(Object value) { return value == null ? null : number(value); }
-    /** 只接受合法的正整型供应商引用。 */
-    private static Long positiveLong(String value) {
-        try { long parsed = Long.parseLong(value); return parsed > 0 ? parsed : null; }
-        catch (NumberFormatException failure) { return null; }
-    }
-    /** 读取可空金额，不经过浮点转换。 */
-    private static BigDecimal decimal(Object value) { return value == null ? null : new BigDecimal(value.toString()); }
-    /** 读取可空业务日期。 */
-    private static LocalDate date(String value) { return value == null ? null : LocalDate.parse(value); }
-    /** 保持空字段的缺失语义。 */
-    private static String text(Object value) { return value == null || value.toString().isBlank() ? null : value.toString(); }
-    /** 读取快照字段。 */
-    private static String text(JsonNode node, String field) { return node.path(field).isNull() || node.path(field).isMissingNode() ? null : text(node.path(field).asText()); }
-    /** 优先使用来源字段，其次使用已有正式默认值。 */
-    private static <T> T first(T value, T fallback) { return value == null ? fallback : value; }
-}

finance/src/main/java/com/baiyue/finance/repository/FinanceSettlementDetailRepository.java

@@ -1,29 +0,0 @@
-package com.baiyue.finance.repository;
-
-import com.baiyue.finance.mapper.FinanceSettlementDetailMapper;
-import org.springframework.stereotype.Repository;
-import org.springframework.util.LinkedCaseInsensitiveMap;
-import java.util.List;
-import java.util.Map;
-
-/** 结算详情查询封装，列名大小写差异不改变已有字段映射语义。 */
-@Repository
-public class FinanceSettlementDetailRepository {
-    private final FinanceSettlementDetailMapper mapper;
-    /** 注入结算详情持久化入口。 */
-    public FinanceSettlementDetailRepository(FinanceSettlementDetailMapper mapper) { this.mapper = mapper; }
-    /** 保留原数据库列名不区分大小写的读取语义。 */
-    private List<Map<String, Object>> rows(List<Map<String, Object>> rows) {
-        return rows.stream().map(row -> { Map<String, Object> copy = new LinkedCaseInsensitiveMap<>(); copy.putAll(row); return copy; }).toList();
-    }
-    /** 读取平台结算主单及来源摘要。 */
-    public List<Map<String, Object>> summary(long settlementId) { return rows(mapper.summary(settlementId)); }
-    /** 读取该客户该结算的费用明细。 */
-    public List<Map<String, Object>> lines(long customerId, long settlementId) { return rows(mapper.lines(customerId, settlementId)); }
-    /** 读取该客户付款流水及落库业务号，不能用ID替代。 */
-    public List<Map<String, Object>> payments(long customerId, long settlementId) { return rows(mapper.payments(customerId, settlementId)); }
-    /** 读取对账单已确认收款；收款凭证号不是PAY业务号。 */
-    public List<Map<String, Object>> receipts(long customerId, long statementId) { return rows(mapper.receipts(customerId, statementId)); }
-    /** 读取该客户结算修订历史。 */
-    public List<Map<String, Object>> audits(long customerId, long settlementId) { return rows(mapper.audits(customerId, settlementId)); }
-}

finance/src/main/java/com/baiyue/finance/service/BusinessFeeSourceEventService.java

@@ -135,7 +135,6 @@ public class BusinessFeeSourceEventService {
             positive(value.walletSettlement().holdId(), "walletSettlement.holdId");
             positive(value.walletSettlement().ledgerId(), "walletSettlement.ledgerId");
             if (blank(value.walletSettlement().commandEventId())) throw error("FIN-EVT-012", "缺少原资金命令引用");
-            walletIdentity(value);
         } else if ("OVERSEAS_PROCUREMENT_FEE".equals(value.sourceType()) && "RECEIVABLE".equals(value.direction())) {
             throw error("FIN-EVT-012", "采购应收必须引用成功实扣资金，不能进入待收费池");
         }
@@ -155,7 +154,7 @@ public class BusinessFeeSourceEventService {
                 throw error("FIN-EVT-012", "应付来源供应商快照不一致");
             validateSettlement(value);
         } else if (!blank(value.supplierId()) || !blank(value.supplierName()) || !blank(value.supplierCategory())
-            || value.settlementMode() != null && !Set.of("BILL", "WALLET").contains(value.settlementMode()) || value.paidAt() != null
+            || !blank(value.settlementMode()) || value.paidAt() != null
             || !blank(value.paymentMethod()) || !blank(value.paymentReferenceNo())
             || (value.paymentVoucherFileIds() != null && !value.paymentVoucherFileIds().isEmpty())) {
             throw error("FIN-EVT-012", "应收来源不得携带供应商或付款事实");
@@ -203,10 +202,9 @@ public class BusinessFeeSourceEventService {
             long customerId = positive(source.customerId(), "customerId");
             long holdId = positive(reference.holdId(), "holdId");
             long ledgerId = positive(reference.ledgerId(), "ledgerId");
-            String[] identity = walletIdentity(source);
             List<Map<String, Object>> rows = jdbc.queryForList(
                 "SELECT l.amount,c.result_json FROM fin_wallet_hold h JOIN fin_wallet_ledger l ON l.id=h.action_ledger_id AND l.customer_id=h.customer_id JOIN fin_wallet_command_inbox c ON c.event_id=? AND c.status='SUCCEEDED' WHERE h.id=? AND l.id=? AND h.customer_id=? AND h.business_type=? AND h.business_no=? AND h.status='SETTLED' AND l.change_type='CONSUMPTION' FOR UPDATE",
-                reference.commandEventId(), holdId, ledgerId, customerId, identity[0], identity[1]);
+                reference.commandEventId(), holdId, ledgerId, customerId, source.businessType(), source.businessNo());
             if (rows.size() != 1 || !(rows.get(0).get("amount") instanceof java.math.BigDecimal amount)
                 || amount.negate().compareTo(source.totalAmount()) != 0) {
                 throw error("FIN-EVT-017", "费用来源与成功扣款的客户、业务或金额不匹配");
@@ -220,8 +218,8 @@ public class BusinessFeeSourceEventService {
                 || !reference.holdId().equals(result.path("walletHoldId").asText())
                 || !reference.ledgerId().equals(result.path("walletLedgerId").asText())
                 || result.path("customerId").asLong() != customerId
-                || !identity[0].equals(result.path("businessType").asText())
+                || !source.businessType().equals(result.path("businessType").asText())
-                || !identity[1].equals(result.path("businessNo").asText())
+                || !source.businessNo().equals(result.path("businessNo").asText())
                 || result.path("amount").decimalValue().compareTo(source.totalAmount()) != 0) {
                 throw error("FIN-EVT-017", "费用来源引用的资金结果不匹配");
             }
@@ -236,25 +234,6 @@ public class BusinessFeeSourceEventService {
             feeSourceId);
     }
 
-    /** 独立锁款仅接收已约定的人工费用或仓租身份，不能借此挂接任意业务扣款。 */
-    private String[] walletIdentity(BusinessFeeSourceChangedV1 source) {
-        var reference = source.walletSettlement();
-        String type = reference.walletBusinessType(), no = reference.walletBusinessNo();
-        if (type == null && no == null) return new String[]{source.businessType(), source.businessNo()};
-        if (blank(type) || blank(no) || !"LASTLEG".equals(source.sourceSystem()))
-            throw error("FIN-EVT-017", "资金业务引用不完整");
-        if ("OVERSEAS_MANUAL_FEE".equals(type)) {
-            if ("FEE_TYPE_077".equals(source.feeItemCode())
-                || !no.matches(java.util.regex.Pattern.quote(source.sourceFeeId()) + "-[1-9][0-9]*"))
-                throw error("FIN-EVT-017", "人工费用资金引用与来源不匹配");
-        } else if ("STORAGE_RENT".equals(type)) {
-            if (!"FEE_TYPE_077".equals(source.feeItemCode()))
-                throw error("FIN-EVT-017", "仓租资金引用与费用项目不匹配");
-            positive(no, "walletBusinessNo");
-        } else throw error("FIN-EVT-017", "不支持的独立资金业务引用");
-        return new String[]{type, no};
-    }
-
     private void materializeDirectPaidCost(String system, long feeId, BusinessFeeSourceChangedV1 value) {
         jdbc.update("INSERT INTO fin_cost(tenant_id,cost_no,cost_type,cost_origin,source_system,source_type,source_fee_id,source_fee_version,source_hash,order_id,inbound_id,container_id,warehouse_id,supplier_id,supplier_name_snapshot,fee_item_code,fee_item_name,currency_code,cost_amount,voucher_file_ids,paid_at,payment_method,payment_reference_no,status,confirmed_at,created_by,created_by_name,updated_by) VALUES(?,?,'SOURCE_DIRECT_PAID','BUSINESS_DIRECT_PAID',?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,'CONFIRMED',CURRENT_TIMESTAMP(3),0,'系统',0)",
             positive(value.customerId(), "customerId"), "DIRECT-" + system + '-' + value.sourceType() + '-' + feeId + "-V" + value.sourceVersion(),

finance/src/main/java/com/baiyue/finance/service/FinancePhase1OperationService.java

@@ -1,10 +1,10 @@
 package com.baiyue.finance.service;
 
-import com.baiyue.finance.repository.FinanceFeeSourceReadRepository;
 import com.baiyue.finance.dto.FinancePhase1Dtos.AccountSummary;
 import com.baiyue.finance.dto.FinancePhase1Dtos.FeeSourceDetail;
 import com.baiyue.finance.dto.FinancePhase1Dtos.FeeSourceSummary;
 import com.baiyue.finance.dto.FinancePhase1Dtos.LedgerEntry;
+import com.baiyue.finance.dto.FinancePhase1Dtos.OperationLog;
 import com.baiyue.finance.dto.FinancePhase1Dtos.PageEnvelope;
 import com.baiyue.finance.dto.FinancePhase1Dtos.ReviewRequest;
 import com.baiyue.finance.dto.FinancePhase1Dtos.FeeSourceActionRequest;
@@ -12,7 +12,6 @@ import com.baiyue.finance.dto.FinancePhase1Dtos.FeeSourceEditRequest;
 import com.baiyue.finance.client.FirstlegFeeSourceClient;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
 import feign.FeignException;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
@@ -44,19 +43,19 @@ public class FinancePhase1OperationService {
     private final ObjectMapper objectMapper;
     private final FirstlegFeeSourceClient firstleg;
     private final String internalToken;
-    private final FinanceFeeSourceReadRepository feeSources;
 
-    /** 注入费用来源查询及现有业务依赖。 */
     @Autowired
     public FinancePhase1OperationService(JdbcTemplate jdbc, ObjectMapper objectMapper,
                                          FirstlegFeeSourceClient firstleg,
-                                         @Value("${baiyue.security.internal-service-token}") String internalToken,
+                                         @Value("${baiyue.security.internal-service-token}") String internalToken) {
-                                         FinanceFeeSourceReadRepository feeSources) {
         this.jdbc = jdbc;
         this.objectMapper = objectMapper;
         this.firstleg = firstleg;
         this.internalToken = internalToken;
-        this.feeSources = feeSources;
+    }
+
+    public FinancePhase1OperationService(JdbcTemplate jdbc, ObjectMapper objectMapper) {
+        this(jdbc, objectMapper, null, "");
     }
 
     public PageEnvelope<AccountSummary> listDerivedCustomerAccounts(int page, int pageSize, String customerName, String status) {
@@ -163,7 +162,6 @@ public class FinancePhase1OperationService {
         return PageEnvelope.success(List.copyOf(projected.subList(from, to)), page, pageSize, projected.size());
     }
 
-    /** 按同一来源费用的当前版本分页，调整历史不重复计入客户应收应付。 */
     public PageEnvelope<FeeSourceSummary> listFinanceFeeSources(int page, int pageSize, Long customerId,
                                                                  String direction, String sourceStatus,
                                                                  String reviewStatus,
@@ -179,9 +177,34 @@ public class FinancePhase1OperationService {
             List.of("DRAFT", "PENDING", "APPROVED", "REJECTED"), "审核状态无效");
         String normalizedSourceStatus = normalized(sourceStatus,
             List.of("AVAILABLE", "LOCKED", "BILLED", "SETTLED", "VOIDED", "SUPERSEDED"), "费用来源状态无效");
-        Map<String, Object> filters = feeSources.filters(customerId, normalizedDirection, normalizedSourceStatus,
+        String generatedSql = "EXISTS(SELECT 1 FROM fin_bill_line bl WHERE bl.source_id=f.id AND bl.source_version=f.source_fee_version)";
-            normalizedReview, statementGenerated, businessDateFrom, businessDateTo, blankToNull(keyword), page, pageSize);
+        String effectiveStatusSql = "CASE WHEN f.status='AVAILABLE' AND " + generatedSql + " THEN 'BILLED' ELSE f.status END";
-        return PageEnvelope.success(feeSources.list(filters), page, pageSize, feeSources.count(filters));
+        String businessDateSql = "STR_TO_DATE(JSON_UNQUOTE(JSON_EXTRACT(f.source_snapshot,'$.businessDate')),'%Y-%m-%d')";
+        StringBuilder where = new StringBuilder(" FROM fin_fee_source f WHERE 1=1");
+        List<Object> args = new ArrayList<>();
+        if (customerId != null) { where.append(" AND f.customer_id=?"); args.add(customerId); }
+        if (normalizedDirection != null) { where.append(" AND f.direction=?"); args.add(normalizedDirection); }
+        if (normalizedReview != null) { where.append(" AND f.review_status=?"); args.add(normalizedReview); }
+        if (normalizedSourceStatus != null) { where.append(" AND ").append(effectiveStatusSql).append("=?"); args.add(normalizedSourceStatus); }
+        if (statementGenerated != null) { where.append(" AND ").append(generatedSql).append("=?"); args.add(statementGenerated); }
+        if (businessDateFrom != null) { where.append(" AND ").append(businessDateSql).append(">=?"); args.add(businessDateFrom); }
+        if (businessDateTo != null) { where.append(" AND ").append(businessDateSql).append("<=?"); args.add(businessDateTo); }
+        String normalizedKeyword = blankToNull(keyword);
+        if (normalizedKeyword != null) {
+            where.append(" AND (f.source_no LIKE CONCAT('%',?,'%') OR f.fee_item_name LIKE CONCAT('%',?,'%')")
+                .append(" OR JSON_UNQUOTE(JSON_EXTRACT(f.source_snapshot,'$.customerName')) LIKE CONCAT('%',?,'%')")
+                .append(" OR JSON_UNQUOTE(JSON_EXTRACT(f.source_snapshot,'$.inboundCode')) LIKE CONCAT('%',?,'%')")
+                .append(" OR JSON_UNQUOTE(JSON_EXTRACT(f.source_snapshot,'$.containerNo')) LIKE CONCAT('%',?,'%')")
+                .append(" OR JSON_UNQUOTE(JSON_EXTRACT(f.source_snapshot,'$.supplierName')) LIKE CONCAT('%',?,'%'))");
+            for (int i = 0; i < 6; i++) args.add(normalizedKeyword);
+        }
+        Long total = jdbc.queryForObject("SELECT COUNT(*)" + where, Long.class, args.toArray());
+        List<Object> queryArgs = new ArrayList<>(args);
+        queryArgs.add(pageSize); queryArgs.add((page - 1) * pageSize);
+        String select = "SELECT f.*," + generatedSql + " statement_generated," + effectiveStatusSql + " effective_status" +
+            where + " ORDER BY " + businessDateSql + " DESC,f.id DESC LIMIT ? OFFSET ?";
+        List<FeeSourceSummary> rows = jdbc.query(select, (rs, n) -> summary(rs), queryArgs.toArray());
+        return PageEnvelope.success(rows, page, pageSize, total == null ? 0 : total);
     }
 
     public FeeSourceDetail getFinanceFeeSource(long feeSourceId) {
@@ -315,7 +338,6 @@ public class FinancePhase1OperationService {
         return after;
     }
 
-    /** 读取指定不可变版本，并附带同客户同方向的费用调整历史。 */
     private FeeSourceDetail detail(ResultSet rs) throws SQLException {
         JsonNode snapshot = parse(rs.getString("source_snapshot"));
         long id = rs.getLong("id");
@@ -333,7 +355,33 @@ public class FinancePhase1OperationService {
             amount, rs.getString("currency_code"), firstText(text(snapshot, "originalCurrency"), rs.getString("currency_code")), originalAmount,
             firstDecimal(decimal(snapshot, "exchangeRate"), BigDecimal.ONE), text(snapshot, "exchangeRateMonth"),
             defaultString(rs.getString("review_status"), "DRAFT"), status, generated,
-            rs.getString("review_reason"), rs.getString("source_hash"), rs.getInt("operation_version"), feeSources.logs(rs.getLong("customer_id"), id));
+            rs.getString("review_reason"), rs.getString("source_hash"), rs.getInt("operation_version"), logs(rs.getLong("customer_id"), id));
+    }
+
+    private FeeSourceSummary summary(ResultSet rs) throws SQLException {
+        JsonNode snapshot = parse(rs.getString("source_snapshot"));
+        boolean generated = rs.getBoolean("statement_generated");
+        BigDecimal quantity = decimal(snapshot, "chargeableQuantity");
+        BigDecimal amount = money(rs, "amount");
+        BigDecimal originalAmount = firstDecimal(decimal(snapshot, "originalAmount"), amount);
+        BigDecimal unitPrice = firstDecimal(decimal(snapshot, "unitPrice"), quantity != null && quantity.signum() > 0
+            ? originalAmount.divide(quantity, 6, java.math.RoundingMode.HALF_UP) : null);
+        return new FeeSourceSummary(rs.getLong("id"), rs.getString("source_system"), rs.getString("source_type"),
+            firstText(rs.getString("source_no"), text(snapshot, "sourceBusinessId")), rs.getLong("source_fee_id"), rs.getInt("source_fee_version"),
+            rs.getString("direction"), rs.getLong("customer_id"), text(snapshot, "customerName"),
+            jsonLong(snapshot, "supplierId"), text(snapshot, "supplierName"), nullableLong(rs, "order_id"),
+            nullableLong(rs, "inbound_id"), text(snapshot, "inboundCode"), nullableLong(rs, "container_id"),
+            text(snapshot, "containerNo"), date(snapshot, "businessDate"), rs.getString("fee_item_name"),
+            quantity, text(snapshot, "quantityUnit"), unitPrice, nullableDate(snapshot, "periodStart"), nullableDate(snapshot, "periodEnd"),
+            amount, rs.getString("currency_code"), firstText(text(snapshot, "originalCurrency"), rs.getString("currency_code")), originalAmount,
+            firstDecimal(decimal(snapshot, "exchangeRate"), BigDecimal.ONE), text(snapshot, "exchangeRateMonth"),
+            defaultString(rs.getString("review_status"), "DRAFT"),
+            rs.getString("effective_status"), generated);
+    }
+
+    private List<OperationLog> logs(long customerId, long id) {
+        return jdbc.query("SELECT created_at,action,operator_name_snapshot,reason FROM fin_audit_log WHERE tenant_id=? AND resource_type='FIN_FEE_SOURCE' AND resource_id=? ORDER BY created_at DESC,id DESC", (rs, n) ->
+            new OperationLog(time(rs, "created_at"), rs.getString("action"), rs.getString("operator_name_snapshot"), "SUCCESS", rs.getString("reason")), customerId, id);
     }
 
     private Long reserve(long customerId, long operatorId, String operation, String key, String method, String path, Object body) {
@@ -389,14 +437,7 @@ public class FinancePhase1OperationService {
     private static Long nullableLong(ResultSet rs, String column) throws SQLException { long value = rs.getLong(column); return rs.wasNull() ? null : value; }
     private JsonNode parse(String json) { try { return objectMapper.readTree(json); } catch (Exception e) { throw error("FIN-DATA-500", "费用来源快照损坏"); } }
     private String json(Object value) { try { return objectMapper.writeValueAsString(value); } catch (Exception e) { throw error("FIN-DATA-500", "财务数据序列化失败"); } }
-    /** 固定映射键序，使同一请求在服务重启前后使用相同摘要。 */
+    private String hash(Object value) { try { return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(json(value).getBytes(StandardCharsets.UTF_8))); } catch (Exception e) { throw error("FIN-DATA-500", "幂等请求哈希失败"); } }
-    private String hash(Object value) {
-        try {
-            byte[] canonical = objectMapper.writer().with(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS)
-                .writeValueAsBytes(value);
-            return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(canonical));
-        } catch (Exception failure) { throw error("FIN-DATA-500", "幂等请求哈希失败"); }
-    }
     private static String text(JsonNode node, String field) { JsonNode value = node.path(field); return value.isMissingNode() || value.isNull() ? null : value.asText(); }
     private static Long jsonLong(JsonNode node, String field) {
         JsonNode value = node.path(field);

finance/src/main/java/com/baiyue/finance/service/FinanceQueryService.java

@@ -219,7 +219,6 @@ public class FinanceQueryService {
             row.outstandingAmount(), row.currency(), row.status(), row.version())).toList();
     }
 
-    /** 成本查询按来源付款事实回显金额，直接已付不能再次展示为待付款。 */
     public List<PayableSettlement> payableSettlements(Long customerId) {
         validateOptionalCustomer(customerId);
         String sql = "SELECT id,tenant_id,cost_no,cost_type,order_id,inbound_id,container_id,supplier_name_snapshot,fee_item_name,cost_amount,currency_code,status,created_at,version FROM fin_cost WHERE 1=1";
@@ -228,13 +227,9 @@ public class FinanceQueryService {
         return jdbc.query(sql + " ORDER BY created_at DESC,id DESC",
             (rs, rowNum) -> {
                 BigDecimal amount = rs.getBigDecimal("cost_amount");
-                boolean directPaid = "SOURCE_DIRECT_PAID".equals(rs.getString("cost_type"));
-                // 已确认直付成本已全额付款；作废历史不再计入有效已付，也不形成新应付。
-                BigDecimal paid = directPaid && "CONFIRMED".equals(rs.getString("status")) ? amount : BigDecimal.ZERO;
-                BigDecimal outstanding = directPaid ? BigDecimal.ZERO : amount;
                 return new PayableSettlement(rs.getLong("id"), rs.getLong("tenant_id"), rs.getString("cost_no"), rs.getString("cost_type"),
                     nullableLong(rs, "order_id"), nullableLong(rs, "inbound_id"), nullableLong(rs, "container_id"), rs.getString("supplier_name_snapshot"),
-                    rs.getString("fee_item_name"), amount, paid, outstanding, rs.getString("currency_code"), rs.getString("status"),
+                    rs.getString("fee_item_name"), amount, BigDecimal.ZERO, amount, rs.getString("currency_code"), rs.getString("status"),
                     time(rs, "created_at"), rs.getInt("version"));
             }, args);
     }

finance/src/main/java/com/baiyue/finance/service/FinanceService.java

@@ -4,7 +4,6 @@ import com.baiyue.common.core.api.ResultCode;
 import com.baiyue.common.core.exception.BizException;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.support.GeneratedKeyHolder;
 import org.springframework.jdbc.support.KeyHolder;
@@ -307,14 +306,7 @@ public class FinanceService {
             default -> throw new IllegalArgumentException("未知财务幂等操作: " + operation);
         };
     }
-    /** 固定请求映射键序，避免服务重启后拒绝同一财务命令。 */
+    private String hash(Object request) { try { byte[] bytes = java.security.MessageDigest.getInstance("SHA-256").digest(json(request).getBytes(java.nio.charset.StandardCharsets.UTF_8)); return java.util.HexFormat.of().formatHex(bytes); } catch (Exception ex) { throw new IllegalStateException("请求哈希失败", ex); } }
-    private String hash(Object request) {
-        try {
-            byte[] canonical = objectMapper.writer().with(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS)
-                .writeValueAsBytes(request == null ? List.of() : request);
-            return java.util.HexFormat.of().formatHex(java.security.MessageDigest.getInstance("SHA-256").digest(canonical));
-        } catch (Exception ex) { throw new IllegalStateException("请求哈希失败", ex); }
-    }
 
     private static void requireCustomer(long tenantId) { if (tenantId <= 0) throw bad("客户范围无效"); }
     private static BizException bad(String message) { return new BizException(ResultCode.BAD_REQUEST, message); }

finance/src/main/java/com/baiyue/finance/service/FinanceSettlementService.java

@@ -12,7 +12,6 @@ import com.baiyue.finance.dto.FinanceSettlementDtos.SettlementActionRequest;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
 import org.slf4j.MDC;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.support.GeneratedKeyHolder;
@@ -45,9 +44,23 @@ import java.util.UUID;
 public class FinanceSettlementService {
     private static final String CNY = "CNY";
     private static final Set<String> PAYMENT_METHODS = Set.of("BANK_TRANSFER", "CASH", "OTHER");
-    private static final String SETTLEMENT_SUMMARY_SELECT = com.baiyue.finance.mapper.FinanceSettlementDetailMapper.SUMMARY_SELECT;
+    private static final String SETTLEMENT_SUMMARY_SELECT =
+        "SELECT s.id,s.tenant_id,s.settlement_no,s.direction,s.customer_name_snapshot,s.supplier_id," +
+            "s.supplier_name_snapshot,s.reconciliation_statement_id,b.bill_no reconciliation_statement_no," +
+            "s.business_period,(SELECT GROUP_CONCAT(DISTINCT fs.fee_item_name ORDER BY fs.fee_item_name SEPARATOR '、') " +
+            "FROM fin_settlement_line sl JOIN fin_fee_source fs ON fs.id=sl.fee_source_id " +
+            "WHERE sl.tenant_id=s.tenant_id AND sl.settlement_id=s.id) fee_item_summary," +
+            "s.currency_code,s.total_amount,s.paid_amount,s.outstanding_amount,s.generated_date,s.due_date," +
+            "s.payment_status,s.status,s.created_by,(SELECT a.operator_name_snapshot FROM fin_audit_log a " +
+            "WHERE a.tenant_id=s.tenant_id AND a.resource_type='FIN_SETTLEMENT' AND a.resource_id=s.id " +
+            "AND a.action='CREATE' ORDER BY a.created_at,a.id LIMIT 1) created_by_name,s.created_at,s.updated_at," +
+            "CASE WHEN s.direction='RECEIVABLE' THEN (SELECT MAX(r.created_at) FROM fin_receipt_bill rb " +
+            "JOIN fin_receipt r ON r.id=rb.receipt_id AND r.tenant_id=rb.tenant_id " +
+            "WHERE rb.tenant_id=s.tenant_id AND rb.bill_id=s.reconciliation_statement_id AND r.status='CONFIRMED') " +
+            "ELSE (SELECT MAX(p.created_at) FROM fin_settlement_payment p WHERE p.tenant_id=s.tenant_id " +
+            "AND p.settlement_id=s.id) END last_payment_at,s.version FROM fin_settlement s " +
+            "LEFT JOIN fin_bill b ON b.tenant_id=s.tenant_id AND b.id=s.reconciliation_statement_id ";
     private final JdbcTemplate jdbc;
-    private final com.baiyue.finance.repository.FinanceSettlementDetailRepository details;
     private final ObjectMapper objectMapper;
     private final FinanceVoucherValidator voucherValidator;
     private final FinanceSupplierValidator supplierValidator;
@@ -57,10 +70,8 @@ public class FinanceSettlementService {
     @Autowired
     public FinanceSettlementService(JdbcTemplate jdbc, ObjectMapper objectMapper, FinanceVoucherValidator voucherValidator,
                                     FinanceSupplierValidator supplierValidator,
-                                    FinanceDocumentNumberGenerator documentNumbers,
+                                    FinanceDocumentNumberGenerator documentNumbers) {
-                                    com.baiyue.finance.repository.FinanceSettlementDetailRepository details) {
         this.jdbc = jdbc;
-        this.details = details;
         this.objectMapper = objectMapper;
         this.voucherValidator = voucherValidator;
         this.supplierValidator = supplierValidator;
@@ -171,21 +182,33 @@ public class FinanceSettlementService {
         return getSettlement(settlementId);
     }
 
-    /** 读取结算及其业务流水号；全部详情数据访问经Repository和Mapper。 */
     public SettlementDetail getSettlement(long settlementId) {
         if (settlementId <= 0) throw error("FIN_404", "结算单不存在");
-        List<Map<String, Object>> records = details.summary(settlementId);
+        Map<String, Object> row = one(
-        if (records.isEmpty()) throw error("FIN_404", "结算单不存在");
+            SETTLEMENT_SUMMARY_SELECT + "WHERE s.id=?",
-        SettlementSummary summary = summary(records.get(0));
+            "结算单不存在", settlementId);
-        List<SettlementLine> lines = details.lines(summary.customerId(), settlementId)
+        SettlementSummary summary = summary(row);
+        List<SettlementLine> lines = jdbc.queryForList(
+            "SELECT f.id fee_source_id,f.source_type,f.source_fee_id,f.source_fee_version,f.direction,f.customer_id," +
+                "f.order_id,f.inbound_id,f.container_id,f.fee_item_name,f.amount,f.currency_code,f.review_status,f.status,f.source_snapshot " +
+                "FROM fin_settlement_line sl JOIN fin_fee_source f ON f.id=sl.fee_source_id " +
+                "WHERE sl.tenant_id=? AND sl.settlement_id=? ORDER BY sl.id", summary.customerId(), settlementId)
             .stream().map(source -> line(source, summary)).toList();
-        List<SettlementTransaction> transactions = new ArrayList<>(details.payments(summary.customerId(), settlementId)
+        List<SettlementTransaction> transactions = new ArrayList<>(jdbc.queryForList(
-            .stream().map(this::transaction).toList());
+            "SELECT id,transaction_type,transaction_date,amount,method,reference_no,voucher_file_ids,created_by,created_by_name,created_at,remark " +
+                "FROM fin_settlement_payment WHERE tenant_id=? AND settlement_id=? ORDER BY created_at,id",
+            summary.customerId(), settlementId).stream().map(this::transaction).toList());
         if ("RECEIVABLE".equals(summary.direction()) && summary.reconciliationStatementId() != null) {
-            transactions.addAll(details.receipts(summary.customerId(), summary.reconciliationStatementId())
+            transactions.addAll(jdbc.queryForList(
-                .stream().map(this::transaction).toList());
+                "SELECT r.id,'RECEIPT' transaction_type,DATE(r.received_at) transaction_date,rb.applied_amount amount,r.payment_method method,r.voucher_no reference_no,r.voucher_file_ids,r.created_by,r.created_by_name,r.created_at,r.remark " +
+                    "FROM fin_receipt_bill rb JOIN fin_receipt r ON r.id=rb.receipt_id AND r.tenant_id=rb.tenant_id " +
+                    "WHERE rb.tenant_id=? AND rb.bill_id=? AND r.status='CONFIRMED' ORDER BY r.created_at,r.id",
+                summary.customerId(), summary.reconciliationStatementId()).stream().map(this::transaction).toList());
         }
-        List<Map<String, Object>> audits = details.audits(summary.customerId(), settlementId);
+        List<Map<String, Object>> audits = jdbc.queryForList(
+            "SELECT action,reason,before_data,after_data,operator_id,operator_name_snapshot,created_at FROM fin_audit_log " +
+                "WHERE tenant_id=? AND resource_type='FIN_SETTLEMENT' AND resource_id=? ORDER BY created_at,id",
+            summary.customerId(), settlementId);
         List<SettlementRevision> revisions = new ArrayList<>();
         for (int index = 0; index < audits.size(); index++) revisions.add(revision(index + 1, audits.get(index)));
         return new SettlementDetail(summary, lines, transactions, List.copyOf(revisions));
@@ -453,9 +476,8 @@ public class FinanceSettlementService {
             text(row, "status"), true);
     }
 
-    /** 返回真实付款业务号；未生成PAY号的收款记录保持为空，不回退成内部ID。 */
     private SettlementTransaction transaction(Map<String, Object> row) {
-        return new SettlementTransaction(number(row, "id").longValue(), text(row, "transaction_no"), text(row, "transaction_type"),
+        return new SettlementTransaction(number(row, "id").longValue(), text(row, "transaction_type"),
             date(row, "transaction_date"), decimal(row, "amount"), text(row, "method"), text(row, "reference_no"),
             stringList(text(row, "voucher_file_ids")), number(row, "created_by").longValue(),
             text(row, "created_by_name"),
@@ -501,13 +523,10 @@ public class FinanceSettlementService {
         return documentNumbers.next("PAY");
     }
 
-    /** 固定映射键序，避免 JVM 重启改变 Map.of 遍历顺序而误拒绝原请求。 */
     private String hash(Object value) {
         try {
-            String canonical = objectMapper.writer()
-                .with(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS).writeValueAsString(value);
             return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256")
-                .digest(canonical.getBytes(StandardCharsets.UTF_8)));
+                .digest(json(value).getBytes(StandardCharsets.UTF_8)));
         } catch (Exception failure) {
             throw error("FIN_001", "幂等请求哈希失败");
         }

finance/src/main/java/com/baiyue/finance/service/FinanceWalletService.java

@@ -14,7 +14,6 @@ import com.baiyue.finance.dto.FinanceWalletDtos.WalletHoldActionRequest;
 import com.baiyue.finance.dto.FinanceWalletDtos.WalletLedgerEntry;
 import com.baiyue.finance.dto.FinanceWalletDtos.WalletPage;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.dao.DuplicateKeyException;
 import org.springframework.http.ResponseEntity;
@@ -695,9 +694,8 @@ public class FinanceWalletService {
             timestamp(rs.getTimestamp("reviewed_at")));
     }
 
-    /** 摘要固定映射键序，保证充值和资金指令跨进程重放稳定。 */
     private String hash(Object value) {
-        try { return sha256(objectMapper.writer().with(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS).writeValueAsBytes(value)); }
+        try { return sha256(objectMapper.writeValueAsBytes(value)); }
         catch (Exception exception) { throw error("FIN_500", "请求摘要生成失败"); }
     }
     private String fileHash(MultipartFile file) {

finance/src/main/java/com/baiyue/finance/service/ReconciliationStatementService.java

@@ -10,7 +10,6 @@ import com.baiyue.finance.dto.ReconciliationStatementDtos.ReconciliationLine;
 import com.baiyue.finance.dto.ReconciliationStatementDtos.ReconciliationRevision;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
 import org.slf4j.MDC;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.support.GeneratedKeyHolder;
@@ -522,13 +521,9 @@ public class ReconciliationStatementService {
         catch (Exception exception) { throw error("FIN_001", "财务数据序列化失败"); }
     }
 
-    /** 固定映射键序，使同一请求在服务重启前后使用相同摘要。 */
     private String hash(Object value) {
-        try {
+        try { return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(json(value).getBytes(StandardCharsets.UTF_8))); }
-            byte[] canonical = objectMapper.writer().with(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS)
+        catch (Exception exception) { throw error("FIN_001", "幂等请求哈希失败"); }
-                .writeValueAsBytes(value);
-            return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(canonical));
-        } catch (Exception failure) { throw error("FIN_001", "幂等请求哈希失败"); }
     }
 
     private static LocalDateTime localTime(Object value) {

finance/src/main/resources/openapi/finance-wallet-refund-v1.yaml

@@ -1,61 +0,0 @@
-openapi: 3.0.3
-info:
-  title: 平台资金账户关联退款
-  version: 1.0.0
-  description: 原消费保持不可变；退款记录关联原消费流水号，累计退款不得超过原消费金额，包含业务退款事件已退金额。
-paths:
-  /api/platform/finance/v1/accounts/{customerId}/ledger/{ledgerId}/refunds:
-    post:
-      operationId: refundWalletConsumption
-      summary: 原消费关联退款
-      description: 仅平台 tenantId=0 且具有 platform:finance:customer-account:adjust 权限可操作。账户行锁串行校验累计可退金额，无需前端提交账户版本。优先归还已用授信，再增加实际余额。相同键同请求返回原流水；相同键不同原消费或金额失败。非成功消费、跨客户原流水、超额退款均拒绝。
-      security:
-        - bearerAuth: []
-      parameters:
-        - {name: customerId, in: path, required: true, schema: {type: string, pattern: '^[1-9][0-9]*$'}}
-        - {name: ledgerId, in: path, required: true, schema: {type: string, pattern: '^[1-9][0-9]*$'}}
-        - {name: Idempotency-Key, in: header, required: true, schema: {type: string, minLength: 1, maxLength: 128}}
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              type: object
-              required: [amount, reason]
-              properties:
-                amount: {type: number, minimum: 0.01, maximum: 999999999999.99, multipleOf: 0.01}
-                reason: {type: string, minLength: 1, maxLength: 500, description: 必填退款原因，不得仅空白}
-      responses:
-        '200':
-          description: 统一响应 code=200 成功；业务失败使用 FIN-REQ-400、FIN-WALLET-404、FIN-IDEMPOTENCY-CONFLICT 或 FIN-WALLET-REFUND-EXCEEDED 等业务码。
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code: {type: string}
-                  data:
-                    $ref: '#/components/schemas/RefundLedgerEntry'
-        '403': {description: 非平台主体或缺少调账权限}
-components:
-  securitySchemes:
-    bearerAuth: {type: http, scheme: bearer, bearerFormat: JWT}
-  schemas:
-    RefundLedgerEntry:
-      type: object
-      description: 完整返回 FinanceWalletDtos.WalletLedgerEntry，资金余额字段沿用账户流水协议。
-      properties:
-        ledgerId: {type: string}
-        businessNo: {type: string, description: 新退款流水正式 AC 单号}
-        changeType: {type: string, enum: [REFUND]}
-        amount: {type: number, description: 实际退款正金额}
-        sourceType: {type: string, enum: [BUSINESS_REFUND]}
-        sourceNo: {type: string, description: 客户及幂等键派生的稳定技术退款引用}
-        referenceNo: {type: string, description: 原消费流水 businessNo，用于关联及累计可退校验}
-        operatorName: {type: string, nullable: true}
-        remark: {type: string, description: 退款原因}
-        actualBalanceAfter: {type: number}
-        frozenBalanceAfter: {type: number}
-        availableBalanceAfter: {type: number}
-        creditUsedAfter: {type: number}
-        availableCreditAfter: {type: number}

finance/src/test/java/com/baiyue/finance/BusinessFeeSourceEventServiceTest.java

@@ -286,82 +286,4 @@ class BusinessFeeSourceEventServiceTest {
             base.aggregateType(), base.aggregateId(), base.aggregateVersion(), null, base.traceId(), base.correlationId(), null,
             payload, EventPayloadHash.sha256(EventPayloadCanonicalizer.canonicalize(payload)));
     }
-
-    @Test
-    void manualConsumptionUsesDedicatedFundingIdentityWhilePreservingServiceOrder() {
-        verifyDedicatedConsumption("OVERSEAS_MANUAL_FEE", "701-2", "FEE_TYPE_071");
-    }
-
-    @Test
-    void rentConsumptionUsesPreparationIdentityWhilePreservingServiceOrder() {
-        verifyDedicatedConsumption("STORAGE_RENT", "445", "FEE_TYPE_077");
-    }
-
-    @Test
-    void dedicatedFundingCannotReferenceAnotherManualFeeOrWrongFeeItem() {
-        assertThatThrownBy(() -> service.consume(dedicatedEvent("OVERSEAS_MANUAL_FEE", "702-1", "FEE_TYPE_071")))
-            .hasMessageContaining("来源不匹配");
-        assertThatThrownBy(() -> service.consume(dedicatedEvent("STORAGE_RENT", "445", "FEE_TYPE_071")))
-            .hasMessageContaining("项目不匹配");
-        noFinancialWrites();
-    }
-
-    @Test
-    void dedicatedConsumptionCannotReuseHoldAlreadyLinkedToAnotherSource() {
-        stubDedicatedConsumption("STORAGE_RENT", "445");
-        when(jdbc.queryForList(startsWith("SELECT id FROM fin_fee_source WHERE wallet_hold_id="),
-            eq(Long.class), eq(9L), eq(901L))).thenReturn(List.of(902L));
-        assertThatThrownBy(() -> service.consume(dedicatedEvent("STORAGE_RENT", "445", "FEE_TYPE_077")))
-            .hasMessageContaining("已关联其他费用");
-        verify(jdbc, never()).update(startsWith("UPDATE fin_fee_source SET wallet_hold_id="), any(Object[].class));
-    }
-
-    @Test
-    void dedicatedConsumptionRejectsResultFromDifferentFundingBusiness() {
-        stubDedicatedConsumption("STORAGE_RENT", "445");
-        when(jdbc.queryForList(startsWith("SELECT l.amount,c.result_json"), eq("command-1"), eq(9L), eq(72L),
-            eq(10001L), eq("STORAGE_RENT"), eq("445"))).thenReturn(List.of(Map.of(
-                "amount", new BigDecimal("-120.00"), "result_json", """
-                    {"result":"SUCCEEDED","operation":"SETTLE","commandEventId":"command-1",
-                     "walletHoldId":"9","walletLedgerId":"72","customerId":10001,
-                     "businessType":"STORAGE_RENT","businessNo":"446","amount":120.00}
-                    """)));
-        assertThatThrownBy(() -> service.consume(dedicatedEvent("STORAGE_RENT", "445", "FEE_TYPE_077")))
-            .hasMessageContaining("资金结果不匹配");
-    }
-
-    private void verifyDedicatedConsumption(String type, String no, String item) {
-        stubDedicatedConsumption(type, no);
-        EventEnvelope event = dedicatedEvent(type, no, item);
-        service.consume(event);
-        verify(jdbc).update(startsWith("UPDATE fin_fee_source SET wallet_hold_id="), eq(9L), eq(901L), eq(10001L));
-        assertThat(event.payload().path("businessType").asText()).isEqualTo("WAREHOUSE_SERVICE");
-        assertThat(event.payload().path("businessNo").asText()).isEqualTo("PO-US-001");
-    }
-
-    private void stubDedicatedConsumption(String type, String no) {
-        when(jdbc.queryForObject(startsWith("SELECT id FROM fin_fee_source"), eq(Long.class),
-            eq("LASTLEG"), eq("OVERSEAS_WAREHOUSE_FEE"), eq(701L), eq(1))).thenReturn(901L);
-        ObjectNode result = json.createObjectNode();
-        result.put("result", "SUCCEEDED").put("operation", "SETTLE").put("commandEventId", "command-1")
-            .put("walletHoldId", "9").put("walletLedgerId", "72").put("customerId", 10001)
-            .put("businessType", type).put("businessNo", no).put("amount", new BigDecimal("120.00"));
-        when(jdbc.queryForList(startsWith("SELECT l.amount,c.result_json"), eq("command-1"), eq(9L), eq(72L),
-            eq(10001L), eq(type), eq(no))).thenReturn(List.of(Map.of(
-                "amount", new BigDecimal("-120.00"), "result_json", result.toString())));
-    }
-
-    private EventEnvelope dedicatedEvent(String type, String no, String item) {
-        EventEnvelope base = eventWithoutInbound();
-        ObjectNode payload = base.payload().deepCopy();
-        payload.put("feeItemCode", item);
-        payload.putObject("walletSettlement").put("commandEventId", "command-1").put("holdId", "9")
-            .put("ledgerId", "72").put("walletBusinessType", type).put("walletBusinessNo", no);
-        payload.putNull("action"); payload.putNull("sourceHash");
-        payload.put("sourceHash", EventPayloadHash.sha256(EventPayloadCanonicalizer.canonicalize(payload)));
-        payload.put("action", "PUBLISHED");
-        return new EventEnvelope(base.eventId(), base.eventType(), base.eventVersion(), base.occurredAt(), base.tenantId(),
-            base.aggregateType(), base.aggregateId(), base.aggregateVersion(), null, base.traceId(), base.correlationId(), null,
-            payload, EventPayloadHash.sha256(EventPayloadCanonicalizer.canonicalize(payload)));
-    }
 }

finance/src/test/java/com/baiyue/finance/FinanceContractTest.java

@@ -17,7 +17,6 @@ class FinanceContractTest {
             .getAnnotation(org.springframework.scheduling.annotation.EnableScheduling.class));
     }
 
-    /** 固定财务访问域与账单关联键，查询迁入 Mapper 后仍核对真实来源记录。 */
     @Test
     void controllersUseFrozenFinancePaths() throws Exception {
         assertEquals("/api/platform/finance/v1", PlatformFinanceController.class.getAnnotation(org.springframework.web.bind.annotation.RequestMapping.class).value()[0]);
@@ -41,8 +40,7 @@ class FinanceContractTest {
         assertTrue(controller.contains("costSnapshotClient.loadingPlan") && controller.contains("createCost(request.customerId(), user.userId(), internal, volumes, key)"));
         assertTrue(service.contains("validateVoucherFiles(tenantId, request.voucherFileIds())"));
         String operations = Files.readString(Path.of("src/main/java/com/baiyue/finance/service/FinancePhase1OperationService.java"));
-        String feeReads = Files.readString(Path.of("src/main/java/com/baiyue/finance/mapper/FinanceFeeSourceReadMapper.java"));
+        assertTrue(operations.contains("bl.source_id=f.id"));
-        assertTrue(feeReads.contains("bl.source_id=f.id"));
         assertTrue(operations.contains("Boolean.class, id, rs.getInt(\"source_fee_version\")"));
         assertFalse(operations.contains("bl.source_id=f.source_fee_id"));
         String unified = Files.readString(Path.of("../deploy/sql/头程数据库统一增量-MySQL8.sql"));

finance/src/test/java/com/baiyue/finance/FinanceDirectPaidCostReadTest.java

@@ -1,89 +0,0 @@
-package com.baiyue.finance;
-
-import com.baiyue.finance.service.FinanceQueryService;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.ValueSource;
-import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.datasource.DriverManagerDataSource;
-
-import java.util.UUID;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-
-/** 成本列表和详情须与直接已付事实一致，不能提示供应商费用仍待支付。 */
-class FinanceDirectPaidCostReadTest {
-    private JdbcTemplate jdbc;
-    private FinanceQueryService service;
-
-    /** 使用隔离内存表验证正式读取路径，不访问共享测试环境。 */
-    @BeforeEach
-    void setUp() {
-        jdbc = new JdbcTemplate(new DriverManagerDataSource(
-            "jdbc:h2:mem:cost-read-" + UUID.randomUUID() + ";MODE=MySQL;DB_CLOSE_DELAY=-1", "sa", ""));
-        jdbc.execute("CREATE TABLE fin_cost(id BIGINT PRIMARY KEY,tenant_id BIGINT,cost_no VARCHAR(128),"
-            + "cost_type VARCHAR(24),cost_origin VARCHAR(24),order_id BIGINT,inbound_id BIGINT,container_id BIGINT,"
-            + "supplier_name_snapshot VARCHAR(128),fee_item_name VARCHAR(128),cost_amount DECIMAL(18,2),"
-            + "currency_code VARCHAR(3),status VARCHAR(24),created_at TIMESTAMP,version INT)");
-        jdbc.execute("CREATE TABLE fin_cost_allocation(id BIGINT,tenant_id BIGINT,cost_id BIGINT,order_id BIGINT,"
-            + "inbound_id BIGINT,volume_cbm DECIMAL(18,6),total_volume_cbm DECIMAL(18,6),allocation_rate DECIMAL(18,6),"
-            + "allocated_amount DECIMAL(18,2),rounding_adjustment BOOLEAN)");
-        service = new FinanceQueryService(jdbc, new ObjectMapper());
-    }
-
-    /** 头程与海外直付均已付款，列表和详情不能再次显示未付余额。 */
-    @ParameterizedTest
-    @ValueSource(strings = {"BUSINESS_DIRECT_PAID", "FIRSTLEG_DIRECT_PAID"})
-    void confirmedDirectPaidCostIsFullyPaidInListAndDetail(String origin) {
-        insertCost(1, 11, "SOURCE_DIRECT_PAID", origin, "CONFIRMED");
-
-        var row = service.payableSettlements(11L).get(0);
-        assertThat(row.payableAmount()).isEqualByComparingTo("0.03");
-        assertThat(row.paidAmount()).isEqualByComparingTo("0.03");
-        assertThat(row.outstandingAmount()).isZero();
-        assertThat(service.cost(11, 1).cost()).isEqualTo(row);
-    }
-
-    /** 已作废的直付历史保留原金额，但不再作为有效已付或待付款展示。 */
-    @Test
-    void voidedDirectPaidCostHasNoActivePaymentOrOutstandingAmount() {
-        insertCost(1, 11, "SOURCE_DIRECT_PAID", "BUSINESS_DIRECT_PAID", "VOIDED");
-
-        var row = service.payableSettlements(11L).get(0);
-        assertThat(row.payableAmount()).isEqualByComparingTo("0.03");
-        assertThat(row.paidAmount()).isZero();
-        assertThat(row.outstandingAmount()).isZero();
-        assertThat(row.status()).isEqualTo("VOIDED");
-    }
-
-    /** 人工补充成本没有直接已付事实，不能被自动视为付款完成。 */
-    @ParameterizedTest
-    @ValueSource(strings = {"SINGLE_ORDER", "CONTAINER_SHARED"})
-    void manualCostKeepsItsExistingUnpaidAmounts(String type) {
-        insertCost(1, 11, type, "MANUAL", "CONFIRMED");
-
-        var row = service.payableSettlements(11L).get(0);
-        assertThat(row.paidAmount()).isZero();
-        assertThat(row.outstandingAmount()).isEqualByComparingTo("0.03");
-    }
-
-    /** 金额回显修复不能让其他客户读到成本列表或详情。 */
-    @Test
-    void costReadsKeepCustomerIsolation() {
-        insertCost(1, 11, "SOURCE_DIRECT_PAID", "BUSINESS_DIRECT_PAID", "CONFIRMED");
-
-        assertThat(service.payableSettlements(12L)).isEmpty();
-        assertThatThrownBy(() -> service.cost(12, 1)).hasMessageContaining("成本不存在或不属于客户");
-    }
-
-    /** 仅构造测试所需的成本事实，金额对应本轮发现问题的小额样本。 */
-    private void insertCost(long id, long customer, String type, String origin, String status) {
-        jdbc.update("INSERT INTO fin_cost(id,tenant_id,cost_no,cost_type,cost_origin,order_id,container_id,"
-                + "supplier_name_snapshot,fee_item_name,cost_amount,currency_code,status,created_at,version) "
-                + "VALUES(?,?,?,?,?,101,201,'验收供应商','人工费',0.03,'CNY',?,CURRENT_TIMESTAMP,0)",
-            id, customer, "COST-READ-TEST", type, origin, status);
-    }
-}

finance/src/test/java/com/baiyue/finance/FinanceFeeSourceReadMapperTest.java

@@ -1,141 +0,0 @@
-package com.baiyue.finance;
-
-import com.baiyue.finance.mapper.FinanceFeeSourceReadMapper;
-import com.baiyue.finance.repository.FinanceFeeSourceReadRepository;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.apache.ibatis.mapping.Environment;
-import org.apache.ibatis.session.Configuration;
-import org.apache.ibatis.session.SqlSessionFactoryBuilder;
-import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.ValueSource;
-import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.datasource.DriverManagerDataSource;
-
-import java.math.BigDecimal;
-import java.time.LocalDate;
-import java.util.UUID;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/** 隔离数据库执行正式 Mapper，验证版本归并与历史不会改变金额和客户归属。 */
-public class FinanceFeeSourceReadMapperTest {
-    /** 应收和应付均以来源身份替换当前展示，同名费用、其他来源类型和系统保持独立。 */
-    @ParameterizedTest
-    @ValueSource(strings = {"RECEIVABLE", "PAYABLE"})
-    void currentProjectionAndHistoryKeepStableFeeIdentity(String direction) {
-        var data = new DriverManagerDataSource("jdbc:h2:mem:fee-current-" + UUID.randomUUID() + ";MODE=MySQL", "sa", "");
-        var jdbc = new JdbcTemplate(data);
-        // 保持一个会话存活；Mapper 使用同一隔离数据库，绝不访问共享测试环境。
-        try (var connection = data.getConnection()) {
-            jdbc.execute("CREATE ALIAS JSON_EXTRACT FOR 'com.baiyue.finance.FinanceFeeSourceReadMapperTest.jsonExtract'");
-            jdbc.execute("CREATE ALIAS JSON_UNQUOTE FOR 'com.baiyue.finance.FinanceFeeSourceReadMapperTest.jsonUnquote'");
-            jdbc.execute("CREATE TABLE fin_fee_source(id BIGINT PRIMARY KEY,source_system VARCHAR(32),source_type VARCHAR(32),source_fee_id BIGINT,source_fee_version INT,customer_id BIGINT,direction VARCHAR(16),source_no VARCHAR(64),fee_item_name VARCHAR(100),amount DECIMAL(20,6),currency_code VARCHAR(3),review_status VARCHAR(16),status VARCHAR(16),source_snapshot VARCHAR(2000),order_id BIGINT,inbound_id BIGINT,container_id BIGINT,created_at TIMESTAMP)");
-            jdbc.execute("CREATE TABLE fin_bill_line(source_id BIGINT,source_version INT)");
-            jdbc.execute("CREATE TABLE fin_audit_log(id BIGINT PRIMARY KEY,tenant_id BIGINT,resource_type VARCHAR(32),resource_id BIGINT,action VARCHAR(64),operator_name_snapshot VARCHAR(64),reason VARCHAR(100),before_data VARCHAR(1000),after_data VARCHAR(1000),created_at TIMESTAMP)");
-            insert(jdbc, 1, "FIRSTLEG", "INBOUND_FEE", 700, 1, 9, direction, "SUPERSEDED", "100.00");
-            insert(jdbc, 2, "FIRSTLEG", "INBOUND_FEE", 700, 2, 9, direction, "AVAILABLE", "120.00");
-            insert(jdbc, 3, "FIRSTLEG", "INBOUND_FEE", 701, 1, 9, direction, "AVAILABLE", "80.00");
-            insert(jdbc, 4, "FIRSTLEG", "INBOUND_FEE", 702, 1, 9, direction, "AVAILABLE", "50.00");
-            insert(jdbc, 5, "FIRSTLEG", "INBOUND_FEE", 702, 2, 9, direction, "VOIDED", "70.00");
-            insert(jdbc, 6, "LASTLEG", "INBOUND_FEE", 700, 1, 9, direction, "AVAILABLE", "33.00");
-            insert(jdbc, 7, "FIRSTLEG", "CONTAINER_FEE", 700, 1, 9, direction, "AVAILABLE", "44.00");
-            insert(jdbc, 8, "FIRSTLEG", "INBOUND_FEE", 703, 1, 10, direction, "AVAILABLE", "55.00");
-            jdbc.update("INSERT INTO fin_audit_log VALUES(1,9,'FIN_FEE_SOURCE',1,'FEE_SOURCE_REVIEW_APPROVE','审核员','原费用审核',NULL,NULL,'2026-10-21 10:01:30')");
-            jdbc.update("INSERT INTO fin_audit_log VALUES(2,9,'FIN_FEE_SOURCE',2,'FEE_SOURCE_ADJUST','财务员','更正费用','{\"amount\":100}','{\"amount\":120,\"currency\":\"CNY\"}','2026-10-21 10:03:00')");
-            jdbc.update("INSERT INTO fin_audit_log VALUES(3,9,'FIN_FEE_SOURCE',3,'FEE_SOURCE_ADJUST','其他费用','不能合并',NULL,NULL,'2026-10-21 10:04:00')");
-            jdbc.update("INSERT INTO fin_audit_log VALUES(4,10,'FIN_FEE_SOURCE',1,'FEE_SOURCE_ADJUST','其他客户','不能越界',NULL,NULL,'2026-10-21 10:04:00')");
-
-            var configuration = new Configuration(new Environment("test", new JdbcTransactionFactory(), data));
-            configuration.addMapper(FinanceFeeSourceReadMapper.class);
-            try (var session = new SqlSessionFactoryBuilder().build(configuration).openSession()) {
-                var repository = new FinanceFeeSourceReadRepository(session.getMapper(FinanceFeeSourceReadMapper.class), new ObjectMapper());
-                var filters = repository.filters(9L, direction, null, "APPROVED", false,
-                    LocalDate.of(2026, 10, 1), LocalDate.of(2026, 10, 31), "操作费", 1, 20);
-                assertThat(repository.count(filters)).isEqualTo(5);
-                var rows = repository.list(filters);
-                assertThat(rows).extracting(row -> row.feeSourceId()).containsExactly(7L, 6L, 5L, 3L, 2L);
-                assertThat(rows.stream().map(row -> row.amount()).reduce(BigDecimal.ZERO, BigDecimal::add))
-                    .isEqualByComparingTo("347.00");
-                assertThat(rows).allSatisfy(row -> {
-                    assertThat(row.direction()).isEqualTo(direction);
-                    assertThat(row.customerId()).isEqualTo(9);
-                    assertThat(row.supplierId()).isEqualTo(79);
-                    assertThat(row.inboundCode()).isEqualTo("IN-9");
-                    assertThat(row.businessDate()).isEqualTo(LocalDate.of(2026, 10, 21));
-                    assertThat(row.originalAmount()).isEqualByComparingTo("200");
-                    assertThat(row.unitPrice()).isEqualByComparingTo("20");
-                });
-                filters.put("limit", 2);
-                filters.put("offset", 2);
-                assertThat(repository.count(filters)).isEqualTo(5);
-                assertThat(repository.list(filters)).extracting(row -> row.feeSourceId()).containsExactly(5L, 3L);
-                filters.put("limit", 20); filters.put("offset", 0); filters.put("status", "AVAILABLE");
-                assertThat(repository.count(filters)).isEqualTo(4);
-                assertThat(repository.list(filters)).extracting(row -> row.feeSourceId()).doesNotContain(4L, 5L);
-                filters.put("status", "SUPERSEDED");
-                assertThat(repository.list(filters)).extracting(row -> row.feeSourceId()).containsExactly(1L);
-
-                var logs = repository.logs(9, 2);
-                assertThat(logs).hasSize(4);
-                assertThat(logs).extracting(log -> log.action()).containsExactly(
-                    "FEE_SOURCE_ADJUST", "FEE_SOURCE_VERSION_ADJUST", "FEE_SOURCE_REVIEW_APPROVE", "FEE_SOURCE_PUBLISHED");
-                assertThat(logs.get(0).remark()).isEqualTo("更正费用；金额 100 → 120 CNY");
-                assertThat(logs.get(1).remark()).contains("来源版本 1 → 2", "100.000000 → 120.000000 CNY");
-                assertThat(logs).noneSatisfy(log -> assertThat(log.operatorName()).startsWith("其他"));
-                assertThat(repository.logs(9, 2)).isEqualTo(logs);
-                assertThat(repository.logs(9, 1)).hasSize(2);
-                assertThat(repository.logs(10, 2)).isEmpty();
-                // 同毫秒必须先展示新版本；审计仍按 ID 倒序，不能反转金额差分或突破旧版本锚点。
-                jdbc.update("UPDATE fin_fee_source SET created_at='2026-10-21 10:03:00.123' WHERE id IN (1,2)");
-                jdbc.update("UPDATE fin_audit_log SET created_at='2026-10-21 10:03:00.123' WHERE id IN (1,2)");
-                jdbc.update("INSERT INTO fin_audit_log VALUES(6,9,'FIN_FEE_SOURCE',2,'FEE_SOURCE_REVIEW_APPROVE','审核员','同毫秒后审计',NULL,NULL,'2026-10-21 10:03:00.123')");
-                session.clearCache();
-                var sameTimeLogs = repository.logs(9, 2);
-                assertThat(sameTimeLogs).extracting(log -> log.action()).containsExactly(
-                    "FEE_SOURCE_VERSION_ADJUST", "FEE_SOURCE_PUBLISHED", "FEE_SOURCE_REVIEW_APPROVE",
-                    "FEE_SOURCE_ADJUST", "FEE_SOURCE_REVIEW_APPROVE");
-                assertThat(sameTimeLogs.get(0).remark()).contains("来源版本 1 → 2", "100.000000 → 120.000000 CNY");
-                assertThat(sameTimeLogs.get(1).remark()).contains("来源版本 1；金额 100.000000 CNY");
-                assertThat(sameTimeLogs.subList(2, 5)).extracting(log -> log.remark()).containsExactly(
-                    "同毫秒后审计", "更正费用；金额 100 → 120 CNY", "原费用审核");
-                assertThat(repository.logs(9, 2)).isEqualTo(sameTimeLogs);
-                assertThat(repository.logs(9, 1)).extracting(log -> log.action()).containsExactly(
-                    "FEE_SOURCE_PUBLISHED", "FEE_SOURCE_REVIEW_APPROVE");
-                assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM fin_fee_source", Long.class)).isEqualTo(8);
-                jdbc.update("INSERT INTO fin_bill_line VALUES(2,2)");
-                filters.put("status", "BILLED"); filters.put("statementGenerated", true);
-                assertThat(repository.count(filters)).isEqualTo(1);
-                assertThat(repository.list(filters)).extracting(row -> row.feeSourceId()).containsExactly(2L);
-
-                // 财务内部费用原地改金额，其历史只取真实审计，不能伪造旧时间的同步金额。
-                insert(jdbc, 9, "FINANCE", "MANUAL", 700, 1, 9, direction, "AVAILABLE", "120.00");
-                jdbc.update("INSERT INTO fin_audit_log VALUES(5,9,'FIN_FEE_SOURCE',9,'FEE_SOURCE_ADJUST','财务员','更正人工费用','{\"amount\":100}','{\"amount\":120,\"currency\":\"CNY\"}','2026-10-21 10:05:00')");
-                assertThat(repository.logs(9, 9)).singleElement().satisfies(log -> {
-                    assertThat(log.action()).isEqualTo("FEE_SOURCE_ADJUST");
-                    assertThat(log.remark()).isEqualTo("更正人工费用；金额 100 → 120 CNY");
-                });
-            }
-        } catch (java.sql.SQLException failure) { throw new AssertionError(failure); }
-    }
-
-    /** 准备具有相同名称、不同稳定来源的隔离费用快照。 */
-    private static void insert(JdbcTemplate jdbc, long id, String system, String type, long fee, int version,
-                               long customer, String direction, String status, String amount) {
-        jdbc.update("INSERT INTO fin_fee_source(id,source_system,source_type,source_fee_id,source_fee_version,customer_id,direction,source_no,fee_item_name,amount,currency_code,review_status,status,source_snapshot,created_at) VALUES(?,?,?,?,?,?,?,'IN-9','操作费',?,'CNY','APPROVED',?,?,?)",
-            id, system, type, fee, version, customer, direction, new BigDecimal(amount), status,
-            "{\"businessDate\":\"2026-10-21\",\"supplierId\":79,\"inboundCode\":\"IN-9\",\"chargeableQuantity\":10,\"originalAmount\":200}",
-            java.sql.Timestamp.valueOf("2026-10-21 10:0" + version + ":00"));
-    }
-
-    /** H2 仅补足 MySQL JSON 读取函数，实际筛选、关联和分页仍执行正式 SQL。 */
-    public static String jsonExtract(String value, String path) throws Exception {
-        var node = new ObjectMapper().readTree(value).path(path.substring(2));
-        return node.isMissingNode() || node.isNull() ? null : node.toString();
-    }
-
-    /** 对测试 JSON 标量解引号，保持 MySQL 空值语义。 */
-    public static String jsonUnquote(String value) throws Exception {
-        return value == null ? null : new ObjectMapper().readTree(value).asText();
-    }
-}

finance/src/test/java/com/baiyue/finance/FinancePhase1OperationBehaviorTest.java

@@ -9,13 +9,10 @@ import com.baiyue.finance.dto.FinancePhase1Dtos.FeeSourceDetail;
 import com.baiyue.finance.dto.FinancePhase1Dtos.PageEnvelope;
 import com.baiyue.finance.service.FinanceEventException;
 import com.baiyue.finance.service.FinancePhase1OperationService;
-import com.baiyue.finance.repository.FinanceFeeSourceReadRepository;
 import com.baiyue.finance.service.FinanceCustomerAccountService;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.ValueSource;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.jdbc.core.JdbcTemplate;
@@ -43,9 +40,6 @@ import static org.mockito.Mockito.lenient;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.times;
 
 @ExtendWith(MockitoExtension.class)
 class FinancePhase1OperationBehaviorTest {
@@ -87,20 +81,18 @@ class FinancePhase1OperationBehaviorTest {
         assertThat(response.page().total()).isEqualTo(1);
     }
 
-    /** 无效客户在进入持久化查询前拒绝。 */
     @Test
     void ledgerRejectsInvalidCustomerBeforeAnyQuery() {
-        FinancePhase1OperationService service = new FinancePhase1OperationService(mock(JdbcTemplate.class), objectMapper(), null, "", mock(FinanceFeeSourceReadRepository.class));
+        FinancePhase1OperationService service = new FinancePhase1OperationService(mock(JdbcTemplate.class), objectMapper());
         assertThatThrownBy(() -> service.listDerivedCustomerAccountLedger(0, 1, 20, null, null, null))
             .isInstanceOf(FinanceEventException.class)
             .extracting(error -> ((FinanceEventException) error).code()).isEqualTo("FIN-REQ-400");
     }
 
-    /** 保留客户账户汇总的固定分页与金额口径。 */
     @Test
     void accountListReturnsFixedPagedDto() {
         AccountJdbc jdbc = new AccountJdbc();
-        FinancePhase1OperationService service = new FinancePhase1OperationService(jdbc, objectMapper(), null, "", mock(FinanceFeeSourceReadRepository.class));
+        FinancePhase1OperationService service = new FinancePhase1OperationService(jdbc, objectMapper());
 
         PageEnvelope<FinancePhase1Dtos.AccountSummary> result =
             service.listDerivedCustomerAccounts(1, 20, "客户9", "ACTIVE");
@@ -120,11 +112,10 @@ class FinancePhase1OperationBehaviorTest {
         assertThat(jdbc.accountListSql).doesNotContain("CAST(c.customer_id AS CHAR)");
     }
 
-    /** 所有派生流水查询保留目标客户范围。 */
     @Test
     void ledgerQueriesEveryDerivedSourceWithinCustomerScope() {
         AccountJdbc jdbc = new AccountJdbc();
-        FinancePhase1OperationService service = new FinancePhase1OperationService(jdbc, objectMapper(), null, "", mock(FinanceFeeSourceReadRepository.class));
+        FinancePhase1OperationService service = new FinancePhase1OperationService(jdbc, objectMapper());
 
         PageEnvelope<FinancePhase1Dtos.LedgerEntry> result =
             service.listDerivedCustomerAccountLedger(9L, 1, 20, null, null, null);
@@ -137,24 +128,58 @@ class FinancePhase1OperationBehaviorTest {
             .contains("fin_settlement_payment", "transaction_type='PAYMENT'", "s.direction='PAYABLE'"));
     }
 
-    /** 所有筛选在服务端进入同一版本投影，不在分页后按费用名称去重。 */
     @Test
-    void feeSourceListUsesFormalFieldsAndAllActiveFilters() {
+    void feeSourceListUsesFormalFieldsAndAllActiveFilters() throws Exception {
-        var reads = mock(FinanceFeeSourceReadRepository.class);
+        JdbcTemplate jdbc = mock(JdbcTemplate.class);
-        var filters = java.util.Map.<String, Object>of("query", "current");
+        when(jdbc.queryForObject(startsWith("SELECT COUNT(*) FROM fin_fee_source"), eq(Long.class), any(Object[].class)))
-        when(reads.filters(9L, "RECEIVABLE", "AVAILABLE", "APPROVED", false,
+            .thenReturn(1L);
-            LocalDate.of(2026, 8, 1), LocalDate.of(2026, 8, 31), "IN-9", 2, 50)).thenReturn(filters);
+        when(jdbc.query(startsWith("SELECT f.*"), any(RowMapper.class), any(Object[].class))).thenAnswer(invocation -> {
-        when(reads.list(filters)).thenReturn(List.of());
+            @SuppressWarnings("unchecked") RowMapper<Object> mapper = invocation.getArgument(1);
-        when(reads.count(filters)).thenReturn(3L);
+            ResultSet rs = mock(ResultSet.class);
-        var service = new FinancePhase1OperationService(mock(JdbcTemplate.class), objectMapper(), null, "", reads);
+            when(rs.getLong("id")).thenReturn(88L);
+            when(rs.getLong("source_fee_id")).thenReturn(9001L);
+            when(rs.getInt("source_fee_version")).thenReturn(3);
+            when(rs.getLong("customer_id")).thenReturn(9L);
+            when(rs.getLong("order_id")).thenReturn(19L);
+            when(rs.getLong("inbound_id")).thenReturn(29L);
+            when(rs.getLong("container_id")).thenReturn(39L);
+            when(rs.getString("source_system")).thenReturn("FIRSTLEG");
+            when(rs.getString("source_type")).thenReturn("INBOUND_FEE");
+            when(rs.getString("source_no")).thenReturn("IN-9");
+            when(rs.getString("direction")).thenReturn("RECEIVABLE");
+            when(rs.getString("fee_item_name")).thenReturn("入库操作费");
+            when(rs.getString("currency_code")).thenReturn("CNY");
+            when(rs.getString("review_status")).thenReturn("APPROVED");
+            when(rs.getString("effective_status")).thenReturn("AVAILABLE");
+            when(rs.getString("source_snapshot")).thenReturn("{\"customerName\":\"客户9\",\"supplierId\":\"79\",\"supplierName\":\"供应商A\",\"inboundCode\":\"IN-9\",\"containerNo\":\"CONT-9\",\"businessDate\":\"2026-08-11\",\"chargeableQuantity\":\"10\"}");
+            when(rs.getBigDecimal("amount")).thenReturn(new BigDecimal("120.00"));
+            when(rs.getBoolean("statement_generated")).thenReturn(false);
+            return List.of(mapper.mapRow(rs, 0));
+        });
+        FinancePhase1OperationService service = new FinancePhase1OperationService(jdbc, objectMapper());
+
         var result = service.listFinanceFeeSources(2, 50, 9L, "receivable", "available", "approved",
             false, LocalDate.of(2026, 8, 1), LocalDate.of(2026, 8, 31), "IN-9");
-        assertThat(result.page().total()).isEqualTo(3);
+
-        assertThat(result.page().page()).isEqualTo(2);
+        assertThat(result.page()).satisfies(meta -> {
-        verify(reads).list(filters);
+            assertThat(meta.page()).isEqualTo(2);
+            assertThat(meta.pageSize()).isEqualTo(50);
+            assertThat(meta.total()).isEqualTo(1);
+        });
+        assertThat(result.data()).singleElement().satisfies(source -> {
+            assertThat(source.sourceSystem()).isEqualTo("FIRSTLEG");
+            assertThat(source.sourceBusinessId()).isEqualTo("IN-9");
+            assertThat(source.inboundCode()).isEqualTo("IN-9");
+            assertThat(source.containerNo()).isEqualTo("CONT-9");
+            assertThat(source.supplierId()).isEqualTo(79L);
+            assertThat(source.supplierName()).isEqualTo("供应商A");
+            assertThat(source.reviewStatus()).isEqualTo("APPROVED");
+            assertThat(source.businessDate()).isEqualTo(LocalDate.of(2026, 8, 11));
+            assertThat(source.statementGenerated()).isFalse();
+        });
+        verify(jdbc).query(startsWith("SELECT f.*"), any(RowMapper.class), any(Object[].class));
     }
 
-    /** 流水返回业务单号和操作者快照。 */
     @Test
     void ledgerReturnsStableBusinessTypeDocumentAndOperatorNameSnapshot() throws Exception {
         JdbcTemplate jdbc = mock(JdbcTemplate.class);
@@ -172,7 +197,7 @@ class FinancePhase1OperationBehaviorTest {
         });
         when(jdbc.query(startsWith("SELECT id,receipt_no"), any(RowMapper.class), eq(9L))).thenReturn(List.of());
         when(jdbc.query(startsWith("SELECT id,cost_no"), any(RowMapper.class), eq(9L))).thenReturn(List.of());
-        FinancePhase1OperationService service = new FinancePhase1OperationService(jdbc, objectMapper(), null, "", mock(FinanceFeeSourceReadRepository.class));
+        FinancePhase1OperationService service = new FinancePhase1OperationService(jdbc, objectMapper());
 
         PageEnvelope<FinancePhase1Dtos.LedgerEntry> result =
             service.listDerivedCustomerAccountLedger(9L, 1, 20, null, null, null);
@@ -186,20 +211,18 @@ class FinancePhase1OperationBehaviorTest {
         });
     }
 
-    /** 保留费用审核状态读取。 */
     @Test
     void approvedFeeCannotBeEditedAsDraft() throws Exception {
         JdbcTemplate jdbc = feeSourceJdbc("REJECTED", false, 2);
-        FinancePhase1OperationService service = new FinancePhase1OperationService(jdbc, objectMapper(), null, "", mock(FinanceFeeSourceReadRepository.class));
+        FinancePhase1OperationService service = new FinancePhase1OperationService(jdbc, objectMapper());
 
         assertThat(service.getFinanceFeeSource(88L).reviewStatus()).isEqualTo("REJECTED");
     }
 
-    /** 费用详情保持原客户与来源版本。 */
     @Test
     void feeSourceDetailUsesFixedDtoAndRealCustomerScope() throws Exception {
         FinancePhase1OperationService service = new FinancePhase1OperationService(
-            feeSourceJdbc("APPROVED", true, 2), objectMapper(), null, "", mock(FinanceFeeSourceReadRepository.class));
+            feeSourceJdbc("APPROVED", true, 2), objectMapper());
 
         FeeSourceDetail detail = service.getFinanceFeeSource(88L);
 
@@ -209,11 +232,10 @@ class FinancePhase1OperationBehaviorTest {
         assertThat(detail.reviewStatus()).isEqualTo("APPROVED");
     }
 
-    /** 业务来源费用必须回到所属系统调整。 */
     @Test
     void firstlegFeeEditAndAdjustAreBlockedInsteadOfMutatingFinanceCopy() throws Exception {
         JdbcTemplate jdbc = feeSourceJdbc("REJECTED", false, 1);
-        FinancePhase1OperationService service = new FinancePhase1OperationService(jdbc, objectMapper(), null, "", mock(FinanceFeeSourceReadRepository.class));
+        FinancePhase1OperationService service = new FinancePhase1OperationService(jdbc, objectMapper());
 
         var request = new FinancePhase1Dtos.FeeSourceEditRequest(
             new BigDecimal("120.00"), "更正金额", 1);
@@ -225,7 +247,6 @@ class FinancePhase1OperationBehaviorTest {
             (Object[]) any());
     }
 
-    /** 头程作废等待权威来源事件，不能直接改财务副本。 */
     @Test
     void voidingNyexx2608180003DelegatesToFirstlegAndWaitsForEvent() throws Exception {
         JdbcTemplate jdbc = feeSourceJdbc("APPROVED", false, 2);
@@ -236,7 +257,7 @@ class FinancePhase1OperationBehaviorTest {
             .thenReturn(ApiResponse.success(new FirstlegFeeSourceClient.CommandResult(
                 "INBOUND_FEE", 700L, 3, "VOIDED", false)));
         FinancePhase1OperationService service = new FinancePhase1OperationService(
-            jdbc, objectMapper(), firstleg, "internal-token", mock(FinanceFeeSourceReadRepository.class));
+            jdbc, objectMapper(), firstleg, "internal-token");
 
         FeeSourceDetail result = service.voidFinanceFeeSource(88L, 71L, "finance",
             "void-key", new FinancePhase1Dtos.FeeSourceActionRequest("测试作废", 2));
@@ -257,7 +278,6 @@ class FinancePhase1OperationBehaviorTest {
             (Object[]) any());
     }
 
-    /** 审核以当前操作版本更新并追加同一记录的审计。 */
     @Test
     void reviewUsesExpectedVersionAndReturnsUpdatedDetail() throws Exception {
         JdbcTemplate jdbc = mock(JdbcTemplate.class);
@@ -269,6 +289,7 @@ class FinancePhase1OperationBehaviorTest {
             return List.of(mapper.mapRow(resultSet(review, false, version), 0));
         });
         when(jdbc.queryForObject(startsWith("SELECT COUNT(*)>0"), eq(Boolean.class), eq(88L), eq(3))).thenReturn(false);
+        when(jdbc.query(startsWith("SELECT created_at,action"), any(RowMapper.class), eq(9L), eq(88L))).thenReturn(List.of());
         when(jdbc.queryForList(startsWith("SELECT request_hash"), eq(9L), eq(71L),
             eq("FEE_SOURCE_REVIEW"), eq("review-key"))).thenReturn(List.of());
         when(jdbc.update(startsWith("INSERT INTO fin_idempotency_record"), eq(9L), eq(71L),
@@ -280,7 +301,7 @@ class FinancePhase1OperationBehaviorTest {
             eq(71L), eq("操作人 71"), any(), any())).thenReturn(1);
         when(jdbc.update(startsWith("UPDATE fin_idempotency_record SET status='SUCCEEDED'"),
             eq(88L), eq(9L), eq(71L), eq("FEE_SOURCE_REVIEW"), eq("review-key"))).thenReturn(1);
-        FinancePhase1OperationService service = new FinancePhase1OperationService(jdbc, objectMapper(), null, "", mock(FinanceFeeSourceReadRepository.class));
+        FinancePhase1OperationService service = new FinancePhase1OperationService(jdbc, objectMapper());
 
         FeeSourceDetail result = service.reviewFinanceFeeSource(88L, 71L, "review-key",
             new FinancePhase1Dtos.ReviewRequest("APPROVE", "核对无误", 0));
@@ -290,51 +311,6 @@ class FinancePhase1OperationBehaviorTest {
         verify(jdbc).update(startsWith("UPDATE fin_fee_source SET review_status="), eq("APPROVED"), eq("核对无误"), eq(88L), eq(0));
     }
 
-    /** 财务内部应收应付调整原费用记录，重复提交不能新增费用或重复记审计。 */
-    @ParameterizedTest
-    @ValueSource(strings = {"RECEIVABLE", "PAYABLE"})
-    void manualAdjustmentUpdatesOriginalFeeOnceAndChecksVersionAndFrozenState(String direction) throws Exception {
-        var jdbc = mock(JdbcTemplate.class);
-        var service = spy(new FinancePhase1OperationService(jdbc, objectMapper(), null, "", mock(FinanceFeeSourceReadRepository.class)));
-        var beforeJson = objectMapper().createObjectNode().put("feeSourceId", 88).put("sourceSystem", "FINANCE")
-            .put("sourceType", "MANUAL").put("sourceFeeId", 700).put("sourceVersion", 1).put("customerId", 9)
-            .put("direction", direction).put("amount", 100).put("currency", "CNY").put("operationVersion", 2)
-            .put("reviewStatus", "APPROVED").put("sourceStatus", "AVAILABLE").put("statementGenerated", false);
-        var before = objectMapper().treeToValue(beforeJson, FeeSourceDetail.class);
-        var after = objectMapper().treeToValue(beforeJson.deepCopy().put("amount", 120)
-            .put("operationVersion", 3).put("reviewStatus", "DRAFT"), FeeSourceDetail.class);
-        doReturn(before, after).when(service).getFinanceFeeSource(88L);
-        lenient().when(jdbc.update(startsWith("UPDATE fin_fee_source SET amount="), eq(new BigDecimal("120.00")), eq(88L), eq(2), eq("APPROVED")))
-            .thenReturn(1, 0);
-        var request = new FinancePhase1Dtos.FeeSourceEditRequest(new BigDecimal("120.00"), "调整金额", 2);
-        var result = service.editFinanceFeeSource(88, 71, "adjust-once", request, true);
-        assertThat(result.feeSourceId()).isEqualTo(88);
-        assertThat(result.sourceFeeId()).isEqualTo(700);
-        assertThat(result.direction()).isEqualTo(direction);
-        assertThat(result.amount()).isEqualByComparingTo("120");
-        assertThat(result.operationVersion()).isEqualTo(3);
-        var hash = org.mockito.ArgumentCaptor.forClass(String.class);
-        verify(jdbc).update(startsWith("INSERT INTO fin_idempotency_record"), eq(9L), eq(71L),
-            eq("FEE_SOURCE_ADJUST"), eq("adjust-once"), hash.capture());
-        lenient().when(jdbc.queryForList(startsWith("SELECT request_hash"), eq(9L), eq(71L), eq("FEE_SOURCE_ADJUST"), eq("adjust-once")))
-            .thenReturn(List.of(java.util.Map.of("request_hash", hash.getValue(), "status", "SUCCEEDED", "result_resource_id", 88L)));
-        assertThat(service.editFinanceFeeSource(88, 71, "adjust-once", request, true)).isEqualTo(after);
-        verify(jdbc, times(1)).update(startsWith("UPDATE fin_fee_source SET amount="), eq(new BigDecimal("120.00")), eq(88L), eq(2), eq("APPROVED"));
-        verify(jdbc, times(1)).update(startsWith("INSERT INTO fin_audit_log"), eq(9L), eq("FIN_FEE_SOURCE"), eq(88L),
-            eq("FEE_SOURCE_ADJUST"), eq("调整金额"), anyString(), anyString(), eq(71L), anyString(), any(), any());
-        verify(jdbc, never()).update(startsWith("INSERT INTO fin_fee_source"), any(Object[].class));
-        assertThatThrownBy(() -> service.editFinanceFeeSource(88, 71, "adjust-once",
-            new FinancePhase1Dtos.FeeSourceEditRequest(new BigDecimal("121.00"), "调整金额", 2), true))
-            .isInstanceOf(FinanceEventException.class).hasMessageContaining("Idempotency-Key已用于其他请求");
-        assertThatThrownBy(() -> service.editFinanceFeeSource(88, 71, "stale-version", request, true))
-            .isInstanceOf(FinanceEventException.class).hasMessageContaining("状态或版本");
-        doReturn(objectMapper().treeToValue(beforeJson.deepCopy().put("statementGenerated", true), FeeSourceDetail.class))
-            .when(service).getFinanceFeeSource(88L);
-        assertThatThrownBy(() -> service.editFinanceFeeSource(88, 71, "frozen", request, true))
-            .isInstanceOf(FinanceEventException.class).hasMessageContaining("已生成单据");
-    }
-
-    /** 准备指定来源版本的费用查询，不再模拟已迁入 Mapper 的审计查询。 */
     private static JdbcTemplate feeSourceJdbc(String reviewStatus, boolean included, int version) throws Exception {
         JdbcTemplate jdbc = mock(JdbcTemplate.class);
         when(jdbc.query(startsWith("SELECT * FROM fin_fee_source"), any(RowMapper.class), (Object[]) any())).thenAnswer(invocation -> {
@@ -342,6 +318,7 @@ class FinancePhase1OperationBehaviorTest {
             return List.of(mapper.mapRow(resultSet(reviewStatus, included, version), 0));
         });
         when(jdbc.queryForObject(startsWith("SELECT COUNT(*)>0"), eq(Boolean.class), eq(88L), eq(3))).thenReturn(false);
+        when(jdbc.query(startsWith("SELECT created_at,action"), any(RowMapper.class), eq(9L), eq(88L))).thenReturn(List.of());
         lenient().when(jdbc.queryForList(startsWith("SELECT request_hash"), eq(9L), eq(71L),
             eq("FEE_SOURCE_SETTLEMENT"), eq("include-key"))).thenReturn(List.of());
         return jdbc;

finance/src/test/java/com/baiyue/finance/FinancePlatformListContractTest.java

@@ -93,7 +93,7 @@ class FinancePlatformListContractTest {
         assertRecordFields(com.baiyue.finance.dto.ReconciliationStatementDtos.ReconciliationRevision.class,
             "operatorId", "operatorName");
         assertRecordFields(com.baiyue.finance.dto.FinanceSettlementDtos.SettlementTransaction.class,
-            "createdBy", "createdByName", "transactionNo");
+            "createdBy", "createdByName");
         assertRecordFields(com.baiyue.finance.dto.FinanceSettlementDtos.SettlementRevision.class,
             "operatorId", "operatorName");
         assertRecordFields(com.baiyue.finance.dto.FinanceSettlementDtos.SettlementSummary.class,

finance/src/test/java/com/baiyue/finance/FinanceSettlementBehaviorTest.java

@@ -236,8 +236,8 @@ class FinanceSettlementBehaviorTest {
             eq("SETTLEMENT_PAYMENT_CREATE"), eq("pay-key"))).thenReturn(List.of());
         when(jdbc.queryForList(startsWith("SELECT s.id,s.tenant_id,s.settlement_no"), eq(88L))).thenReturn(List.of(after));
         when(jdbc.queryForList(startsWith("SELECT f.id fee_source_id"), eq(10L), eq(88L))).thenReturn(List.of());
-        when(jdbc.queryForList(startsWith("SELECT id,transaction_no,transaction_type"), eq(10L), eq(88L))).thenReturn(List.of(Map.ofEntries(
+        when(jdbc.queryForList(startsWith("SELECT id,transaction_type"), eq(10L), eq(88L))).thenReturn(List.of(Map.ofEntries(
-            Map.entry("id", 501L), Map.entry("transaction_no", "PAY202610210001"), Map.entry("transaction_type", "PAYMENT"),
+            Map.entry("id", 501L), Map.entry("transaction_type", "PAYMENT"),
             Map.entry("transaction_date", Date.valueOf(LocalDate.of(2026, 8, 11))),
             Map.entry("amount", new BigDecimal("40.00")), Map.entry("method", "BANK_TRANSFER"),
             Map.entry("reference_no", "BANK-1"), Map.entry("voucher_file_ids", "[\"91\"]"),
@@ -258,7 +258,6 @@ class FinanceSettlementBehaviorTest {
         assertThat(result.transactions()).singleElement().extracting(transaction -> transaction.transactionType())
             .isEqualTo("PAYMENT");
         assertThat(result.transactions().get(0).createdByName()).isEqualTo("platform_admin");
-        assertThat(result.transactions().get(0).transactionNo()).isEqualTo("PAYMENT".equals(result.transactions().get(0).transactionType()) ? "PAY202610210001" : null);
         verify(jdbc).update(startsWith("UPDATE fin_settlement SET paid_amount"),
             any(), any(), any(), any(), any(), any(), any(), any());
     }
@@ -523,7 +522,6 @@ class FinanceSettlementBehaviorTest {
             .isEqualTo("RECEIPT");
         assertThat(result.transactions().get(0).amount()).isEqualByComparingTo("40.00");
         assertThat(result.transactions().get(0).createdByName()).isEqualTo("platform_admin");
-        assertThat(result.transactions().get(0).transactionNo()).isEqualTo("PAYMENT".equals(result.transactions().get(0).transactionType()) ? "PAY202610210001" : null);
     }
 
     @Test
@@ -625,15 +623,8 @@ class FinanceSettlementBehaviorTest {
         org.mockito.Mockito.lenient().when(documentNumbers.next("AR")).thenReturn("AR202608180001");
         org.mockito.Mockito.lenient().when(documentNumbers.next("AP")).thenReturn("AP202608180001");
         org.mockito.Mockito.lenient().when(documentNumbers.next("PAY")).thenReturn("PAY202608180001");
-        // 既有业务测试保留JDBC替身，新详情路径通过真实Repository和Mapper接口适配执行。
-        var mapper = org.mockito.Mockito.mock(com.baiyue.finance.mapper.FinanceSettlementDetailMapper.class, invocation -> {
-            var select = invocation.getMethod().getAnnotation(org.apache.ibatis.annotations.Select.class);
-            if (select == null) return RETURNS_DEFAULTS.answer(invocation);
-            String sql = String.join(" ", select.value()).replaceAll("#\\{[a-zA-Z]+\\}", "?");
-            return jdbc.queryForList(sql, invocation.getArguments());
-        });
         return new FinanceSettlementService(jdbc, new ObjectMapper().findAndRegisterModules(),
-            new FinanceVoucherValidator(fileClient, "internal-token"), supplierValidator, documentNumbers, new com.baiyue.finance.repository.FinanceSettlementDetailRepository(mapper));
+            new FinanceVoucherValidator(fileClient, "internal-token"), supplierValidator, documentNumbers);
     }
 
     private static FinanceSupplierValidator supplierValidator() {
@@ -666,7 +657,7 @@ class FinanceSettlementBehaviorTest {
         when(jdbc.queryForList(startsWith("SELECT s.id,s.tenant_id,s.settlement_no"), eq(88L))).thenReturn(List.of(settlement));
         long customerId = ((Number) settlement.get("tenant_id")).longValue();
         when(jdbc.queryForList(startsWith("SELECT f.id fee_source_id"), eq(customerId), eq(88L))).thenReturn(List.of());
-        when(jdbc.queryForList(startsWith("SELECT id,transaction_no,transaction_type"), eq(customerId), eq(88L))).thenReturn(List.of());
+        when(jdbc.queryForList(startsWith("SELECT id,transaction_type"), eq(customerId), eq(88L))).thenReturn(List.of());
         when(jdbc.queryForList(startsWith("SELECT action,reason"), eq(customerId), eq(88L))).thenReturn(List.of());
     }
 

finance/src/test/java/com/baiyue/finance/FinanceSettlementDetailMapperTest.java

@@ -1,36 +0,0 @@
-package com.baiyue.finance;
-
-import com.baiyue.finance.mapper.FinanceSettlementDetailMapper;
-import com.baiyue.finance.repository.FinanceSettlementDetailRepository;
-import org.apache.ibatis.mapping.Environment;
-import org.apache.ibatis.session.Configuration;
-import org.apache.ibatis.session.SqlSessionFactoryBuilder;
-import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
-import org.junit.jupiter.api.Test;
-import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.datasource.DriverManagerDataSource;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class FinanceSettlementDetailMapperTest {
-    /** 真实执行付款查询，业务号必须来自本客户本结算的流水，空号不以其他字段替代。 */
-    @Test
-    void paymentNumbersRemainScopedToCustomerAndSettlement() {
-        var source = new DriverManagerDataSource("jdbc:h2:mem:settlement-number;MODE=MySQL;DB_CLOSE_DELAY=-1", "sa", "");
-        var jdbc = new JdbcTemplate(source);
-        jdbc.execute("CREATE TABLE fin_settlement_payment (id BIGINT PRIMARY KEY,tenant_id BIGINT,settlement_id BIGINT,transaction_no VARCHAR(32),transaction_type VARCHAR(32),transaction_date DATE,amount DECIMAL(18,2),method VARCHAR(32),reference_no VARCHAR(64),voucher_file_ids VARCHAR(255),created_by BIGINT,created_by_name VARCHAR(64),created_at TIMESTAMP,remark VARCHAR(255))");
-        jdbc.update("INSERT INTO fin_settlement_payment (id,tenant_id,settlement_id,transaction_no,transaction_type,reference_no) VALUES (1,10,20,'PAY202610210001','PAYMENT','BANK-1'),(2,11,20,'PAY202610210002','PAYMENT','BANK-2'),(3,10,21,'PAY202610210003','PAYMENT','BANK-3'),(4,10,22,NULL,'PAYMENT','BANK-4')");
-        var configuration = new Configuration(new Environment("test", new JdbcTransactionFactory(), source));
-        configuration.addMapper(FinanceSettlementDetailMapper.class);
-        try (var session = new SqlSessionFactoryBuilder().build(configuration).openSession()) {
-            var repository = new FinanceSettlementDetailRepository(session.getMapper(FinanceSettlementDetailMapper.class));
-            var rows = repository.payments(10, 20);
-            assertThat(rows).hasSize(1);
-            assertThat(rows.get(0).get("transaction_no")).isEqualTo("PAY202610210001");
-            assertThat(rows.get(0).get("reference_no")).isEqualTo("BANK-1");
-            assertThat(repository.payments(11, 21)).isEmpty();
-            assertThat(repository.payments(10, 22)).hasSize(1);
-            assertThat(repository.payments(10, 22).get(0).get("transaction_no")).isNull();
-        }
-    }
-}

finance/src/test/java/com/baiyue/finance/FinanceSettlementRequestHashTest.java

@@ -1,47 +0,0 @@
-package com.baiyue.finance;
-
-import com.baiyue.finance.service.FinanceSettlementService;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.ValueSource;
-import com.baiyue.finance.service.FinanceWalletService;
-import com.baiyue.finance.service.FinancePhase1OperationService;
-import com.baiyue.finance.service.FinanceService;
-import com.baiyue.finance.service.ReconciliationStatementService;
-import org.springframework.test.util.ReflectionTestUtils;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class FinanceSettlementRequestHashTest {
-    /** 模拟不同 JVM 的 Map 遍历顺序；同一付款请求必须得到相同摘要。 */
-    @ParameterizedTest
-    @ValueSource(classes = {FinanceSettlementService.class, FinanceWalletService.class,
-        FinancePhase1OperationService.class, FinanceService.class, ReconciliationStatementService.class})
-    void equivalentRequestsIgnoreMapIterationOrderButDetectChangedPayment(Class<?> serviceType) {
-        Object service = org.mockito.Mockito.mock(serviceType, org.mockito.Mockito.CALLS_REAL_METHODS);
-        ReflectionTestUtils.setField(service, "objectMapper", new ObjectMapper());
-        Map<String, Object> body = new LinkedHashMap<>();
-        body.put("amount", 190); body.put("expectedVersion", 0);
-        Map<String, Object> first = new LinkedHashMap<>();
-        first.put("path", "/settlements/202/transactions"); first.put("method", "POST");
-        first.put("customerId", 10L); first.put("body", body);
-        Map<String, Object> reversedBody = new LinkedHashMap<>();
-        reversedBody.put("expectedVersion", 0); reversedBody.put("amount", 190);
-        Map<String, Object> second = new LinkedHashMap<>();
-        second.put("body", reversedBody); second.put("customerId", 10L);
-        second.put("method", "POST"); second.put("path", "/settlements/202/transactions");
-
-        String original = ReflectionTestUtils.invokeMethod(service, "hash", first);
-        String reordered = ReflectionTestUtils.invokeMethod(service, "hash", second);
-        assertThat(reordered).isEqualTo(original);
-        reversedBody.put("amount", 191);
-        String changed = ReflectionTestUtils.invokeMethod(service, "hash", second);
-        assertThat(changed).isNotEqualTo(original);
-        second.put("customerId", 11L); reversedBody.put("amount", 190);
-        String otherCustomer = ReflectionTestUtils.invokeMethod(service, "hash", second);
-        assertThat(otherCustomer).isNotEqualTo(original);
-    }
-}

finance/src/test/java/com/baiyue/finance/PlatformFinanceWalletRefundControllerTest.java

@@ -1,54 +0,0 @@
-package com.baiyue.finance;
-
-import com.baiyue.common.security.AuthenticatedUser;
-import com.baiyue.finance.controller.PlatformFinanceWalletController;
-import com.baiyue.finance.dto.FinanceWalletDtos.WalletRefundRequest;
-import com.baiyue.finance.service.FinanceWalletService;
-import org.junit.jupiter.api.Test;
-import org.springframework.security.access.prepost.PreAuthorize;
-import java.math.BigDecimal;
-import java.util.Set;
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.*;
-
-/** 平台退款入口鉴权、必填原因和稳定幂等引用的回归。 */
-class PlatformFinanceWalletRefundControllerTest {
-    private final FinanceWalletService service = mock(FinanceWalletService.class);
-    private final PlatformFinanceWalletController controller = new PlatformFinanceWalletController(service);
-    private final WalletRefundRequest request = new WalletRefundRequest(new BigDecimal("12.00"), "退回多收费用");
-
-    /** 客户即使携带同名权限也不能借平台入口操作他人资金。 */
-    @Test void nonPlatformPrincipalsAreDeniedBeforeWalletAccess() {
-        for (var user : new AuthenticatedUser[]{null, user("CLIENT", 9L), user("PLATFORM", 9L)})
-            assertThatThrownBy(() -> controller.refund(user, 9, 1, "key", request))
-                .isInstanceOf(org.springframework.web.server.ResponseStatusException.class);
-        verifyNoInteractions(service);
-    }
-
-    /** 同一客户请求键生成同一退款引用，实际防重与金额上限仍由资金事务执行。 */
-    @Test void authorizedCallsUseStableReferenceAndExistingAdjustPermission() throws Exception {
-        controller.refund(user("PLATFORM", 0L), 9, 1, " key ", request);
-        controller.refund(user("PLATFORM", 0L), 9, 1, "key", request);
-        var reference = org.mockito.ArgumentCaptor.forClass(String.class);
-        verify(service, times(2)).refundConsumption(eq(9L), eq(1L), reference.capture(), eq("key"),
-            eq(request.amount()), eq(7L), isNull(), eq(request.reason()));
-        assertThat(reference.getAllValues()).allSatisfy(value -> assertThat(value).startsWith("MANUAL_REFUND:"));
-        assertThat(reference.getAllValues().get(0)).isEqualTo(reference.getAllValues().get(1));
-        assertThat(PlatformFinanceWalletController.class.getMethod("refund", AuthenticatedUser.class,
-            long.class, long.class, String.class, WalletRefundRequest.class).getAnnotation(PreAuthorize.class).value())
-            .isEqualTo("hasAuthority('platform:finance:customer-account:adjust')");
-    }
-
-    /** 空说明或非法幂等键在触达资金前失败。 */
-    @Test void missingReasonAndIdempotencyAreRejected() {
-        assertThatThrownBy(() -> controller.refund(user("PLATFORM", 0L), 9, 1, " ", request)).isInstanceOf(IllegalArgumentException.class);
-        assertThatThrownBy(() -> controller.refund(user("PLATFORM", 0L), 9, 1, "key",
-            new WalletRefundRequest(BigDecimal.ONE, " "))).isInstanceOf(IllegalArgumentException.class);
-        verifyNoInteractions(service);
-    }
-
-    private AuthenticatedUser user(String app, long tenant) {
-        return new AuthenticatedUser(7L, tenant, 0L, null, "finance", app, "WEB",
-            Set.of("platform:finance:customer-account:adjust"));
-    }
-}

finance/src/test/java/com/baiyue/finance/service/OverseasFeeWalletClosureTest.java

@@ -1,183 +0,0 @@
-package com.baiyue.finance.service;
-
-import com.baiyue.finance.client.FinanceFileClient;
-import com.baiyue.finance.dto.FinanceWalletDtos.*;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.h2.jdbcx.JdbcDataSource;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.datasource.DataSourceTransactionManager;
-import org.springframework.transaction.support.TransactionTemplate;
-
-import java.math.BigDecimal;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.time.LocalDate;
-import java.util.List;
-import java.util.UUID;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.regex.Pattern;
-
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.Mockito.*;
-
-/** 真实资金服务、隔离数据库及事务验证海外费用释放、实扣与重复操作。 */
-class OverseasFeeWalletClosureTest {
-    private JdbcTemplate jdbc;
-    private FinanceWalletService wallet;
-    private TransactionTemplate transaction;
-
-    /** 复用正式资金表定义，所有造数只进入本测试独立内存库。 */
-    @BeforeEach void setup() throws Exception {
-        var dataSource = new JdbcDataSource();
-        dataSource.setURL("jdbc:h2:mem:" + UUID.randomUUID() + ";MODE=MySQL;DATABASE_TO_LOWER=TRUE;DB_CLOSE_DELAY=-1");
-        jdbc = new JdbcTemplate(dataSource);
-        transaction = new TransactionTemplate(new DataSourceTransactionManager(dataSource));
-        var sql = Files.readString(Path.of("src/main/resources/db/finance.sql"));
-        for (var table : List.of("fin_wallet_account", "fin_wallet_hold", "fin_wallet_ledger", "fin_idempotency_record", "fin_audit_log")) {
-            var matcher = Pattern.compile("(?s)CREATE TABLE IF NOT EXISTS " + table + " \\(.*?\\) ENGINE=[^;]+;").matcher(sql);
-            assertThat(matcher.find()).as(table).isTrue();
-            // H2 使用同一列及约束，但去除 MySQL 引擎与更新时间自动生成，避免多列生成键差异。
-            var ddl = matcher.group().replaceAll("(?s) ENGINE=.*", "")
-                .replaceAll("(?i) UNSIGNED", "")
-                .replaceAll("(?i) ON UPDATE CURRENT_TIMESTAMP\\(3\\)", "")
-                .replaceAll("(?i) DEFAULT CURRENT_TIMESTAMP\\(3\\)", "")
-                .replaceAll("(?i)((?:created_at|updated_at) DATETIME\\(3\\)) NOT NULL", "$1 NULL");
-            jdbc.execute(ddl);
-        }
-        var numbers = mock(FinanceDocumentNumberGenerator.class);
-        var sequence = new AtomicInteger();
-        when(numbers.next(anyString())).thenAnswer(call -> "AC-TEST-" + sequence.incrementAndGet());
-        wallet = new FinanceWalletService(jdbc, new ObjectMapper().findAndRegisterModules(),
-            mock(FinanceFileClient.class), numbers, "test", "", "test", "test");
-        jdbc.update("INSERT INTO fin_wallet_account(customer_id,currency_code,actual_balance,frozen_balance,available_balance,credit_limit,credit_used,credit_frozen,credit_expires_on,version,created_by,updated_by) VALUES(9,'CNY',60,0,160,100,0,0,?,0,0,0)", LocalDate.now().plusDays(7));
-    }
-
-    /** 驳回后释放原冻结，实际余额和授信均恢复可用且不发生消费。 */
-    @Test void rejectionReleasesCashAndCreditExactlyOnce() {
-        freeze();
-        assertThat(wallet.account(9).frozenBalance()).isEqualByComparingTo("80.00");
-        assertThat(wallet.account(9).creditFrozen()).isEqualByComparingTo("20.00");
-        var request = new WalletHoldActionRequest("金额录错，驳回费用");
-        transaction.execute(status -> wallet.release(9, "OVERSEAS_MANUAL_FEE", "701-1", "release", request));
-        transaction.execute(status -> wallet.release(9, "OVERSEAS_MANUAL_FEE", "701-1", "release", request));
-        var account = wallet.account(9);
-        assertThat(account.actualBalance()).isEqualByComparingTo("60.00");
-        assertThat(account.frozenBalance()).isZero(); assertThat(account.creditFrozen()).isZero();
-        assertThat(account.availableBalance()).isEqualByComparingTo("160.00");
-        assertThat(count("CONSUMPTION")).isZero(); assertThat(count("UNFREEZE")).isEqualTo(1);
-    }
-
-    /** 扣款事务失败后可重试原请求，多次点击或不同请求键均不重复消费。 */
-    @Test void failedSettlementRollsBackAndRetryConsumesOnlyOnce() {
-        freeze();
-        var request = new WalletHoldActionRequest("审核通过扣款");
-        assertThatThrownBy(() -> transaction.execute(status -> {
-            wallet.settle(9, "OVERSEAS_MANUAL_FEE", "701-1", "settle", request);
-            throw new IllegalStateException("模拟扣款事务提交前异常");
-        })).hasMessageContaining("模拟扣款");
-        assertThat(wallet.account(9).actualBalance()).isEqualByComparingTo("60.00");
-        assertThat(count("CONSUMPTION")).isZero();
-        for (int repeat = 0; repeat < 3; repeat++)
-            transaction.execute(status -> wallet.settle(9, "OVERSEAS_MANUAL_FEE", "701-1", "settle", request));
-        assertThatThrownBy(() -> transaction.execute(status -> wallet.settle(9, "OVERSEAS_MANUAL_FEE", "701-1", "another-key", request)))
-            .hasMessageContaining("已处理");
-        assertThat(wallet.account(9).actualBalance()).isZero();
-        assertThat(wallet.account(9).creditUsed()).isEqualByComparingTo("20.00");
-        assertThat(wallet.account(9).frozenBalance()).isZero(); assertThat(count("CONSUMPTION")).isEqualTo(1);
-    }
-
-    /** 第一版错扣退回复用手工充值；原因、关联单号和操作人进入资金流水。 */
-    @Test void manualCreditRetainsCorrectionReasonAndReplaysWithoutDoubleCredit() {
-        var request = new AccountAdjustmentRequest("RECHARGE", new BigDecimal("12.00"), LocalDate.now(),
-            "OTHER", "TR-001 / 费用701", "退回多收操作费", 0);
-        var first = transaction.execute(status -> wallet.adjust(9, 7, "财务员", "correction-credit", request));
-        var second = transaction.execute(status -> wallet.adjust(9, 7, "财务员", "correction-credit", request));
-        assertThat(second.ledgerId()).isEqualTo(first.ledgerId());
-        assertThat(first.remark()).isEqualTo("退回多收操作费");
-        assertThat(first.referenceNo()).isEqualTo("TR-001 / 费用701");
-        assertThat(first.operatorName()).isEqualTo("财务员");
-        assertThat(wallet.account(9).actualBalance()).isEqualByComparingTo("72.00");
-        assertThat(count("RECHARGE")).isEqualTo(1);
-    }
-
-    /** 部分退款优先还授信，累计退款不能超过原消费，原消费事实保持不变。 */
-    @Test void linkedRefundRestoresCreditThenCashAndCannotExceedOriginalConsumption() {
-        freeze();
-        var hold = transaction.execute(status -> wallet.settle(9, "OVERSEAS_MANUAL_FEE", "701-1", "settle", new WalletHoldActionRequest("审核扣款")));
-        long original = hold.actionLedgerId();
-        var first = transaction.execute(status -> wallet.refundConsumption(9, original, "refund-1", "refund-key-1", new BigDecimal("25"), 7, "财务", "多收退款"));
-        var replay = transaction.execute(status -> wallet.refundConsumption(9, original, "refund-1", "refund-key-1", new BigDecimal("25"), 7, "财务", "多收退款"));
-        assertThat(replay.ledgerId()).isEqualTo(first.ledgerId());
-        assertThat(first.changeType()).isEqualTo("REFUND");
-        assertThat(first.sourceType()).isEqualTo("BUSINESS_REFUND");
-        assertThat(first.referenceNo()).isEqualTo(jdbc.queryForObject("SELECT business_no FROM fin_wallet_ledger WHERE id=?", String.class, original));
-        assertThat(wallet.account(9).creditUsed()).isZero();
-        assertThat(wallet.account(9).actualBalance()).isEqualByComparingTo("5.00");
-        assertThatThrownBy(() -> transaction.execute(status -> wallet.refundConsumption(9, original, "refund-1", "refund-key-1", BigDecimal.ONE, 7, "财务", "变更金额"))).hasMessageContaining("幂等");
-        assertThatThrownBy(() -> transaction.execute(status -> wallet.refundConsumption(9, original, "refund-too-much", "refund-too-much", new BigDecimal("56"), 7, "财务", "退款"))).hasMessageContaining("超过");
-        transaction.execute(status -> wallet.refundConsumption(9, original, "refund-2", "refund-key-2", new BigDecimal("55"), 7, "财务", "余款退款"));
-        assertThat(wallet.account(9).actualBalance()).isEqualByComparingTo("60.00");
-        assertThat(count("REFUND")).isEqualTo(2);
-        assertThat(count("CONSUMPTION")).isEqualTo(1);
-        assertThat(jdbc.queryForObject("SELECT amount FROM fin_wallet_ledger WHERE id=?", BigDecimal.class, original)).isEqualByComparingTo("-80.00");
-    }
-
-    /** 非消费流水、跨客户原流水及非正金额均不能改变余额。 */
-    @Test void linkedRefundRejectsWrongCustomerNonConsumptionAndInvalidAmount() {
-        freeze();
-        long frozenLedger = jdbc.queryForObject("SELECT id FROM fin_wallet_ledger WHERE change_type='FREEZE'", Long.class);
-        assertThatThrownBy(() -> transaction.execute(status -> wallet.refundConsumption(9, frozenLedger, "bad", "bad", BigDecimal.ONE, 7, "财务", "退款"))).hasMessageContaining("成功业务扣款");
-        var hold = transaction.execute(status -> wallet.settle(9, "OVERSEAS_MANUAL_FEE", "701-1", "settle", new WalletHoldActionRequest("扣款")));
-        jdbc.update("INSERT INTO fin_wallet_account(customer_id,currency_code,actual_balance,frozen_balance,available_balance,credit_limit,credit_used,credit_frozen,version,created_by,updated_by) VALUES(10,'CNY',0,0,0,0,0,0,0,0,0)");
-        assertThatThrownBy(() -> transaction.execute(status -> wallet.refundConsumption(10, hold.actionLedgerId(), "wrong-customer", "wrong-customer", BigDecimal.ONE, 7, "财务", "退款"))).hasMessageContaining("不存在");
-        assertThatThrownBy(() -> transaction.execute(status -> wallet.refundConsumption(9, hold.actionLedgerId(), "zero", "zero", BigDecimal.ZERO, 7, "财务", "退款"))).isInstanceOf(RuntimeException.class);
-        assertThatThrownBy(() -> transaction.execute(status -> wallet.refundConsumption(9, hold.actionLedgerId(), "blank", "blank", BigDecimal.ONE, 7, "财务", " "))).hasMessageContaining("原因");
-        assertThat(count("REFUND")).isZero();
-        assertThat(wallet.account(9).creditUsed()).isEqualByComparingTo("20.00");
-        assertThat(wallet.account(10).actualBalance()).isZero();
-    }
-
-    /** 不同请求键的并发退款同样受原消费可退余额约束。 */
-    @Test void concurrentRefundsSerializeOnAccountAndNeverOverRefund() throws Exception {
-        freeze();
-        var hold = transaction.execute(status -> wallet.settle(9, "OVERSEAS_MANUAL_FEE", "701-1", "settle", new WalletHoldActionRequest("扣款")));
-        var start = new java.util.concurrent.CountDownLatch(1);
-        var executor = java.util.concurrent.Executors.newFixedThreadPool(2);
-        try {
-            var results = new java.util.ArrayList<java.util.concurrent.Future<Boolean>>();
-            for (int i = 0; i < 2; i++) {
-                final String reference = "concurrent-" + i;
-                results.add(executor.submit(() -> {
-                    start.await();
-                    try {
-                        transaction.execute(status -> wallet.refundConsumption(9, hold.actionLedgerId(), reference, reference, new BigDecimal("50"), 7, "财务", "并发退款"));
-                        return true;
-                    } catch (FinanceEventException ex) {
-                        assertThat(ex.code()).isEqualTo("FIN-WALLET-REFUND-EXCEEDED");
-                        return false;
-                    }
-                }));
-            }
-            start.countDown();
-            int succeeded = 0;
-            for (var result : results) if (result.get(10, java.util.concurrent.TimeUnit.SECONDS)) succeeded++;
-            assertThat(succeeded).isEqualTo(1);
-            assertThat(count("REFUND")).isEqualTo(1);
-            assertThat(wallet.account(9).actualBalance()).isEqualByComparingTo("30.00");
-        } finally { executor.shutdownNow(); }
-    }
-
-    /** 冻结始终沿用同一海外费用业务身份。 */
-    private void freeze() {
-        transaction.execute(status -> wallet.freeze(9, "freeze", new WalletFreezeRequest(
-            new BigDecimal("80.00"), "OVERSEAS_MANUAL_FEE", "701-1", "海外费用")));
-    }
-
-    /** 按真实流水类型统计资金影响，避免只检查服务返回状态。 */
-    private int count(String type) {
-        return jdbc.queryForObject("SELECT COUNT(*) FROM fin_wallet_ledger WHERE customer_id=9 AND change_type=?", Integer.class, type);
-    }
-}

firstleg/docs/business-index.md

@@ -42,7 +42,7 @@
 | 财务费用来源快照 | `controller/InternalFinanceFeeSourceController.java`；入库费用与柜次费用分别按来源 ID、版本向 Finance 提供不可变快照 |
 | 柜次费用明细与跨客户分摊组 | `controller/PlatformContainerFeeDetailController.java`、`service/ContainerFeeDetailService.java`、`dto/ContainerFeeDetailDtos.java`；跨客户公共柜费使用 `allocation-groups` 按柜内真实客户和订单原子分摊，入仓 ID/入仓码同时填写或同时留空；各行金额合计必须等于原始柜费，审核、驳回、调整、作废均整组处理，单行入口拒绝分摊组；契约 `src/main/resources/openapi/container-fees-v1.yaml`；Admin 消费端见 `../../apps/admin-web/src/modules/loading-lists/api/containerFees.ts` |
 | 财务整柜成本分摊快照 | `loading/controller/InternalFinanceCostSnapshotController.java`、`loading/service/FinanceCostSnapshotService.java` |
-| 分柜、预装、真实柜号后补与正式装柜清单生命周期 | `split/controller/PlatformSplitPreloadController.java`、`controller/PlatformLoadingListController.java`、`service/LoadingListService.java`；契约 `src/main/resources/openapi/loading-lists-v1.yaml`，详情阶段先查 `/loading-plans/{planId}/lifecycle`。创建柜次时原子生成唯一预装计划，加入入仓码明细时同步创建入库预装聚合与关联，不设推送步骤；同一 `planId` 在 `EDITING/LOADING` 返回 `PRELOAD`，`COMPLETED` 返回 `LOADING_LIST`。订单协作备注以 Order 为权威，`OrderRemarksSyncService` 负责订单列表与全部未冻结预装明细双向同步，完成装柜后保留冻结快照。订舱关联允许真实集装箱号暂缺；确认预装和创建 PDA task 前必须补齐非空柜号，不按 ISO 格式阻断；可在 `EDITING/LOADING` 首次补录，PDA 完成前再次校验；已有值纠正仅限 `EDITING` 且任务未领取、无物理作业事实 |
+| 分柜、预装、真实柜号后补与正式装柜清单生命周期 | `split/controller/PlatformSplitPreloadController.java`、`controller/PlatformLoadingListController.java`、`service/LoadingListService.java`；契约 `src/main/resources/openapi/loading-lists-v1.yaml`，详情阶段先查 `/loading-plans/{planId}/lifecycle`。创建柜次时原子生成唯一预装计划，加入入仓码明细时同步创建入库预装聚合与关联，不设推送步骤；同一 `planId` 在 `EDITING/LOADING` 返回 `PRELOAD`，`COMPLETED` 返回 `LOADING_LIST`。订单协作备注以 Order 为权威，`OrderRemarksSyncService` 负责订单列表与全部未冻结预装明细双向同步，完成装柜后保留冻结快照。订舱关联、预装确认和 PDA task 创建不依赖真实集装箱号；可在 `EDITING/LOADING` 首次补录，最终 PDA 完成前必须存在；已有值纠正仅限 `EDITING` 且任务未领取、无物理作业事实 |
 | 同柜不可拆组 | `loading/coload/controller/PlatformColoadGroupController.java`、`service/ColoadGroupService.java`、`persistence/ColoadGroupMapper.java`；契约 `src/main/resources/openapi/coload-groups-v1.yaml`。请求按订单 ID 建组，服务端允许待审核、待测量/测量中、待分柜及装柜中订单，冻结每票全部有效入仓片段与满箱数；成员全部未进柜时创建未锁定组，成员已满箱进入同一装柜计划时直接创建锁定组，部分占用或跨柜时拒绝；仅要求同国内仓、同渠道，允许跨客户及不同目的仓港；分配、移除、取消均保持整组原子 |
 | 货柜与全局智能排柜 | `controller/PlatformContainerController.java`、`PlatformSmartLoadingController.java`、`service/SmartLoadingService.java`、`repository/SmartLoadingRepository.java`、`client/PendingReviewOrderClient.java`、`loading/`；全局候选合并本服务履约投影与 Order `/internal/order/v1/pending-review-orders` 权威待审核页，工作台柜次从 `/inbound-candidates`、`/containers` 进入；普通箱数、待审核占位、同柜组和全部未拣移除分别走 `/inbound-assignments`、`/pending-review-assignments`、`/group-assignments`、`/unpicked-items`，明细规格拆分留在服务端 |
 | 货柜资料、PDA 证据与业务总览 | `controller/PlatformContainerController.java` 的 `/{id}/overview`、`/{id}/documents/{documentType}`，聚合 `mapper/ContainerOverviewMapper.java`；契约 `src/main/resources/openapi/phase3-container-overview-v1.yaml`，四类资料固定为目的港清关、国内出口报关、DO、PU 的当前唯一版本 |
@@ -58,7 +58,7 @@
 | 目的港码头拖车与还空预警 | `terminaldrayage/controller/PlatformTerminalDrayageController.java`、`service/TerminalDrayageService.java`、`mapper/TerminalDrayageMapper.java`；货柜实际到港后引用 Warehouse `ACTIVE/TRUCKING/OVERSEAS` 海外车队供应商，依次选择车队、预约提柜、确认实际提柜，海外仓卸柜或全部直送目的仓实际卸货完成后确认还柜；服务端按卸柜完成时间加 72 小时返回报空预警，实际提柜和还柜通过现有 `CarrierScheduleQueryService` 推进 `PICKED_UP/EMPTY_RETURNED`，不复制船节点或车队主档。契约 `src/main/resources/openapi/terminal-drayage-v1.yaml`，基线 `src/main/resources/db/phase3-terminal-drayage-schema.sql` 邮件由 `terminaldrayage/service/TerminalDrayageMailService.java` 入队，`TerminalDrayageMailDispatcher.java` 顺序投递，模板与 SMTP 配置见 `docs/terminal-drayage-mail.md`；首次选队不发信，换队事务内生成取消与请求两封邮件。 |
 | 船节点交接事件 | `portschedule/service/CarrierScheduleNodeOutboxService.java`；实际节点落库后按 `containerBookingId` 柜级发布 `FIRST_LEG_CONTAINER_SHIPPING_NODE_RECORDED` V1，信封固定使用 `tenantId=0` 平台技术范围且 Payload 不携带客户，复用 `LoadingCompletedOutboxRepository`/Relay 直投 Lastleg `/internal/lastleg/events`；消费见 `../lastleg-service/src/main/java/com/baiyue/lastleg/shipping/service/ContainerShippingNodeConsumer.java`，ACK/重试按 `../../docs/统一认证与服务通信契约.md` |
 | Firstleg 业务单据编号 | `service/FirstlegDocumentNumberGenerator.java`；前缀与生成规则见 `../../../docs/业务单据编号契约.md`，柜次及实物标签规则保持不变 |
-| 订舱级拖车与整柜出仓调度 | `controller/PlatformTruckAppointmentController.java` 的 `/candidates`、`service/TruckAppointmentService.java`、`repository/TruckAppointmentRepository.java`、`outbound/dispatch/controller/PlatformOutboundDispatchController.java`；拖车契约 `src/main/resources/openapi/truck-appointments-v1.yaml`。预约只绑定 `RELEASED` 订舱，候选排除缺提单号或已有非终态预约的订舱；创建及派车不要求订舱文件；API 不含客户、柜次、装柜计划或真实柜号，每订舱最多一张有效预约，已有完成单不得重建收费；PDA 完成不推进拖车状态，全部要求货柜确认国内离仓后由 `TruckAppointmentCompletionService` 自动完成并经 `TruckAppointmentFeeService` 发布应付 |
+| 订舱级拖车与整柜出仓调度 | `controller/PlatformTruckAppointmentController.java` 的 `/candidates`、`service/TruckAppointmentService.java`、`repository/TruckAppointmentRepository.java`、`outbound/dispatch/controller/PlatformOutboundDispatchController.java`；拖车契约 `src/main/resources/openapi/truck-appointments-v1.yaml`。预约只绑定 `RELEASED` 订舱，候选排除缺提单/有效订舱文件或已有非终态预约的订舱；API 不含客户、柜次、装柜计划或真实柜号，每订舱最多一张有效预约，已有完成单不得重建收费；PDA 完成不推进拖车状态，全部要求货柜确认国内离仓后由 `TruckAppointmentCompletionService` 自动完成并经 `TruckAppointmentFeeService` 发布应付 |
 | 整柜出口报关 | `customs/container/controller/PlatformContainerCustomsController.java`、`customs/container/controller/MerchantContainerCustomsController.java`、`customs/container/service/ContainerCustomsService.java`、`customs/container/mapper/ContainerCustomsMapper.java`；装柜完成后按柜收集退税资料，多对多覆盖入仓码，开始报关冻结，完成文件逐资料一对一回传，全买单柜由平台确认并通过导出中心取明细；正式申报批次与海关结果在同一模块独立记录，不改报关四态、PDA 或船期事实；契约 `src/main/resources/openapi/customs-v1.yaml`，基线 `src/main/resources/db/phase3-container-customs-schema.sql`；消费者为 Admin `../../apps/admin-web/src/modules/container-loading/components/ContainerCustomsPanel.vue` 和 Client `../../apps/client-web/src/modules/first-leg/components/CustomsDocumentsDialog.vue` |
 | 买单订单明细导出 Provider | `customs/container/controller/LoadingListBuyDeclarationExportController.java`、`service/LoadingListBuyDeclarationExportService.java`；只为 File 导出中心提供 `LOADING_LIST_BUY_DECLARATION_ITEMS` 的已完成装柜实际买单行，不在 Firstleg 生成文件 |
 | 跨模型桥接 | `loading/bridge/controller/PlatformLoadingModelBridgeController.java` |
@@ -79,8 +79,8 @@
 - 客户箱规配置必须恰好保持四档且默认算法在四行一致；`ADD` 以实测尺寸为基准对三个维度分别增加命中箱规的尺寸值，`MULTIPLY` 使用当前客户唯一默认计费规则，并由服务端按规则中的规格档位选择系数。测量行必须保存实际尺寸、选用规则和算法快照，页面不得自行重算后覆盖服务端结果；计价使用用户确认的重量/体积选择值并纳入幂等请求哈希。
 - 报关、订舱和拖车引用的供应商必须通过 `WarehouseSupplierSnapshotService` 按 ID 向 Warehouse 校验：报关使用 `CUSTOMS`，订舱使用 `BOOKING`（不区分国内/国外 scope），国内拖车使用 `TRUCKING + truckingScope=DOMESTIC`，清关提柜/目的港码头拖车使用 `TRUCKING + truckingScope=OVERSEAS`；供应商必须为 `ACTIVE`。请求中的名称只能作为一致性提示，持久化名称必须来自 Warehouse 快照，禁止用自由文本绕过 ID、类别或启用状态校验。修改任一供应商引用 DTO、OpenAPI 或内部客户端时，必须同步检查三条业务链、Warehouse `supplier-v1.yaml`、数据库快照字段和对应契约测试。
 - Order 渠道变更门禁必须检查装柜或后续状态、PDA task、预装、分柜及同柜组兼容性；任何不确定结果均失败关闭。`ORDER_DECLARATION_UPDATED_V1` 消费必须校验订单号/入仓码归属，永久保留 `eventId + payload hash` 幂等历史并按版本单调更新申报投影；不得覆盖仓库实测、箱码、测量审核或已确认费用。
-- 订舱状态固定为 `DRAFT → RELEASED`：草稿允许资料不完整并可替换或删除，放舱时校验完整持久化聚合但不要求订舱附件，放舱后除预计到港外的运输、预报货量、三方和柜型需求只读；预计到港允许通过 `/estimated-arrival` 按编辑权限、版本与幂等键单独维护，保留前后审计快照且不得清空或早于预计开船，不改实际到港或计划到仓；三项实际货量允许通过 `OceanBookingService.updateActualCargo` 按编辑权限、版本、幂等键和原因补录并保存前后审计快照。创建草稿和放舱都只维护订舱聚合、三类参与方及柜型需求，不创建真实 `containerNo`、货柜行或分配关系；真实货柜只在后续提柜关联时占用已放舱柜型需求。
+- 订舱状态固定为 `DRAFT → RELEASED`：草稿允许资料不完整并可替换或删除，放舱时校验完整持久化聚合，放舱后永久只读。创建草稿和放舱都只维护订舱聚合、三类参与方及柜型需求，不创建真实 `containerNo`、货柜行或分配关系；真实货柜只在后续提柜关联时占用已放舱柜型需求。
-- 订舱柜型需求至少一项、最多 20 项，数量必须为正整数，容量和限重必须匹配平台柜型规格。起运仓必须是启用的国内中转仓；物流渠道必须来自该仓当前 ACTIVE 价格版本，服务端保存渠道名称快照，渠道失效时失败关闭。预计到港草稿可留空，放舱前必填且不得早于预计开船时间；关联柜次时带入柜级到港来源，供日历和默认到仓日期解析使用。
+- 订舱柜型需求至少一项、最多 20 项，数量必须为正整数，容量和限重必须匹配平台柜型规格。起运仓必须是启用的国内中转仓；物流渠道必须来自该仓当前 ACTIVE 价格版本，服务端保存渠道名称快照，渠道失效时失败关闭。
 - 订舱号遵循 `../../../docs/业务单据编号契约.md`；不得以实体 ID 拼接生成。提单号在订舱主表全局唯一，柜次表只保存快照；真实集装箱号只在同一订舱内唯一，不同提单允许复用。放舱不要求真实柜号，也不得为满足放舱校验伪造柜号。
 - 订舱列表 `containerCount` 固定为该订舱全部柜型需求 `quantity` 之和，与真实柜关联/解除无关；关联候选只返回 `RELEASED`、剩余数量大于 0 且 `warehouseId + channelCode + containerType` 精确匹配的需求，由服务端集合查询 ACTIVE 分配量。前端不得扇出详情计算或用已关联柜数覆盖该字段，最终关联命令仍须重验目标货柜可修改性。
 - 拖车预约是平台级订舱聚合，不是客户或柜次资源：请求、实体、查询、响应和附件不得恢复 `customerId/customerName`，公开 DTO 也不得出现 `containerBookingId/loadingPlanId/cabinetNo/containerNo`。创建候选只返回有提单号、ACTIVE `BOOKING_CONFIRMATION` 或 `BILL_OF_LADING` 且没有非终态拖车单的 `RELEASED` 订舱；创建或编辑只冻结订舱仓库/提单与 TRUCKING/DOMESTIC 国内拖车供应商快照。每订舱通过查询锁与唯一约束最多一张非终态预约，重复创建返回现有派车单号；PDA 装柜完成不得改变拖车状态；只有订舱全部柜型需求均已关联且每柜全部入仓绑定确认国内离仓，才自动完成（含草稿/晚提交）。离仓、拖车创建/编辑/操作统一先锁订舱，完成状态、`AUTO_COMPLETE` 历史、按实装体积守恒分摊的柜次应付及 Finance Outbox 同事务落库；取消/异常单不自动恢复，已有有效或完成单不得重复创建。应付拖车费仅人民币 RMB（财务快照为 CNY），固定使用 `FEE_TYPE_108`，关联 ACTIVE/TRUCKING/DOMESTIC 供应商，零金额不生成费用；正金额缺归属、有效体积或费用配置时失败关闭，不丢费、不伪造均分。手工 DEPART/COMPLETE 动作已移除。附件使用 `tenantId=0 + TRUCK_APPOINTMENT_ATTACHMENT + appointmentId`，提单文件继续归订舱。
@@ -94,7 +94,7 @@
 
 ## 国内货柜履约装柜与 PDA 资源结算
 
-- 新增模拟柜只保存智能装柜的 9 类计划渠道 channel_group_code；未关联已放舱订舱时 channel_code/channel_name 为空，关联后才冻结订舱的实际渠道。智能装柜全局工作台和订舱关联候选均按计划渠道组匹配；服务端把业务渠道分组映射为实际渠道，并分别分页查询候选与 `WAIT_LOADING/EDITING/LOADING` 柜次；候选支持按创建日期和预计到货日期闭区间筛选，状态筛选使用最多四项的 `orderStatuses`，未传表示 `PENDING_REVIEW/WAIT_MEASURE/WAIT_SPLIT/LOADING` 全部未完成状态。状态只用于搜索和展示，能否加入以响应 `canAssign` 为准，由有效柜次占用、剩余箱数、容量、组锁和版本等事实决定；人工加入允许订单国内仓及渠道与柜次不同，智能推荐允许跨国内仓但仍只选择柜次渠道。容积和重量均允许达到柜型额定值的 150%，超过即拒绝。待审核事实必须经 `PendingReviewOrderClient` 重新核验 Order 权威 `SUBMITTED` 订单，待审核或待测量可先占位，但确认预装和启动 PDA 前仍必须进入 `WAIT_SPLIT`。计划明细通过 `totalPackageCount/remainingPackageCount` 返回可调总量和余量：测量前取 Order 原始申报箱数，进入 `WAIT_SPLIT/LOADING` 后取最新已审核测量箱数；只读补充失败时保守回退当前已分配数，调整写入仍重新查询并校验权威数量。同柜不可拆组只有全部成员命中状态集合时才返回，且必须成员完整、满箱并作为单个分页与分配单元，不能跨页或拆分。一次性移除未拣明细时，普通未拣项直接移除；同柜组仅全组未拣时整组移除，任一成员已拣则整组保留，单事务只递增一次计划版本。推荐顺序按入库时间先进先出。真实集装箱号允许在关联已放舱订舱时暂缺；关联、运输修改和提柜补录统一只规范化空白和大小写，不以 ISO 长度、结构、设备类别或校验位阻断，数据库不设置 ISO 格式 CHECK，仍遵守同订舱唯一及已有柜号一致性。确认预装、创建 PDA 任务和 PDA 完成只要求真实柜号非空，不再校验 ISO 格式；跨服务装柜、船节点和卸柜事件统一接受非 ISO 柜号，冻结事实仍要求柜号已规范化且与来源柜一致。运输纠错继续遵守原因、版本及 PDA 领取和物理作业冻结限制。确认预装及创建 PDA 任务前必须补齐；历史已建但缺号的 PDA 任务可在预装详情首次补录，补录后按柜次当前真实集装箱号恢复作业。装柜计划状态为 `EDITING -> LOADING -> COMPLETED`，PDA 全部明细处理完成后自动完成。
+- 新增模拟柜只保存智能装柜的 9 类计划渠道 channel_group_code；未关联已放舱订舱时 channel_code/channel_name 为空，关联后才冻结订舱的实际渠道。智能装柜全局工作台和订舱关联候选均按计划渠道组匹配；服务端把业务渠道分组映射为实际渠道，并分别分页查询候选与 `WAIT_LOADING/EDITING/LOADING` 柜次；候选支持按创建日期和预计到货日期闭区间筛选，状态筛选使用最多四项的 `orderStatuses`，未传表示 `PENDING_REVIEW/WAIT_MEASURE/WAIT_SPLIT/LOADING` 全部未完成状态。状态只用于搜索和展示，能否加入以响应 `canAssign` 为准，由有效柜次占用、剩余箱数、容量、组锁和版本等事实决定；人工加入允许订单国内仓及渠道与柜次不同，智能推荐允许跨国内仓但仍只选择柜次渠道。容积和重量均允许达到柜型额定值的 150%，超过即拒绝。待审核事实必须经 `PendingReviewOrderClient` 重新核验 Order 权威 `SUBMITTED` 订单，待审核或待测量可先占位，但确认预装和启动 PDA 前仍必须进入 `WAIT_SPLIT`。计划明细通过 `totalPackageCount/remainingPackageCount` 返回可调总量和余量：测量前取 Order 原始申报箱数，进入 `WAIT_SPLIT/LOADING` 后取最新已审核测量箱数；只读补充失败时保守回退当前已分配数，调整写入仍重新查询并校验权威数量。同柜不可拆组只有全部成员命中状态集合时才返回，且必须成员完整、满箱并作为单个分页与分配单元，不能跨页或拆分。一次性移除未拣明细时，普通未拣项直接移除；同柜组仅全组未拣时整组移除，任一成员已拣则整组保留，单事务只递增一次计划版本。推荐顺序按入库时间先进先出。真实集装箱号允许在关联已放舱订舱时暂缺，但确认预装及创建 PDA 任务前必须补齐；历史已建但缺号的 PDA 任务可在预装详情首次补录，补录后按柜次当前真实集装箱号恢复作业。装柜计划状态为 `EDITING -> LOADING -> COMPLETED`，PDA 全部明细处理完成后自动完成。
 - 预装进入 `CONFIRMING/CONFIRMED` 只固化确认快照，不得锁死尚未完成柜次的智能装柜分配；装柜计划仍处于 `EDITING/LOADING` 时可继续新增，未产生实物拣货的明细可调整或移除，已拣明细保持锁定。一件代发智能装柜候选以每个未被有效柜次占用的已封托托盘为独立分页、展示和分配单位；同一入仓单有多托时必须逐托返回，其中一托已分配不得隐藏或禁用其余未分配托盘。智能推荐必须逐个调用整托分配，容量不足时跳过整托，不得回退按箱分配；全局工作台传入当前 `customerId/inboundCode` 筛选范围时，服务端只能推荐同时命中的候选，同一次推荐按受影响客户统一重算费用，不得逐托重复重算。单行删除必须按该行 `palletId` 整托移除。装柜完成事件必须按计划项 `palletId` 精确冻结每托箱唛与 SKU 清单，不得仅按入仓单或货物明细关联而造成多托交叉重复。
 - 客户入库费用只在登录客户范围、测量审核通过、`feeStatus=SENT` 且存在已发布明细时可见；确认必须具备 `merchant:order:edit`，携带当前 `expectedFeeVersion` 与幂等键。成功后记录确认成员和时间；客户未确认或该票尚未装柜完成时，平台仍可修改箱规规则、生成新费用版本并重新发送，新版本必须清空旧版客户确认快照。仅当“客户已确认且该票已装柜完成”同时成立时最终冻结；装柜完成不得代替客户自动确认。旧版本、未发送或重复异参确认均返回冲突，不做兼容覆盖。
 - PDA 普通散箱拣货以 `fl_inbound_carton_label.box_code` 对应的稳定箱唛箱码为扫描身份；审核建单、重复打印、手工测量和墨家测量复用同一映射，版本字段只用于并发控制，不进入扫码文本。一个有效且未重复的箱码扫描表示拣出一箱，不得以 SKU、商品件数、入库单号或页面展示字段替代箱码。一件代发已封托的 `SEALED_PALLET` 是不可拆整托单元，PDA 可扫描计划快照中的 `palletNo`、用该托任一成员 `boxCode` 反查所属整托，也可在明细卡片手工确认整托；三种入口最终都必须携带权威 `palletNo` 以 `PICK_PALLET` 一次性提交，不能按成员箱逐箱累计、部分拣货或跳拣。PDA 首页从 Warehouse 主档选择启用国内仓，一件代发与装柜待办列表必须按所选 `warehouseId` 服务端过滤；装柜任务内部仍允许跨国内仓，仓库与渠道限制统一由上游装柜编排负责，PDA 只按已生成任务读取各入仓单自身的 `CONFIRMED` 库位资源，不得再用柜次仓库过滤任务明细、库存快照或拣货写入。任务下发与提交契约见 `src/main/resources/openapi/phase3-pda-convergence-v1.yaml`。

firstleg/src/main/java/com/baiyue/firstleg/controller/InternalFeeCatalogController.java

@@ -1,58 +0,0 @@
-package com.baiyue.firstleg.controller;
-
-import com.baiyue.common.core.api.ApiResponse;
-import com.baiyue.common.core.api.ResultCode;
-import com.baiyue.common.core.exception.BizException;
-import com.baiyue.firstleg.service.SharedFeeCatalogService;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.RequestHeader;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
-import org.springframework.web.bind.annotation.RestController;
-
-import java.nio.charset.StandardCharsets;
-import java.security.MessageDigest;
-import java.util.List;
-
-/** 公共费用目录内部只读入口，禁止借用平台员工令牌跨服务查询。 */
-@RestController
-@RequestMapping("/internal/firstleg/v1/fee-items")
-public class InternalFeeCatalogController {
-    private final SharedFeeCatalogService service;
-    private final byte[] expectedToken;
-
-    /** 绑定费用目录服务与内部身份凭证，空凭证始终拒绝访问。 */
-    public InternalFeeCatalogController(SharedFeeCatalogService service,
-        @Value("${baiyue.security.internal-service-token:}") String token) {
-        this.service = service;
-        this.expectedToken = token.getBytes(StandardCharsets.UTF_8);
-    }
-
-    /** 返回适用海外仓收付方向的启用项目。 */
-    @GetMapping
-    public ApiResponse<List<SharedFeeCatalogService.Item>> list(
-        @RequestHeader(value = "X-Internal-Service-Token", required = false) String token,
-        @RequestParam(defaultValue = "RECEIVABLE") String direction) {
-        requireToken(token);
-        return ApiResponse.success(service.list(direction));
-    }
-
-    /** 在费用创建时验证实时项目资格。 */
-    @GetMapping("/{code}")
-    public ApiResponse<SharedFeeCatalogService.Item> detail(
-        @RequestHeader(value = "X-Internal-Service-Token", required = false) String token,
-        @PathVariable String code, @RequestParam String direction) {
-        requireToken(token);
-        return ApiResponse.success(service.requireActive(code, direction));
-    }
-
-    /** 使用常量时间比较内部凭证，未配置凭证时关闭入口。 */
-    private void requireToken(String token) {
-        if (expectedToken.length == 0 || token == null
-            || !MessageDigest.isEqual(expectedToken, token.getBytes(StandardCharsets.UTF_8))) {
-            throw new BizException(ResultCode.FORBIDDEN, "内部服务凭证无效");
-        }
-    }
-}

firstleg/src/main/java/com/baiyue/firstleg/customs/container/service/ContainerCustomsService.java

@@ -211,7 +211,6 @@ public class ContainerCustomsService {
         return platformView(planId);
     }
 
-    /** 全部预录单经客户确认后发送报关行执行，保留版本与发送状态校验。 */
     @Transactional
     public ContainerView submitToBroker(long planId, long operatorId, String operatorName, String key, ActionRequest request) {
         String action = "SUBMIT_CUSTOMS_TO_BROKER_" + planId;
@@ -222,8 +221,8 @@ public class ContainerCustomsService {
         ContainerRow container = mapper.lockContainer(planId);
         if (container == null || !DECLARING.equals(container.status())) throw conflict("当前柜不在报关中");
         if (!Objects.equals(container.version(), request.expectedVersion())) throw concurrent();
-        if (mapper.taxRefundCount(container.loadingPlanId()) == 0) throw conflict("全买单柜无需发送预录单确认结果给报关行");
+        if (mapper.taxRefundCount(container.loadingPlanId()) == 0) throw conflict("全买单柜无需发送客户回执给报关行");
-        if (mapper.unconfirmedReceiptCount(container.id()) != 0) throw conflict("仍有预录单未完成客户确认");
+        if (mapper.unconfirmedReceiptCount(container.id()) != 0) throw conflict("仍有报关行回执未完成客户确认");
         if (mapper.brokerSubmission(container.id()) == null) throw conflict("当前柜尚未完成首次发送报关行资料");
         if (mapper.brokerSubmittedAt(container.id()) != null) throw conflict("当前柜已发送给报关行执行");
         if (mapper.submitToBroker(container.id(), container.version(), operatorId, operatorName) != 1) throw concurrent();
@@ -232,7 +231,6 @@ public class ContainerCustomsService {
         return platformView(planId);
     }
 
-    /** 上传预录单并保存文件版本，已发送报关行执行后仍禁止替换。 */
     @Transactional
     public DocumentView uploadCompletion(long documentId, long operatorId, String operatorName, String key,
                                          int expectedVersion, MultipartFile file) {
@@ -248,7 +246,7 @@ public class ContainerCustomsService {
             throw conflict("当前客户资料不在报关中冻结版本");
         }
         if (mapper.brokerSubmittedAt(container.id()) != null) {
-            throw conflict("客户确认的预录单已发送给报关行，不可再修改预录单");
+            throw conflict("客户确认回执已发送给报关行，不可再修改回执");
         }
         if (mapper.brokerSubmission(container.id()) == null) {
             throw conflict("当前柜尚未完成首次发送报关行资料");
@@ -302,7 +300,6 @@ public class ContainerCustomsService {
         return merchantViewForDocument(tenantId, source);
     }
 
-    /** 预录单确认并发送报关行执行后，接收真实报关完税文件。 */
     @Transactional
     public DocumentView uploadFinalDocument(long documentId, long operatorId, String operatorName, String key,
                                             int expectedVersion, MultipartFile file) {
@@ -319,7 +316,7 @@ public class ContainerCustomsService {
         }
         if (mapper.brokerSubmittedAt(container.id()) == null) throw conflict("客户确认结果尚未发送给报关行");
         CompletionRow receipt = mapper.lockCompletion(documentId);
-        if (receipt == null || !"CONFIRMED".equals(receipt.customerConfirmStatus())) throw conflict("该客户的预录单尚未确认");
+        if (receipt == null || !"CONFIRMED".equals(receipt.customerConfirmStatus())) throw conflict("该客户回执尚未确认");
         FinalRow existing = mapper.lockFinalDocument(documentId);
         CustomsFileClient.Metadata metadata = upload(source.tenantId(), RESULT_FILE_TYPE, Long.toString(container.loadingPlanId()), operatorId, file);
         long finalId;
@@ -374,7 +371,7 @@ public class ContainerCustomsService {
         if (container == null || !(DECLARING.equals(container.status()) || COMPLETED.equals(container.status()))) throw conflict("当前柜尚未进入报关行执行阶段，不能创建正式申报批次");
         if (mapper.taxRefundCount(planId) == 0) throw conflict("全买单柜不创建退税正式申报批次");
         if (mapper.unconfirmedReceiptCount(container.id()) != 0 || mapper.brokerSubmittedAt(container.id()) == null) {
-            throw conflict("当前柜尚未完成退税资料、预录单确认和报关行执行");
+            throw conflict("当前柜尚未完成退税资料、回执确认和报关行执行");
         }
         if (!Objects.equals(container.version(), request.expectedVersion())) throw concurrent();
         long batchId = IdWorker.getId();
@@ -539,15 +536,14 @@ public class ContainerCustomsService {
                 row.operatorName(), row.createdAt())).toList();
     }
 
-    /** 按既有客户范围与可见状态下载预录单，沿用文件真实名称。 */
     public Download downloadCompletion(long tenantId, long documentId, boolean platform) {
         DocumentRow source = requiredDocument(documentId);
         ContainerRow container = mapper.containerById(source.customsContainerId());
         if (!platform && (source.tenantId() != tenantId || container == null || !Set.of(DECLARING, COMPLETED).contains(container.status()))) {
-            throw notFound("预录单不存在");
+            throw notFound("报关行回执不存在");
         }
         CompletionRow completion = mapper.completion(documentId);
-        if (completion == null) throw notFound("预录单不存在");
+        if (completion == null) throw notFound("报关行回执不存在");
         return download(source.tenantId(), RECEIPT_FILE_TYPE, Long.toString(container.loadingPlanId()), completion.fileId(), completion.fileName());
     }
 

firstleg/src/main/java/com/baiyue/firstleg/domain/Iso6346ContainerNumber.java

@@ -0,0 +1,49 @@
+package com.baiyue.firstleg.domain;
+
+import com.baiyue.common.core.api.ResultCode;
+import com.baiyue.common.core.exception.BizException;
+
+import java.util.Locale;
+
+/** ISO 6346 真实集装箱号的唯一规范化与校验入口。 */
+public final class Iso6346ContainerNumber {
+    private static final int[] LETTER_VALUES = {
+        10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24,
+        25, 26, 27, 28, 29, 30, 31, 32, 34, 35, 36, 37, 38
+    };
+
+    private Iso6346ContainerNumber() {
+    }
+
+    public static String require(String raw) {
+        String value = normalizeWhitespace(raw);
+        if (value == null || !value.matches("[A-Z]{3}[UJZ][0-9]{7}")) {
+            throw invalid();
+        }
+        int sum = 0;
+        for (int index = 0; index < 10; index++) {
+            char current = value.charAt(index);
+            int number = Character.isDigit(current)
+                ? current - '0' : LETTER_VALUES[current - 'A'];
+            sum += number * (1 << index);
+        }
+        int expected = sum % 11 % 10;
+        if (value.charAt(10) - '0' != expected) throw invalid();
+        return value;
+    }
+
+    private static String normalizeWhitespace(String raw) {
+        if (raw == null) return null;
+        StringBuilder value = new StringBuilder(raw.length());
+        raw.codePoints().filter(codePoint -> !Character.isWhitespace(codePoint)
+                && !Character.isSpaceChar(codePoint))
+            .forEach(value::appendCodePoint);
+        String normalized = value.toString().toUpperCase(Locale.ROOT);
+        return normalized.isEmpty() ? null : normalized;
+    }
+
+    private static BizException invalid() {
+        return new BizException(ResultCode.BAD_REQUEST,
+            "真实集装箱号必须符合ISO 6346结构、设备类别和校验位");
+    }
+}

firstleg/src/main/java/com/baiyue/firstleg/domain/RealContainerNumber.java

@@ -1,19 +0,0 @@
-package com.baiyue.firstleg.domain;
-
-import com.baiyue.common.core.api.ResultCode;
-import com.baiyue.common.core.exception.BizException;
-import com.baiyue.common.event.ContainerNumbers;
-
-/** 真实集装箱号录入与作业门禁，与跨服务事件使用同一规范化规则。 */
-public final class RealContainerNumber {
-    private RealContainerNumber() { }
-
-    /** 保留柜号必填要求，不再检查 ISO 长度、设备类别和校验位。 */
-    public static String require(String raw) {
-        try {
-            return ContainerNumbers.normalizeRequired(raw);
-        } catch (IllegalArgumentException exception) {
-            throw new BizException(ResultCode.BAD_REQUEST, "真实集装箱号不能为空");
-        }
-    }
-}

firstleg/src/main/java/com/baiyue/firstleg/dto/TruckAppointmentDtos.java

@@ -3,8 +3,7 @@ import jakarta.validation.constraints.*; import java.math.BigDecimal; import jav
 public final class TruckAppointmentDtos { private TruckAppointmentDtos(){}
  public record Query(@Size(max=64) String keyword, com.baiyue.firstleg.domain.TruckAppointmentStatus status, @Positive Long oceanBookingId, @Min(1) long page, @Min(1) @Max(200) long size){ public Query{if(page==0)page=1;if(size==0)size=20;} }
  public record CandidateQuery(@Size(max=64) String keyword,@Min(1) long page,@Min(1) @Max(200) long size){public CandidateQuery{if(page==0)page=1;if(size==0)size=20;}}
- /** 已放舱订舱候选，预约不依赖订舱附件。 */
+ public record Candidate(Long oceanBookingId,String oceanBookingNo,String billOfLadingNo,Long warehouseId,String warehouseName,String channelCode,String channelName,Boolean bookingDocumentReady){}
- public record Candidate(Long oceanBookingId,String oceanBookingNo,String billOfLadingNo,Long warehouseId,String warehouseName,String channelCode,String channelName){}
  public record SaveRequest(@Positive Long outboundOrderId,@NotNull @Positive Long oceanBookingId,@Positive Long warehouseId,@NotNull @Positive Long carrierId,@Size(max=128) String carrierName,@Size(max=128) String billOfLadingNo,@Size(max=64) String fleetContact,@Size(max=32) String fleetPhone,@Size(max=64) String driverName,@Size(max=32) String driverPhone,@Size(max=32) String driverIdCard,@Size(max=32) String vehicleNo,@Size(max=128) String storeName,@Size(max=64) String storeContact,@Size(max=32) String storePhone,@Size(max=255) String storeAddress,@Size(max=64) String storeCity,@Size(max=16) String storeZipcode,@PositiveOrZero Integer packageCount,@DecimalMin("0") BigDecimal grossWeightKg,@DecimalMin("0") BigDecimal volumeCbm,@PositiveOrZero Integer palletCount,@Size(max=255) String poNo,@NotNull LocalDateTime plannedLoadingAt,@PositiveOrZero Integer transitMinutes,@DecimalMin("0") @Digits(integer=16,fraction=2) BigDecimal payableAmount,@Pattern(regexp="RMB") String currency,@Size(max=1000) String remark,@NotNull @PositiveOrZero Integer expectedVersion){}
  public record ActionRequest(@NotNull @PositiveOrZero Integer expectedVersion,@Size(max=500) String reason){}
  public record AttachmentRequest(@NotNull @Positive Long fileId,@NotBlank @Pattern(regexp="DISPATCH_ORDER|DRIVER_DOCUMENT|VEHICLE_DOCUMENT|OTHER") String attachmentType,@Size(max=255) String fileName,@Size(max=128) String fileHash){ }

firstleg/src/main/java/com/baiyue/firstleg/loading/coload/controller/PlatformColoadGroupController.java

@@ -67,11 +67,10 @@ public class PlatformColoadGroupController {
             idempotencyKey, user.userId(), user.username()));
     }
 
-    /** 按入仓码返回同柜组业务编号及当前有效成员，保留平台只读权限边界。 */
     @GetMapping("/by-inbound-code/{inboundCode}")
     @PreAuthorize("hasAuthority('platform:firstleg:smart-loading:list')")
     @Operation(summary = "按入仓码查询同柜组业务摘要",
-        description = "返回真实业务组号、业务状态、有效成员数及去重后的全部成员入仓码；不返回内部组ID。")
+        description = "仅返回业务状态、有效成员数及去重后的全部成员入仓码；内部组ID和组号不作为页面识别键。")
     public ApiResponse<BusinessSummary> byInboundCode(
         @AuthenticationPrincipal AuthenticatedUser user,
         @PathVariable @Size(min = 1, max = 40) String inboundCode) {

firstleg/src/main/java/com/baiyue/firstleg/loading/coload/model/ColoadGroupModels.java

@@ -71,7 +71,6 @@ public final class ColoadGroupModels {
 
     /** 页面只读业务摘要；内部组标识不作为用户识别键。 */
     public record BusinessSummary(
-        String groupNo,
         String status,
         int memberCount,
         List<BusinessMember> members

firstleg/src/main/java/com/baiyue/firstleg/loading/coload/persistence/ColoadGroupMapper.java

@@ -108,7 +108,7 @@ public interface ColoadGroupMapper {
                                   @Param("inboundId") long inboundId);
 
     @Select("""
-        SELECT DISTINCT group_row.id groupId,group_row.group_no groupNo,group_row.group_status groupStatus
+        SELECT DISTINCT group_row.id groupId,group_row.group_status groupStatus
           FROM fl_inbound_order requested
           JOIN fl_coload_group_member member
             ON member.tenant_id=requested.tenant_id AND member.inbound_id=requested.id

firstleg/src/main/java/com/baiyue/firstleg/loading/coload/persistence/ColoadGroupQueryRepository.java

@@ -1,20 +0,0 @@
-package com.baiyue.firstleg.loading.coload.persistence;
-
-import org.springframework.stereotype.Repository;
-import java.util.List;
-
-/** 平台同柜组摘要的只读数据访问，保留原入仓片段和组状态范围。 */
-@Repository
-public class ColoadGroupQueryRepository {
-    private final ColoadGroupMapper mapper;
-    /** 注入同服务持久化入口。 */
-    public ColoadGroupQueryRepository(ColoadGroupMapper mapper) { this.mapper = mapper; }
-    /** 按业务入仓码查询当前组及其真实业务组号。 */
-    public List<ColoadPersistenceRows.InboundGroupLookupRow> groupsByInboundCode(String code) {
-        return mapper.groupsByInboundCode(code);
-    }
-    /** 读取被冻结的成员，交由服务核对缺失和重复片段。 */
-    public List<ColoadPersistenceRows.MemberCodeRow> effectiveMemberCodes(long groupId) {
-        return mapper.effectiveMemberCodes(groupId);
-    }
-}

firstleg/src/main/java/com/baiyue/firstleg/loading/coload/persistence/ColoadPersistenceRows.java

@@ -59,7 +59,6 @@ public final class ColoadPersistenceRows {
     @Setter
     public static class InboundGroupLookupRow {
         private Long groupId;
-        private String groupNo;
         private String groupStatus;
     }
 

firstleg/src/main/java/com/baiyue/firstleg/loading/coload/service/ColoadGroupService.java

@@ -47,8 +47,6 @@ public class ColoadGroupService implements ColoadGroupAssignmentPort {
 
     @Resource
     private ColoadGroupMapper mapper;
-    @Resource
-    private com.baiyue.firstleg.loading.coload.persistence.ColoadGroupQueryRepository queryRepository;
     @Resource private PendingReviewOrderClient pendingReviewOrders;
     @Resource private OrderCargoClient orderCargoClient;
     @Resource private InboundOrderCreationService inboundOrderCreationService;
@@ -120,11 +118,10 @@ public class ColoadGroupService implements ColoadGroupAssignmentPort {
         return requiredSnapshot(groupId);
     }
 
-    /** 以入仓码读取同柜组业务号及全部有效成员，不返回内部组ID。 */
     @Transactional(readOnly = true)
     public BusinessSummary queryByInboundCode(String inboundCode) {
         String code = normalizedInboundCode(inboundCode);
-        var groups = queryRepository.groupsByInboundCode(code).stream()
+        var groups = mapper.groupsByInboundCode(code).stream()
             .filter(row -> row.getGroupId() != null && CURRENT_GROUP_STATUSES.contains(row.getGroupStatus()))
             .toList();
         long distinctGroups = groups.stream().map(row -> row.getGroupId()).distinct().limit(2).count();
@@ -134,7 +131,7 @@ public class ColoadGroupService implements ColoadGroupAssignmentPort {
         if (distinctGroups > 1) throw conflict("入仓码关联多个有效同柜不可拆组");
         long groupId = groups.get(0).getGroupId();
         String status = groups.get(0).getGroupStatus();
-        var memberRows = queryRepository.effectiveMemberCodes(groupId);
+        var memberRows = mapper.effectiveMemberCodes(groupId);
         if (memberRows.isEmpty()) throw conflict("同柜不可拆组不存在有效入仓片段");
         if (memberRows.stream().anyMatch(row -> row.getMemberId() == null || row.getInboundId() == null
             || trim(row.getInboundCode()) == null)) {
@@ -145,7 +142,7 @@ public class ColoadGroupService implements ColoadGroupAssignmentPort {
             throw conflict("同柜不可拆组存在重复入仓片段业务号");
         }
         List<BusinessMember> members = inboundCodes.stream().sorted().map(BusinessMember::new).toList();
-        return new BusinessSummary(groups.get(0).getGroupNo(), status, members.size(), members);
+        return new BusinessSummary(status, members.size(), members);
     }
 
     private long requiredCurrentGroupId(String inboundCode) {

firstleg/src/main/java/com/baiyue/firstleg/mapper/LoadingCompletionCommandMapper.java

@@ -4,7 +4,6 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.baiyue.firstleg.entity.LoadingCompletionCommandEntity;
 import org.apache.ibatis.annotations.Insert;
 import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Options;
 import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.annotations.Select;
 import org.apache.ibatis.annotations.Update;
@@ -56,34 +55,28 @@ public interface LoadingCompletionCommandMapper extends BaseMapper<LoadingComple
     int claim(@Param("id") long id, @Param("worker") String worker,
               @Param("leaseUntil") LocalDateTime leaseUntil);
 
-    /** 只有尚未过期的当前所有者可以续租，过期执行者必须重新领取。 */
     @Update("""
         UPDATE fl_loading_completion_command SET lease_until=#{leaseUntil},updated_at=CURRENT_TIMESTAMP(3)
          WHERE id=#{id} AND command_status='PROCESSING' AND lease_owner=#{worker}
-           AND lease_until>CURRENT_TIMESTAMP(3)
         """)
     int renew(@Param("id") long id, @Param("worker") String worker,
               @Param("leaseUntil") LocalDateTime leaseUntil);
 
-    /** 完成落库必须仍持有有效租约，拒绝过期或已易主的旧执行者。 */
     @Update("""
         UPDATE fl_loading_completion_command
            SET command_status='COMPLETED',completed_at=CURRENT_TIMESTAMP(3),updated_at=CURRENT_TIMESTAMP(3),
                lease_owner=NULL,lease_until=NULL,failure_stage=NULL,failure_code=NULL,
                failure_request_id=NULL,failure_trace_id=NULL
          WHERE id=#{id} AND command_status='PROCESSING' AND lease_owner=#{worker}
-           AND lease_until>CURRENT_TIMESTAMP(3)
         """)
     int complete(@Param("id") long id, @Param("worker") String worker);
 
-    /** 失败回执也受当前有效租约保护，不能覆盖新执行者的状态。 */
     @Update("""
         UPDATE fl_loading_completion_command
            SET command_status=#{status},next_retry_at=#{nextRetryAt},updated_at=CURRENT_TIMESTAMP(3),
                lease_owner=NULL,lease_until=NULL,failure_stage=#{stage},failure_code=#{code},
                failure_request_id=#{requestId},failure_trace_id=#{traceId}
          WHERE id=#{id} AND command_status='PROCESSING' AND lease_owner=#{worker}
-           AND lease_until>CURRENT_TIMESTAMP(3)
         """)
     int fail(@Param("id") long id, @Param("worker") String worker, @Param("status") String status,
              @Param("nextRetryAt") LocalDateTime nextRetryAt, @Param("stage") String stage,
@@ -104,32 +97,13 @@ public interface LoadingCompletionCommandMapper extends BaseMapper<LoadingComple
     String checkpoint(@Param("commandId") long commandId, @Param("tenantId") long tenantId,
                       @Param("inboundId") long inboundId);
 
-    /** 检查点事务锁住当前有效租约，与并发重新领取互斥。 */
-    @Options(useCache = false, flushCache = Options.FlushCachePolicy.TRUE)
-    @Select("""
-        SELECT id FROM fl_loading_completion_command
-         WHERE id=#{commandId} AND command_status='PROCESSING' AND lease_owner=#{worker}
-           AND lease_until>CURRENT_TIMESTAMP(3)
-         FOR UPDATE
-        """)
-    Long lockCheckpointLease(@Param("commandId") long commandId, @Param("worker") String worker);
-
-    /** 在已锁定的命令行上重验有效租约；检查点只能前进，不能被迟到写入降级。 */
     @Insert("""
         INSERT INTO fl_loading_completion_checkpoint
           (command_id,tenant_id,inbound_id,owner_sequence,checkpoint_stage)
-        SELECT id,#{tenantId},#{inboundId},#{sequence},#{stage}
+        VALUES (#{commandId},#{tenantId},#{inboundId},#{sequence},#{stage})
-          FROM fl_loading_completion_command
+        ON DUPLICATE KEY UPDATE checkpoint_stage=VALUES(checkpoint_stage),updated_at=CURRENT_TIMESTAMP(3)
-         WHERE id=#{commandId} AND command_status='PROCESSING' AND lease_owner=#{worker}
-           AND lease_until>CURRENT_TIMESTAMP(3)
-        ON DUPLICATE KEY UPDATE checkpoint_stage=CASE
-          WHEN checkpoint_stage='INBOUND_COMPLETED' OR #{stage}='INBOUND_COMPLETED'
-            THEN 'INBOUND_COMPLETED'
-          WHEN checkpoint_stage='SETTLED' OR #{stage}='SETTLED' THEN 'SETTLED'
-          ELSE 'READY' END,updated_at=CURRENT_TIMESTAMP(3)
         """)
-    int checkpointCompleted(@Param("commandId") long commandId, @Param("worker") String worker,
+    int checkpointCompleted(@Param("commandId") long commandId, @Param("tenantId") long tenantId,
-                            @Param("tenantId") long tenantId,
                             @Param("inboundId") long inboundId, @Param("sequence") int sequence,
                             @Param("stage") String stage);
 }

firstleg/src/main/java/com/baiyue/firstleg/mapper/MerchantWorkbenchFilterMapper.java

@@ -64,13 +64,13 @@ public interface MerchantWorkbenchFilterMapper {
         ORDER BY i.order_id
         """)
     List<Long> pendingCustoms(@Param("tenantId") long tenantId);
-    /** 仅按本客户实际装柜片段读取进度；清关资料保存后立即显示已清关。 */
+    /** Only physically loaded fragments can expose container milestones to the customer. */
     @Select("""
         <script>
         SELECT o.order_id, CASE WHEN owned.container_booking_id IS NULL THEN 0
-               WHEN EXISTS (SELECT 1 FROM fl_container_document d
+               WHEN EXISTS (SELECT 1 FROM fl_carrier_schedule_node_fact n
-                 WHERE d.container_booking_id=owned.container_booking_id
+                 WHERE n.container_booking_id=owned.container_booking_id
-                   AND d.document_type='DESTINATION_CLEARANCE' AND d.file_id IS NOT NULL) THEN 3
+                   AND n.standard_node='PICKUP_READY' AND n.actual_at IS NOT NULL) THEN 3
                WHEN EXISTS (SELECT 1 FROM fl_customs_container c
                  WHERE c.loading_plan_id=owned.loading_plan_id AND c.status='COMPLETED') THEN 2
                ELSE 1 END AS stage

firstleg/src/main/java/com/baiyue/firstleg/mapper/TruckAppointmentMapper.java

@@ -1,14 +1,15 @@
 package com.baiyue.firstleg.mapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.baiyue.firstleg.dto.TruckAppointmentDtos.*; import com.baiyue.firstleg.entity.TruckAppointmentEntity; import org.apache.ibatis.annotations.*;
 @Mapper public interface TruckAppointmentMapper extends BaseMapper<TruckAppointmentEntity>{
- /** 查询已放舱且有提单号的可预约订舱，不依赖附件。 */
  @Select("""
   <script>
   SELECT o.id oceanBookingId,o.booking_no oceanBookingNo,o.bill_of_lading_no billOfLadingNo,
          o.warehouse_id warehouseId,o.warehouse_name warehouseName,o.channel_code channelCode,
-         o.channel_name channelName
+         o.channel_name channelName,TRUE bookingDocumentReady
     FROM fl_ocean_booking o
-   WHERE o.status='RELEASED' AND o.bill_of_lading_no IS NOT NULL AND o.bill_of_lading_no&lt;&gt;''
+   WHERE EXISTS (SELECT 1 FROM fl_ocean_booking_document d WHERE d.ocean_booking_id=o.id
+                  AND d.valid=1 AND d.document_type IN ('BOOKING_CONFIRMATION','BILL_OF_LADING'))
+     AND o.status='RELEASED' AND o.bill_of_lading_no IS NOT NULL AND o.bill_of_lading_no&lt;&gt;''
      AND NOT EXISTS (SELECT 1 FROM fl_truck_appointment t WHERE t.ocean_booking_id=o.id
                       AND t.status NOT IN ('CANCELLED','EXCEPTION'))
      AND (#{q.keyword} IS NULL OR o.booking_no LIKE CONCAT('%',#{q.keyword},'%')

firstleg/src/main/java/com/baiyue/firstleg/oceanbooking/controller/PlatformOceanBookingController.java

@@ -126,28 +126,6 @@ public class PlatformOceanBookingController {
     @PutMapping("/{oceanBookingId}") @PreAuthorize("hasAuthority('platform:firstleg:ocean-booking:edit')")
     @BusinessAudit(event="OCEAN_BOOKING_UPDATE_DRAFT", resourceType="OCEAN_BOOKING", resourceId="#oceanBookingId", description="编辑海运订舱草稿")
     public ApiResponse<Detail> updateDraft(@AuthenticationPrincipal AuthenticatedUser user, @PathVariable @Positive long oceanBookingId, @RequestHeader("Idempotency-Key") String key, @Valid @RequestBody UpdateRequest request) { validateOptionalCustomer(user, request.data().customerId()); return ApiResponse.success(service.updateDraft(oceanBookingId, user.userId(), user.username(), key, request)); }
-    /** 放舱后单独维护预计到港，其他运输资料仍冻结。 */
-    @PutMapping("/{oceanBookingId}/estimated-arrival")
-    @PreAuthorize("hasAuthority('platform:firstleg:ocean-booking:edit')")
-    @BusinessAudit(event="OCEAN_BOOKING_UPDATE_ESTIMATED_ARRIVAL", resourceType="OCEAN_BOOKING", resourceId="#oceanBookingId", description="维护订舱预计到港")
-    public ApiResponse<Detail> updateEstimatedArrival(@AuthenticationPrincipal AuthenticatedUser user,
-        @PathVariable @Positive long oceanBookingId, @RequestHeader("Idempotency-Key") String key,
-        @Valid @RequestBody EstimatedArrivalRequest request) {
-        FirstlegScopeGuard.platform(user);
-        return ApiResponse.success(service.updateEstimatedArrival(oceanBookingId, user.userId(), user.username(), key, request));
-    }
-
-    /** 客服在放舱后补录实货量，沿用订舱编辑权限并记录审计。 */
-    @PutMapping("/{oceanBookingId}/actual-cargo")
-    @PreAuthorize("hasAuthority('platform:firstleg:ocean-booking:edit')")
-    @BusinessAudit(event="OCEAN_BOOKING_UPDATE_ACTUAL_CARGO", resourceType="OCEAN_BOOKING", resourceId="#oceanBookingId", description="补录订舱实际货量")
-    public ApiResponse<Detail> updateActualCargo(@AuthenticationPrincipal AuthenticatedUser user,
-        @PathVariable @Positive long oceanBookingId, @RequestHeader("Idempotency-Key") String key,
-        @Valid @RequestBody ActualCargoRequest request) {
-        FirstlegScopeGuard.platform(user);
-        return ApiResponse.success(service.updateActualCargo(oceanBookingId, user.userId(), user.username(), key, request));
-    }
-
     @DeleteMapping("/{oceanBookingId}") @PreAuthorize("hasAuthority('platform:firstleg:ocean-booking:delete')")
     @BusinessAudit(event="OCEAN_BOOKING_DELETE_DRAFT", resourceType="OCEAN_BOOKING", resourceId="#oceanBookingId", description="删除海运订舱草稿")
     public ApiResponse<Void> deleteDraft(@AuthenticationPrincipal AuthenticatedUser user, @PathVariable @Positive long oceanBookingId, @RequestHeader("Idempotency-Key") String key, @Valid @RequestBody ActionRequest request) { FirstlegScopeGuard.platform(user); service.deleteDraft(oceanBookingId, user.userId(), user.username(), key, request); return ApiResponse.success(null); }

firstleg/src/main/java/com/baiyue/firstleg/oceanbooking/dto/OceanBookingDtos.java

@@ -45,12 +45,10 @@ public final class OceanBookingDtos {
                                 String customerName, String warehouseName, String channelName) {}
 
     public record PartyRequest(@NotBlank @Size(max = 24) String partyType,
-                               @NotNull @Size(max = 255) String partyName,
+                               @NotBlank @Size(max = 255) String partyName,
                                @Size(max = 1000) String address,
                                @Size(max = 128) String contactName,
-                               @Size(max = 64) String contactPhone,
+                               @Size(max = 64) String contactPhone) {}
-                               @jakarta.validation.constraints.Email @Size(max = 255) String contactEmail,
-                               @Size(max = 128) String taxNo) {}
 
     public record ContainerRequirementRequest(@NotBlank @Size(max = 32) String containerType,
                                    @NotBlank @Size(max = 32) String containerKind,
@@ -78,35 +76,7 @@ public final class OceanBookingDtos {
                             LocalDateTime estimatedArrivalAt,
                             @Size(max = 1000) String remark,
                             @Valid @Size(max = 3) List<PartyRequest> parties,
-                            @Valid @Size(max = 20) List<ContainerRequirementRequest> containerRequirements,
+                            @Valid @Size(max = 20) List<ContainerRequirementRequest> containerRequirements) {}
-                            @Size(max = 64) String freightTerm,
-                            @Size(max = 64) String serviceTerm,
-                            @Pattern(regexp = "CARTONS|PCS|PALLETS") String packageUnit,
-                            @Size(max = 1000) String cargoDescription,
-                            @Size(max = 1000) String marksAndNos,
-                            @Min(1) @Max(999999999) Integer declaredPackageCount,
-                            @jakarta.validation.constraints.DecimalMin(value = "0", inclusive = false)
-                            @jakarta.validation.constraints.Digits(integer = 12, fraction = 3) BigDecimal declaredGrossWeightKg,
-                            @jakarta.validation.constraints.DecimalMin(value = "0", inclusive = false)
-                            @jakarta.validation.constraints.Digits(integer = 12, fraction = 3) BigDecimal declaredVolumeCbm,
-                            @Min(1) @Max(999999999) Integer actualPackageCount,
-                            @jakarta.validation.constraints.DecimalMin(value = "0", inclusive = false)
-                            @jakarta.validation.constraints.Digits(integer = 12, fraction = 3) BigDecimal actualGrossWeightKg,
-                            @jakarta.validation.constraints.DecimalMin(value = "0", inclusive = false)
-                            @jakarta.validation.constraints.Digits(integer = 12, fraction = 3) BigDecimal actualVolumeCbm) {}
-
-    /** 放舱后仅维护预计到港，不接收其他运输资料。 */
-    public record EstimatedArrivalRequest(@NotNull @Min(0) Integer expectedVersion,
-                                         @NotNull LocalDateTime estimatedArrivalAt) {}
-
-    /** 放舱后的受控实货量补录，不接收运输资料。 */
-    public record ActualCargoRequest(@NotNull @Min(0) Integer expectedVersion,
-                                    @Min(1) @Max(999999999) Integer actualPackageCount,
-                                    @jakarta.validation.constraints.DecimalMin(value = "0", inclusive = false)
-                                    @jakarta.validation.constraints.Digits(integer = 12, fraction = 3) BigDecimal actualGrossWeightKg,
-                                    @jakarta.validation.constraints.DecimalMin(value = "0", inclusive = false)
-                                    @jakarta.validation.constraints.Digits(integer = 12, fraction = 3) BigDecimal actualVolumeCbm,
-                                    @NotBlank @Size(max = 1000) String reason) {}
 
     public record CreateRequest(@NotNull @Min(0) Integer expectedVersion,
                                 @Valid @NotNull DraftData data) {}

firstleg/src/main/java/com/baiyue/firstleg/oceanbooking/entity/OceanBookingEntity.java

@@ -40,17 +40,6 @@ public class OceanBookingEntity {
     private LocalDateTime estimatedSailingAt;
     private LocalDateTime estimatedArrivalAt;
     private String remark;
-    private String freightTerm;
-    private String serviceTerm;
-    private String packageUnit;
-    private String cargoDescription;
-    private String marksAndNos;
-    private Integer declaredPackageCount;
-    private java.math.BigDecimal declaredGrossWeightKg;
-    private java.math.BigDecimal declaredVolumeCbm;
-    private Integer actualPackageCount;
-    private java.math.BigDecimal actualGrossWeightKg;
-    private java.math.BigDecimal actualVolumeCbm;
     private Long createdBy;
     private String createdByName;
     @TableField(fill = FieldFill.INSERT) private LocalDateTime createdAt;

firstleg/src/main/java/com/baiyue/firstleg/oceanbooking/entity/OceanBookingPartyEntity.java

@@ -17,6 +17,4 @@ public class OceanBookingPartyEntity {
     private String address;
     private String contactName;
     private String contactPhone;
-    private String contactEmail;
-    private String taxNo;
 }

firstleg/src/main/java/com/baiyue/firstleg/oceanbooking/mapper/OceanBookingMapper.java

@@ -25,22 +25,8 @@ public interface OceanBookingMapper extends BaseMapper<OceanBookingEntity> {
         """)
     int touchDraft(@Param("id") long id, @Param("expectedVersion") int expectedVersion,
                    @Param("operatorId") long operatorId, @Param("operatorName") String operatorName);
-    @Update("UPDATE fl_ocean_booking SET customer_id=#{value.customerId},customer_name=#{value.customerName},channel_code=#{value.channelCode},channel_name=#{value.channelName},warehouse_id=#{value.warehouseId},warehouse_name=#{value.warehouseName},bill_of_lading_no=#{value.billOfLadingNo},shipping_company_id=#{value.shippingCompanyId},shipping_company_name=#{value.shippingCompanyName},carrier_code=#{value.carrierCode},booking_agent_id=#{value.bookingAgentId},booking_agent_name=#{value.bookingAgentName},vessel_name=#{value.vesselName},voyage_no=#{value.voyageNo},departure_port_code=#{value.departurePortCode},departure_port_name=#{value.departurePortName},destination_port_code=#{value.destinationPortCode},destination_port_name=#{value.destinationPortName},place_of_delivery=#{value.placeOfDelivery},estimated_sailing_at=#{value.estimatedSailingAt},estimated_arrival_at=#{value.estimatedArrivalAt},remark=#{value.remark},freight_term=#{value.freightTerm},service_term=#{value.serviceTerm},package_unit=#{value.packageUnit},cargo_description=#{value.cargoDescription},marks_and_nos=#{value.marksAndNos},declared_package_count=#{value.declaredPackageCount},declared_gross_weight_kg=#{value.declaredGrossWeightKg},declared_volume_cbm=#{value.declaredVolumeCbm},actual_package_count=#{value.actualPackageCount},actual_gross_weight_kg=#{value.actualGrossWeightKg},actual_volume_cbm=#{value.actualVolumeCbm},updated_by=#{operatorId},updated_by_name=#{operatorName},version=version+1,updated_at=NOW() WHERE id=#{id} AND status='DRAFT' AND version=#{version}")
+    @Update("UPDATE fl_ocean_booking SET customer_id=#{value.customerId},customer_name=#{value.customerName},channel_code=#{value.channelCode},channel_name=#{value.channelName},warehouse_id=#{value.warehouseId},warehouse_name=#{value.warehouseName},bill_of_lading_no=#{value.billOfLadingNo},shipping_company_id=#{value.shippingCompanyId},shipping_company_name=#{value.shippingCompanyName},carrier_code=#{value.carrierCode},booking_agent_id=#{value.bookingAgentId},booking_agent_name=#{value.bookingAgentName},vessel_name=#{value.vesselName},voyage_no=#{value.voyageNo},departure_port_code=#{value.departurePortCode},departure_port_name=#{value.departurePortName},destination_port_code=#{value.destinationPortCode},destination_port_name=#{value.destinationPortName},place_of_delivery=#{value.placeOfDelivery},estimated_sailing_at=#{value.estimatedSailingAt},estimated_arrival_at=#{value.estimatedArrivalAt},remark=#{value.remark},updated_by=#{operatorId},updated_by_name=#{operatorName},version=version+1,updated_at=NOW() WHERE id=#{id} AND status='DRAFT' AND version=#{version}")
     int updateDraft(@Param("id") long id, @Param("value") OceanBookingEntity value, @Param("version") int version, @Param("operatorId") long operatorId, @Param("operatorName") String operatorName);
-    /** 已放舱预计到港窄更新，保留状态、版本和操作审计。 */
-    @Update("UPDATE fl_ocean_booking SET estimated_arrival_at=#{estimatedArrivalAt},updated_by=#{operatorId},updated_by_name=#{operatorName},updated_at=CURRENT_TIMESTAMP(3),version=version+1 WHERE id=#{id} AND status='RELEASED' AND version=#{version}")
-    int updateEstimatedArrival(@Param("id") long id, @Param("estimatedArrivalAt") java.time.LocalDateTime estimatedArrivalAt,
-        @Param("version") int version, @Param("operatorId") long operatorId, @Param("operatorName") String operatorName);
-
-    /** 已放舱补实只更新白名单字段，保留乐观锁及状态门禁。 */
-    @Update("""
-        UPDATE fl_ocean_booking SET actual_package_count=#{value.actualPackageCount},
-          actual_gross_weight_kg=#{value.actualGrossWeightKg},actual_volume_cbm=#{value.actualVolumeCbm},
-          updated_by=#{operatorId},updated_by_name=#{operatorName},updated_at=CURRENT_TIMESTAMP(3),version=version+1
-        WHERE id=#{value.id} AND status='RELEASED' AND version=#{version}
-        """)
-    int updateActualCargo(@Param("value") OceanBookingEntity value, @Param("version") int version,
-                          @Param("operatorId") long operatorId, @Param("operatorName") String operatorName);
     @Delete("DELETE FROM fl_ocean_booking WHERE id=#{id} AND status='DRAFT' AND version=#{version}")
     int deleteDraft(@Param("id") long id, @Param("version") int version);
     @Select("""

firstleg/src/main/java/com/baiyue/firstleg/oceanbooking/repository/OceanBookingRepository.java

@@ -54,15 +54,6 @@ public class OceanBookingRepository {
     public int touchDraft(long id, int version, long operatorId, String operatorName) {
         return bookings.touchDraft(id, version, operatorId, operatorName);
     }
-    /** 按订舱版本仅更新已放舱预计到港，不重写其他运输或货量资料。 */
-    public int updateEstimatedArrival(long id, java.time.LocalDateTime estimatedArrivalAt, int version, long operatorId, String operatorName) {
-        return bookings.updateEstimatedArrival(id, estimatedArrivalAt, version, operatorId, operatorName);
-    }
-
-    /** 只更新已放舱订舱的实际货量，运输快照保持冻结。 */
-    public int updateActualCargo(OceanBookingEntity value, int version, long operatorId, String operatorName) {
-        return bookings.updateActualCargo(value, version, operatorId, operatorName);
-    }
     public int deleteDraft(long id, int version) {
         return bookings.deleteDraft(id, version);
     }

firstleg/src/main/java/com/baiyue/firstleg/oceanbooking/service/OceanBookingPrintService.java

@@ -46,7 +46,7 @@ public class OceanBookingPrintService {
         String fileName = booking.getBookingNo() + "-" + suffix + ".pdf";
         PrintPdfClient.FreightA4PdfRequest request = new PrintPdfClient.FreightA4PdfRequest(
             template, A4, fileName, List.of(new PrintPdfClient.FreightDocument(
-                fields(template, detail), List.of(cargo(template, booking)))));
+                fields(template, detail), List.of(emptyCargo()))));
         try {
             ResponseEntity<byte[]> response = print.generateFreightA4Documents(internalToken, requestId, request);
             MediaType contentType = response.getHeaders().getContentType();
@@ -75,21 +75,14 @@ public class OceanBookingPrintService {
         fields.put("portOfLoading", first(booking.getDeparturePortName(), booking.getDeparturePortCode()));
         fields.put("portOfDischarge", first(booking.getDestinationPortName(), booking.getDestinationPortCode()));
         fields.put("placeOfDelivery", text(booking.getPlaceOfDelivery()));
-        fields.put("serviceTerm", text(booking.getServiceTerm()));
+        fields.put("serviceTerm", "");
-        fields.put("freightTerm", text(booking.getFreightTerm()));
+        fields.put("freightTerm", "");
-        Integer count = SHIPPING_INSTRUCTION.equals(template) ? booking.getDeclaredPackageCount() : booking.getActualPackageCount();
+        fields.put("totalPackagesInWords", "");
-        fields.put("totalPackagesInWords", packageWords(count, booking.getPackageUnit()));
         if (SHIPPING_INSTRUCTION.equals(template)) {
             fields.put("toCompany", text(booking.getBookingAgentName()));
             fields.put("jobNumber", text(booking.getBookingNo()));
             fields.put("etdDate", date(booking.getEstimatedSailingAt()));
-            fields.put("cargoQuantity", detail.containerRequirements().stream()
+            fields.put("cargoQuantity", "");
-                .map(value -> value.getQuantity() + "*" + value.getContainerType()).collect(Collectors.joining(" + ")));
-            OceanBookingPartyEntity shipper = parties.get("SHIPPER");
-            fields.put("picName", shipper == null ? "" : text(shipper.getContactName()));
-            fields.put("picTel", shipper == null ? "" : text(shipper.getContactPhone()));
-            fields.put("apName", text(booking.getBookingAgentName()));
-            fields.put("printDate", java.time.LocalDate.now(java.time.ZoneId.of("Asia/Shanghai")).toString());
             fields.put("carrier", text(booking.getShippingCompanyName()));
             fields.put("bookingAgent", text(booking.getBookingAgentName()));
             fields.put("remark", text(booking.getRemark()));
@@ -105,43 +98,8 @@ public class OceanBookingPrintService {
         return fields;
     }
 
-    /** 两类单据严格分别读取委、实数据，不以柜型容量或预报量代替实装量。 */
+    private static PrintPdfClient.CargoRow emptyCargo() {
-    private static PrintPdfClient.CargoRow cargo(String template, OceanBookingEntity booking) {
+        return new PrintPdfClient.CargoRow("—", "—", "—", "—", "—", "—");
-        boolean declared = SHIPPING_INSTRUCTION.equals(template);
-        Integer count = declared ? booking.getDeclaredPackageCount() : booking.getActualPackageCount();
-        BigDecimal weight = declared ? booking.getDeclaredGrossWeightKg() : booking.getActualGrossWeightKg();
-        BigDecimal volume = declared ? booking.getDeclaredVolumeCbm() : booking.getActualVolumeCbm();
-        return new PrintPdfClient.CargoRow(display(booking.getMarksAndNos()), count == null ? "—" : count.toString(),
-            display(booking.getPackageUnit()), display(booking.getCargoDescription()),
-            weight == null ? "—" : weight.setScale(3, java.math.RoundingMode.HALF_UP).toPlainString() + " KGS",
-            volume == null ? "—" : volume.setScale(3, java.math.RoundingMode.HALF_UP).toPlainString() + " CBM");
-    }
-
-    /** 打印空字段使用统一占位符。 */
-    private static String display(String value) { return text(value).isEmpty() ? "—" : text(value); }
-
-    /** 件数大写跟随所选数据和包装单位生成，未录入时明确留空。 */
-    private static String packageWords(Integer count, String unit) {
-        if (count == null || !org.springframework.util.StringUtils.hasText(unit)) return "";
-        String packaging = count == 1 ? switch (unit) {
-            case "CARTONS" -> "CARTON";
-            case "PALLETS" -> "PALLET";
-            case "PCS" -> "PIECE";
-            default -> unit;
-        } : ("PCS".equals(unit) ? "PIECES" : unit);
-        return "SAY " + words(count) + " " + packaging + " ONLY";
-    }
-
-    /** 将受件数范围约束的正整数转换为英文数量。 */
-    private static String words(int value) {
-        String[] small = {"ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE", "TEN",
-            "ELEVEN", "TWELVE", "THIRTEEN", "FOURTEEN", "FIFTEEN", "SIXTEEN", "SEVENTEEN", "EIGHTEEN", "NINETEEN"};
-        String[] tens = {"", "", "TWENTY", "THIRTY", "FORTY", "FIFTY", "SIXTY", "SEVENTY", "EIGHTY", "NINETY"};
-        if (value < 20) return small[value];
-        if (value < 100) return tens[value / 10] + (value % 10 == 0 ? "" : " " + words(value % 10));
-        int divisor = value >= 1000000 ? 1000000 : value >= 1000 ? 1000 : 100;
-        String scale = divisor == 1000000 ? "MILLION" : divisor == 1000 ? "THOUSAND" : "HUNDRED";
-        return words(value / divisor) + " " + scale + (value % divisor == 0 ? "" : " " + words(value % divisor));
     }
 
     private static String requirementSummary(List<OceanBookingContainerRequirementEntity> values) {
@@ -152,8 +110,7 @@ public class OceanBookingPrintService {
     private static String party(OceanBookingPartyEntity value) {
         if (value == null) return "";
         return List.of(text(value.getPartyName()), text(value.getAddress()),
-                join(value.getContactName(), value.getContactPhone()), text(value.getContactEmail()),
+                join(value.getContactName(), value.getContactPhone())).stream()
-                text(value.getTaxNo()).isEmpty() ? "" : "TAX NO: " + text(value.getTaxNo())).stream()
             .filter(part -> !part.isEmpty()).collect(Collectors.joining("\n"));
     }
 

firstleg/src/main/java/com/baiyue/firstleg/oceanbooking/service/OceanBookingService.java

@@ -51,6 +51,7 @@ public class OceanBookingService {
     @Resource private WarehouseMasterDataClient warehouses;
     @Resource private WarehousePartnerClient partners;
     @Resource private FirstlegDocumentNumberGenerator documentNumbers;
+    @Resource private OceanBookingDocumentService documents;
     @Resource private com.baiyue.firstleg.service.IamCustomerSnapshotService customers;
     @Value("${baiyue.security.internal-service-token:}") private String internalToken;
     @Value("${baiyue.warehouse.public-tenant-id:0}") private long publicWarehouseTenantId;
@@ -144,44 +145,6 @@ public class OceanBookingService {
         addHistory(id, OceanBookingStatus.DRAFT.name(), OceanBookingStatus.DRAFT.name(), action, null, before, after, operatorId, operatorName);
         return complete(id, operatorId, action, key, detail(after));
     }
-    /** 放舱后单独维护预计到港，按版本和幂等键保存并审计前后快照。 */
-    @Transactional
-    public Detail updateEstimatedArrival(long id, long operatorId, String name, String key, EstimatedArrivalRequest request) {
-        String action = "UPDATE_ESTIMATED_ARRIVAL";
-        Detail replay = claimOrReplay(id, operatorId, action, key, hash(action, id, request));
-        if (replay != null) return replay;
-        OceanBookingEntity before = requiredVersionForUpdate(id, request.expectedVersion());
-        requireStatus(before, OceanBookingStatus.RELEASED);
-        if (request.estimatedArrivalAt() == null) throw badRequest("预计到港时间不能为空");
-        if (before.getEstimatedSailingAt() != null && request.estimatedArrivalAt().isBefore(before.getEstimatedSailingAt())) {
-            throw badRequest("预计到港时间不能早于预计开船时间");
-        }
-        if (repository.updateEstimatedArrival(id, request.estimatedArrivalAt(), request.expectedVersion(), operatorId, name) != 1) throw concurrent();
-        OceanBookingEntity saved = required(id);
-        addHistory(id, before.getStatus(), saved.getStatus(), action, "维护预计到港", before, saved, operatorId, name);
-        return complete(id, operatorId, action, key, detail(saved));
-    }
-
-    /** 放舱后仅补录实货量，版本、幂等结果和修改前后快照在同一事务保存。 */
-    @Transactional
-    public Detail updateActualCargo(long id, long operatorId, String name, String key, ActualCargoRequest request) {
-        String action = "UPDATE_ACTUAL_CARGO";
-        Detail replay = claimOrReplay(id, operatorId, action, key, hash(action, id, request));
-        if (replay != null) return replay;
-        OceanBookingEntity before = requiredVersionForUpdate(id, request.expectedVersion());
-        requireStatus(before, OceanBookingStatus.RELEASED);
-        if (!StringUtils.hasText(request.reason())) throw badRequest("请填写实货量补录或修正原因");
-        validateCargo(request.actualPackageCount(), request.actualGrossWeightKg(), request.actualVolumeCbm());
-        OceanBookingEntity after = objectMapper.convertValue(before, OceanBookingEntity.class);
-        after.setActualPackageCount(request.actualPackageCount());
-        after.setActualGrossWeightKg(request.actualGrossWeightKg());
-        after.setActualVolumeCbm(request.actualVolumeCbm());
-        if (repository.updateActualCargo(after, request.expectedVersion(), operatorId, name) != 1) throw concurrent();
-        OceanBookingEntity saved = required(id);
-        addHistory(id, before.getStatus(), saved.getStatus(), action, request.reason(), before, saved, operatorId, name);
-        return complete(id, operatorId, action, key, detail(saved));
-    }
-
     @Transactional
     public void deleteDraft(long id, long operatorId, String operatorName, String key, ActionRequest request) {
         String action = "DELETE_DRAFT";
@@ -193,7 +156,6 @@ public class OceanBookingService {
         complete(null, operatorId, action, key, new Detail(before, List.of(), List.of(), List.of(), List.of()));
     }
 
-    /** 校验完整订舱资料后放舱，不以附件上传作为前置条件。 */
     @Transactional public Detail release(long id, long operatorId, String name, String key, ReleaseRequest request) {
         String action = "RELEASE";
         Detail replay = claimOrReplay(id, operatorId, action, key, hash(action, id, request));
@@ -202,6 +164,7 @@ public class OceanBookingService {
         requireStatus(before, OceanBookingStatus.DRAFT);
         validateRelease(before, repository.parties(id), repository.requirements(id));
         validateMasterData(before);
+        documents.requireActiveValidDocument(before);
         if (repository.transition(id, OceanBookingStatus.DRAFT.name(), OceanBookingStatus.RELEASED.name(),
             request.expectedVersion(), operatorId, name) != 1) throw concurrent();
         OceanBookingEntity after = required(id);
@@ -246,18 +209,7 @@ public class OceanBookingService {
     private OceanBookingEntity requiredVersionForUpdate(long id, int version) { OceanBookingEntity value = repository.findForUpdate(id); if (value == null) throw new BizException(ResultCode.NOT_FOUND, "订舱单不存在"); if (!Integer.valueOf(version).equals(value.getVersion())) throw concurrent(); return value; }
     private static void requireStatus(OceanBookingEntity value, OceanBookingStatus status) { if (!status.name().equals(value.getStatus())) throw conflict("订舱状态不允许当前操作"); }
 
-    /** 未采集使用空值；已填写的件数、重量和体积必须为正数且不超出存储精度。 */
-    private static void validateCargo(Integer count, java.math.BigDecimal weight, java.math.BigDecimal volume) {
-        if (count != null && (count < 1 || count > 999999999)) throw badRequest("货物件数必须为1到999999999的整数");
-        for (java.math.BigDecimal number : new java.math.BigDecimal[] {weight, volume}) {
-            if (number != null && (number.signum() <= 0 || number.scale() > 3
-                || number.precision() - number.scale() > 12)) throw badRequest("货物重量和体积必须为正数，最多12位整数和3位小数");
-        }
-    }
-
     private void validateDraftStructure(DraftData data) {
-        validateCargo(data.declaredPackageCount(), data.declaredGrossWeightKg(), data.declaredVolumeCbm());
-        validateCargo(data.actualPackageCount(), data.actualGrossWeightKg(), data.actualVolumeCbm());
         boolean hasCustomerId = data.customerId() != null;
         boolean hasCustomerName = StringUtils.hasText(data.customerName());
         if (!hasCustomerId && hasCustomerName) throw badRequest("客户名称不能脱离客户ID提交");
@@ -279,7 +231,6 @@ public class OceanBookingService {
         }
     }
     private static void validateRange(LocalDateTime from, LocalDateTime to) { if (from != null && to != null && to.isBefore(from)) throw badRequest("预计到港时间不能早于预计开船时间"); }
-    /** 放舱要求预计到港，供关联柜次的到港日历及默认到仓日期使用。 */
     private static void validateRelease(OceanBookingEntity booking, List<OceanBookingPartyEntity> parties,
                                         List<OceanBookingContainerRequirementEntity> requirements) {
         if (!StringUtils.hasText(booking.getChannelCode()) || booking.getWarehouseId() == null
@@ -291,7 +242,6 @@ public class OceanBookingService {
             || !StringUtils.hasText(booking.getPlaceOfDelivery())
             || !StringUtils.hasText(booking.getCarrierCode())
             || booking.getBookingAgentId() == null || parties == null || parties.size() != 3
-            || (parties != null && parties.stream().anyMatch(party -> !StringUtils.hasText(party.getPartyName())))
             || requirements == null || requirements.isEmpty()) throw badRequest("订舱资料尚未填写完整，无法发布");
         validateRange(booking.getEstimatedSailingAt(), booking.getEstimatedArrivalAt());
     }
@@ -348,17 +298,6 @@ public class OceanBookingService {
         v.setPlaceOfDelivery(trim(d.placeOfDelivery()));
         v.setEstimatedSailingAt(d.estimatedSailingAt()); v.setEstimatedArrivalAt(d.estimatedArrivalAt());
         v.setRemark(trim(d.remark()));
-        v.setFreightTerm(trim(d.freightTerm()));
-        v.setServiceTerm(trim(d.serviceTerm()));
-        v.setPackageUnit(trim(d.packageUnit()));
-        v.setCargoDescription(trim(d.cargoDescription()));
-        v.setMarksAndNos(trim(d.marksAndNos()));
-        v.setDeclaredPackageCount(d.declaredPackageCount());
-        v.setDeclaredGrossWeightKg(d.declaredGrossWeightKg());
-        v.setDeclaredVolumeCbm(d.declaredVolumeCbm());
-        v.setActualPackageCount(d.actualPackageCount());
-        v.setActualGrossWeightKg(d.actualGrossWeightKg());
-        v.setActualVolumeCbm(d.actualVolumeCbm());
     }
 
     private void requireUniqueBillOfLadingNo(String billOfLadingNo, Long excludedId) {
@@ -431,7 +370,7 @@ public class OceanBookingService {
         return normalized;
     }
 
-    private static List<OceanBookingPartyEntity> parties(long id, List<PartyRequest> requests) { if (requests == null) return List.of(); return requests.stream().map(r -> { OceanBookingPartyEntity v = new OceanBookingPartyEntity(); v.setId(IdWorker.getId()); v.setOceanBookingId(id); v.setPartyType(r.partyType().trim().toUpperCase()); v.setPartyName(r.partyName().trim()); v.setAddress(trim(r.address())); v.setContactName(trim(r.contactName())); v.setContactPhone(trim(r.contactPhone())); v.setContactEmail(trim(r.contactEmail())); v.setTaxNo(trim(r.taxNo())); return v; }).toList(); }
+    private static List<OceanBookingPartyEntity> parties(long id, List<PartyRequest> requests) { if (requests == null) return List.of(); return requests.stream().map(r -> { OceanBookingPartyEntity v = new OceanBookingPartyEntity(); v.setId(IdWorker.getId()); v.setOceanBookingId(id); v.setPartyType(r.partyType().trim().toUpperCase()); v.setPartyName(r.partyName().trim()); v.setAddress(trim(r.address())); v.setContactName(trim(r.contactName())); v.setContactPhone(trim(r.contactPhone())); return v; }).toList(); }
     private static List<OceanBookingContainerRequirementEntity> requirements(long id, List<ContainerRequirementRequest> requests) { if (requests == null) return List.of(); int[] sort = {0}; return requests.stream().map(r -> { var specification = ContainerSpecificationCatalog.requireMatch(r.containerType(), r.capacityCbm(), r.maxWeightKg()); OceanBookingContainerRequirementEntity v = new OceanBookingContainerRequirementEntity(); v.setId(IdWorker.getId()); v.setOceanBookingId(id); v.setContainerType(specification.containerType()); v.setContainerKind(r.containerKind().trim().toUpperCase()); v.setCapacityCbm(specification.capacityCbm()); v.setMaxWeightKg(specification.maxWeightKg()); v.setQuantity(r.quantity()); v.setSortNo(sort[0]++); return v; }).toList(); }
     private WarehouseMasterDataClient.Warehouse requireDomesticTransitWarehouse(long warehouseId) {
         try {

firstleg/src/main/java/com/baiyue/firstleg/portschedule/mapper/CarrierScheduleQueryMapper.java

@@ -63,7 +63,6 @@ public interface CarrierScheduleQueryMapper extends BaseMapper<CarrierScheduleQu
         """)
     CarrierScheduleQueryEntity findByContainerBookingId(@Param("containerBookingId") long containerBookingId);
 
-    /** 到港与日历统一取最新观测的实际记录，后续修正为更早时间时不能被历史最大值覆盖。 */
     @Select("""
         <script>
         SELECT b.id AS containerBookingId,q.id AS queryId,q.version AS queryVersion,
@@ -71,7 +70,7 @@ public interface CarrierScheduleQueryMapper extends BaseMapper<CarrierScheduleQu
                current.actual_at AS latestActualAt,
                MAX(CASE WHEN f.standard_node='DEPARTED_WAREHOUSE' THEN f.actual_at END) AS departedWarehouseAt,
                MAX(CASE WHEN f.standard_node='DEPARTED_ORIGIN_PORT' THEN f.actual_at END) AS departedOriginPortAt,
-               MAX(arrival.actual_at) AS arrivedDestinationPortAt,
+               MAX(CASE WHEN f.standard_node='ARRIVED_DESTINATION_PORT' THEN f.actual_at END) AS arrivedDestinationPortAt,
                MAX(CASE WHEN f.standard_node='PICKUP_READY' THEN f.actual_at END) AS pickupReadyAt,
                MAX(CASE WHEN f.standard_node='PICKED_UP' THEN f.actual_at END) AS pickedUpAt,
                MAX(CASE WHEN f.standard_node='EMPTY_RETURNED' THEN f.actual_at END) AS emptyReturnedAt
@@ -82,10 +81,6 @@ public interface CarrierScheduleQueryMapper extends BaseMapper<CarrierScheduleQu
                  ORDER BY f2.observed_at DESC,f2.id DESC LIMIT 1)
           LEFT JOIN fl_carrier_schedule_query q ON q.id=current.query_id
           LEFT JOIN fl_carrier_schedule_node_fact f ON f.container_booking_id=b.id AND f.actual_at IS NOT NULL
-          LEFT JOIN fl_carrier_schedule_node_fact arrival ON arrival.id=(
-                SELECT a.id FROM fl_carrier_schedule_node_fact a
-                 WHERE a.container_booking_id=b.id AND a.standard_node='ARRIVED_DESTINATION_PORT' AND a.actual_at IS NOT NULL
-                 ORDER BY a.observed_at DESC,a.id DESC LIMIT 1)
          WHERE b.id IN
          <foreach collection="containerBookingIds" item="id" open="(" separator="," close=")">#{id}</foreach>
          GROUP BY b.id,q.id,q.version,q.status,current.standard_node,current.actual_at

firstleg/src/main/java/com/baiyue/firstleg/portschedule/service/AppointmentForecastService.java

@@ -11,27 +11,16 @@ import java.util.stream.Collectors;
 @Service
 public class AppointmentForecastService {
     public record Forecast(Long containerBookingId,AppointmentForecastMapper.Fact latest,
-                           AppointmentForecastMapper.Fact previous,String timeBasis,
+                           AppointmentForecastMapper.Fact previous,String timeBasis) { }
-                           java.time.LocalDateTime portArrivalAt) { }
     private final AppointmentForecastMapper mapper;
-    private final com.baiyue.firstleg.terminaldrayage.repository.ContainerCalendarSourceRepository sources;
+    public AppointmentForecastService(AppointmentForecastMapper mapper){this.mapper=mapper;}
-    /** 读取船节点及日历权威到港来源，不从调用端接收推算日期。 */
-    public AppointmentForecastService(AppointmentForecastMapper mapper,
-        com.baiyue.firstleg.terminaldrayage.repository.ContainerCalendarSourceRepository sources) {
-        this.mapper=mapper; this.sources=sources;
-    }
-    /** 返回明确来源柜的到港事实，保留未知日期。 */
     public List<Forecast> batch(List<Long> ids) {
         if(ids==null || ids.isEmpty() || ids.size()>200 || ids.stream().anyMatch(id->id==null || id<=0)
             || new HashSet<>(ids).size()!=ids.size()) throw new ResponseStatusException(HttpStatus.BAD_REQUEST,"每批须提供1至200个不重复的柜次");
         var facts=mapper.latest(ids).stream().collect(Collectors.groupingBy(AppointmentForecastMapper.Fact::containerBookingId));
-        var arrivals=sources.byIds(ids).stream().collect(Collectors.toMap(
-            com.baiyue.firstleg.terminaldrayage.dto.ContainerCalendarSource::containerBookingId,
-            java.util.function.Function.identity()));
         return ids.stream().map(id->{
             var rows=facts.getOrDefault(id,List.of());
-            return new Forecast(id,rows.isEmpty()?null:rows.get(0),rows.size()<2?null:rows.get(1),"SOURCE_LOCAL_UNSPECIFIED",
+            return new Forecast(id,rows.isEmpty()?null:rows.get(0),rows.size()<2?null:rows.get(1),"SOURCE_LOCAL_UNSPECIFIED");
-                arrivals.containsKey(id)?arrivals.get(id).arrivalAt():null);
         }).toList();
     }
 }

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

@@ -383,12 +383,11 @@ public class FbaPricingRepository {
             .set(InboundFeeEntity::getConfirmedAt, now));
     }
 
-    /** 确认费用时保留物流主状态，一件代发待组托也允许确认。 */
     public int markInboundConfirmed(long tenantId, long inboundId) {
         return inbounds.update(null, new LambdaUpdateWrapper<InboundPricingEntity>()
             .eq(InboundPricingEntity::getTenantId, tenantId).eq(InboundPricingEntity::getId, inboundId)
             .in(InboundPricingEntity::getProcessStatus,
-                List.of("FEE_CONFIRMING", "WAIT_PALLET", "WAIT_PALLETIZE", "WAIT_SPLIT", "LOADING", "LOADED", "DELIVERED"))
+                List.of("FEE_CONFIRMING", "WAIT_PALLET", "WAIT_SPLIT", "LOADING", "LOADED", "DELIVERED"))
             .eq(InboundPricingEntity::getFeeStatus, "CALCULATED")
             .set(InboundPricingEntity::getFeeStatus, "CONFIRMED"));
     }

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

@@ -54,18 +54,6 @@ public class FeeItemRepository {
             .eq(FeeItemEntity::getFeeCode, feeCode));
     }
 
-    /** 海外录费仅提供平台启用的国际仓库收付费项目，不复制费用目录。 */
-    public List<FeeItemEntity> listActiveInternationalWarehouseItems(String direction) {
-        return feeItems.selectList(new LambdaQueryWrapper<FeeItemEntity>()
-            .eq(FeeItemEntity::getTenantId, PLATFORM_TENANT_ID)
-            .eq(FeeItemEntity::getStatus, "ACTIVE")
-            .eq(FeeItemEntity::getTradeScope, "INTERNATIONAL")
-            .eq("RECEIVABLE".equals(direction), FeeItemEntity::getWarehouseReceivable, true)
-            .eq("PAYABLE".equals(direction), FeeItemEntity::getWarehousePayable, true)
-            .orderByAsc(FeeItemEntity::getCategory)
-            .orderByAsc(FeeItemEntity::getFeeTypeName));
-    }
-
     public boolean itemNameExists(String tradeScope, String feeTypeName, Long excludedId) {
         return feeItems.selectCount(new LambdaQueryWrapper<FeeItemEntity>()
             .eq(FeeItemEntity::getTenantId, PLATFORM_TENANT_ID)

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

@@ -4,7 +4,6 @@ import com.baiyue.firstleg.entity.LoadingCompletionCommandEntity;
 import com.baiyue.firstleg.mapper.LoadingCompletionCommandMapper;
 import jakarta.annotation.Resource;
 import org.springframework.stereotype.Repository;
-import org.springframework.transaction.annotation.Transactional;
 
 import java.time.LocalDateTime;
 import java.util.List;
@@ -13,9 +12,6 @@ import java.util.List;
 public class LoadingCompletionCommandRepository {
     @Resource private LoadingCompletionCommandMapper mapper;
 
-    /** 按事务提交后的命令标识读取唯一完成请求。 */
-    public LoadingCompletionCommandEntity command(long id) { return mapper.selectById(id); }
-
     public int insert(LoadingCompletionCommandEntity command) { return mapper.insertCommand(command); }
     public LoadingCompletionCommandEntity operation(String operationId) { return mapper.findByOperation(operationId); }
     public LoadingCompletionCommandEntity active(long taskId) { return mapper.findActiveByTask(taskId); }
@@ -32,13 +28,7 @@ public class LoadingCompletionCommandRepository {
     public String checkpoint(long commandId, long tenantId, long inboundId) {
         return mapper.checkpoint(commandId, tenantId, inboundId);
     }
-    /** 命令行锁覆盖租约检查与检查点写入，旧执行者不能在租约易主后覆盖新结果。 */
+    public void checkpoint(long commandId, long tenantId, long inboundId, int sequence, String stage) {
-    @Transactional
+        mapper.checkpointCompleted(commandId, tenantId, inboundId, sequence, stage);
-    public boolean checkpoint(long commandId, String worker, long tenantId, long inboundId,
-                              int sequence, String stage) {
-        if (mapper.lockCheckpointLease(commandId, worker) == null) return false;
-        int written = mapper.checkpointCompleted(commandId, worker, tenantId, inboundId, sequence, stage);
-        // 同阶段重放可能被驱动计为零行；命令行仍被本事务锁住，重验租约区分幂等与过期拒绝。
-        return written > 0 || mapper.lockCheckpointLease(commandId, worker) != null;
     }
 }

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

@@ -12,7 +12,7 @@ import com.baiyue.firstleg.dto.ContainerDtos.FullUpdateRequest;
 import com.baiyue.firstleg.dto.ContainerDtos.SaveRequest;
 import com.baiyue.firstleg.dto.ContainerDtos.SimulationCreateRequest;
 import com.baiyue.firstleg.dto.ContainerDtos.OceanBookingLinkRequest;
-import com.baiyue.firstleg.domain.RealContainerNumber;
+import com.baiyue.firstleg.domain.Iso6346ContainerNumber;
 import com.baiyue.firstleg.entity.ContainerBookingEntity;
 import com.baiyue.firstleg.repository.ContainerRepository;
 import com.baiyue.firstleg.pricebookquery.application.model.PriceBookQueryRows.ChannelRow;
@@ -82,19 +82,15 @@ public class ContainerService {
         return value;
     }
 
-    /** 首次关联已放舱订舱，仅规范化柜号并保留关联资格与并发校验。 */
     @Transactional
     public ContainerBookingEntity linkOceanBooking(long id, long operatorId, String operatorName, OceanBookingLinkRequest request) {
         ContainerBookingEntity container = required(id); requireVersion(container, request.expectedVersion()); requireFirstLinkMutable(container);
         if (container.getOceanBookingId() != null) throw conflict("模拟柜已关联真实订舱柜");
         String existingContainerNo = trim(container.getContainerNo());
         String requestedContainerNo = trim(request.containerNo());
-        // 本关联入口不按 ISO 长度、结构或校验位阻断，仍统一空白与大小写以核对唯一性。
+        String containerNo = requestedContainerNo == null
-        if (requestedContainerNo != null) {
+            ? existingContainerNo
-            requestedContainerNo = trim(requestedContainerNo.replaceAll("[\\p{javaWhitespace}\\p{Z}]", "")
+            : Iso6346ContainerNumber.require(requestedContainerNo);
-                .toUpperCase(java.util.Locale.ROOT));
-        }
-        String containerNo = requestedContainerNo == null ? existingContainerNo : requestedContainerNo;
         if (existingContainerNo != null && !existingContainerNo.equals(containerNo)) {
             throw conflict("输入的真实集装箱号与当前柜次已录入柜号不一致，请先在预装运输信息中纠正");
         }
@@ -124,7 +120,6 @@ public class ContainerService {
         return required(id);
     }
 
-    /** 提柜后补录规范化真实柜号，保留同订舱唯一及作业冻结门禁。 */
     @Transactional
     public ContainerBookingEntity assignRealContainerNo(long id, String requestedContainerNo, int expectedVersion,
                                                          long operatorId, String operatorName) {
@@ -139,7 +134,7 @@ public class ContainerService {
             || repository.hasPickTask(id) || repository.hasEvidence(id) || repository.hasDocuments(id)) {
             throw conflict("已进入PDA、证据、单证或不可逆装柜阶段，不能补录真实柜号");
         }
-        String containerNo = RealContainerNumber.require(requestedContainerNo);
+        String containerNo = Iso6346ContainerNumber.require(requestedContainerNo);
         if (repository.containerNoExists(container.getOceanBookingId(), containerNo, id)) {
             throw conflict("当前提单下集装箱号已存在");
         }

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

@@ -9,77 +9,37 @@ import jakarta.annotation.Resource;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.scheduling.annotation.Scheduled;
-import org.springframework.core.task.TaskExecutor;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.event.TransactionalEventListener;
 
 import java.time.LocalDateTime;
 import java.util.UUID;
-import java.util.concurrent.RejectedExecutionException;
 
-/** 事务提交后立即处理 PDA 完成命令，并按持久化租约定时恢复。 */
+/** Lease-based recovery worker for PDA completion commands. */
 @Service
 public class LoadingCompletionWorker {
     private static final Logger log = LoggerFactory.getLogger(LoadingCompletionWorker.class);
     private static final int MAX_ATTEMPTS = 5;
+    private final String workerId = "pda-completion-" + UUID.randomUUID();
 
     @Resource private LoadingCompletionCommandRepository commands;
     @Resource private LoadingPickRepository picks;
     @Resource private LoadingPickService loadingPicks;
-    @Resource(name = "applicationTaskExecutor") private TaskExecutor completionExecutor;
 
-    /** 唤醒只发生在受理事务提交后，异步执行不延长 HTTP 受理请求。 */
-    @TransactionalEventListener
-    public void accepted(LoadingPickService.CompletionAccepted accepted) {
-        try {
-            completionExecutor.execute(() -> dispatchAccepted(accepted));
-        } catch (RejectedExecutionException exception) {
-            // 执行器繁忙或关闭时保留持久化命令，仍由定时扫描领取，不能影响已提交回执。
-            log.warn("pda_completion_wakeup_deferred commandId={}", accepted.commandId(), exception);
-        }
-    }
-
-    /** 唤醒与恢复共用原子领取；同一命令不会被两个执行入口重复结算。 */
-    private void dispatchAccepted(LoadingPickService.CompletionAccepted accepted) {
-        try {
-            LoadingCompletionCommandEntity command = commands.command(accepted.commandId());
-            if (command != null) process(command, "immediate", accepted.acceptedAtNanos());
-        } catch (RuntimeException exception) {
-            log.warn("pda_completion_wakeup_failed commandId={}", accepted.commandId(), exception);
-        }
-    }
-
-    /** 扫描到期或租约过期命令，覆盖唤醒丢失、进程重启及失败退避恢复。 */
     @Scheduled(fixedDelayString = "${baiyue.firstleg.pda-completion.fixed-delay-ms:2000}")
     public void dispatch() {
         for (LoadingCompletionCommandEntity candidate : commands.due(10)) {
-            process(candidate, "scheduled", System.nanoTime());
+            if (!commands.claim(candidate.getId(), workerId, LocalDateTime.now().plusMinutes(10))) {
+                continue;
+            }
+            try {
+                loadingPicks.processCompletion(candidate, workerId);
+            } catch (RuntimeException exception) {
+                handleFailure(candidate, exception);
+            }
         }
     }
 
-    /** 保留租约、检查点和失败恢复语义，记录领取及实际处理耗时。 */
+    private void handleFailure(LoadingCompletionCommandEntity command, RuntimeException exception) {
-    private void process(LoadingCompletionCommandEntity command, String source, long queuedAt) {
-        // 每次领取使用独立所有者，避免旧执行线程在租约过期、同进程重新领取后继续写入。
-        String leaseOwner = "pda-completion-" + UUID.randomUUID();
-        if (!commands.claim(command.getId(), leaseOwner, LocalDateTime.now().plusMinutes(10))) return;
-        long started = System.nanoTime();
-        boolean succeeded = false;
-        log.info("pda_completion_started commandId={} taskId={} source={} wakeupMs={}",
-            command.getId(), command.getPickTaskId(), source, (started - queuedAt) / 1_000_000);
-        try {
-            loadingPicks.processCompletion(command, leaseOwner);
-            succeeded = true;
-        } catch (RuntimeException exception) {
-            handleFailure(command, leaseOwner, exception);
-        } finally {
-            log.info("pda_completion_finished commandId={} taskId={} source={} durationMs={} succeeded={}",
-                command.getId(), command.getPickTaskId(), source, (System.nanoTime() - started) / 1_000_000,
-                succeeded);
-        }
-    }
-
-    /** 确定性失败关闭任务，其余故障按原退避与最大次数恢复。 */
-    private void handleFailure(LoadingCompletionCommandEntity command, String leaseOwner, RuntimeException exception) {
         Throwable cause = exception instanceof LoadingPickService.CompletionProcessingException
             && exception.getCause() != null ? exception.getCause() : exception;
         String stage = exception instanceof LoadingPickService.CompletionProcessingException staged
@@ -93,7 +53,7 @@ public class LoadingCompletionWorker {
         int attempt = command.getAttemptCount() == null ? 1 : command.getAttemptCount() + 1;
         boolean terminal = isDeterministicLocalBusinessFailure(stage, cause) || attempt >= MAX_ATTEMPTS;
         LocalDateTime retryAt = LocalDateTime.now().plusSeconds(Math.min(300L, 15L << Math.min(attempt - 1, 4)));
-        boolean recorded = commands.fail(command.getId(), leaseOwner, terminal ? "FAILED" : "RETRYABLE", retryAt,
+        boolean recorded = commands.fail(command.getId(), workerId, terminal ? "FAILED" : "RETRYABLE", retryAt,
             stage, code, requestId, traceId);
         if (terminal && recorded) {
             picks.failCompletion(command.getPickTaskId());
@@ -103,7 +63,6 @@ public class LoadingCompletionWorker {
             command.getOperationId(), stage, code, requestId, traceId, attempt, terminal, cause);
     }
 
-    /** 仅将已明确不可重试的本地业务门禁判为终态。 */
     private static boolean isDeterministicLocalBusinessFailure(String stage, Throwable cause) {
         if (!(cause instanceof BizException business)) {
             return false;

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

@@ -26,7 +26,7 @@ import com.baiyue.firstleg.loading.bridge.dto.LoadingModelBridgeDtos.Link;
 import com.baiyue.firstleg.repository.LoadingListRepository;
 import com.baiyue.firstleg.repository.LoadingPickRepository;
 import com.baiyue.firstleg.repository.ContainerRepository;
-import com.baiyue.firstleg.domain.RealContainerNumber;
+import com.baiyue.firstleg.domain.Iso6346ContainerNumber;
 import com.baiyue.firstleg.domain.PriceBookChannelCatalog;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JsonNode;
@@ -493,10 +493,10 @@ public class LoadingListService {
         return repository.preloadDetail(requirePlan(planId));
     }
 
-    /** 未提交柜号时保留原值，首次录入或纠错统一规范化并禁止清空。 */
     private static String targetContainerNo(AggregateRow before, String requested) {
-        if (requested == null) return StringUtils.hasText(before.getContainerNo()) ? before.getContainerNo() : null;
+        if (requested != null) return Iso6346ContainerNumber.require(requested);
-        return RealContainerNumber.require(requested);
+        return StringUtils.hasText(before.getContainerNo())
+            ? Iso6346ContainerNumber.require(before.getContainerNo()) : null;
     }
 
     private static String transportHash(long planId, int version, String containerNo,

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

@@ -23,7 +23,7 @@ import com.baiyue.firstleg.dto.LoadingPickDtos.InboundInventory;
 import com.baiyue.firstleg.dto.LoadingPickDtos.InventorySnapshot;
 import com.baiyue.firstleg.dto.LoadingPickDtos.InventoryUnit;
 import com.baiyue.firstleg.dto.LoadingPickDtos.PendingTask;
-import com.baiyue.firstleg.domain.RealContainerNumber;
+import com.baiyue.firstleg.domain.Iso6346ContainerNumber;
 import com.baiyue.firstleg.client.DomesticPdaOperatorClient;
 import com.baiyue.firstleg.entity.LoadingPickAssignmentEntity;
 import com.baiyue.firstleg.entity.LoadingPickHistoryEntity;
@@ -56,7 +56,6 @@ import jakarta.annotation.Resource;
 import org.springframework.dao.DuplicateKeyException;
 import org.springframework.stereotype.Service;
 import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.transaction.support.TransactionTemplate;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.StringUtils;
@@ -88,8 +87,6 @@ public class LoadingPickService {
     @Resource
     private LoadingCompletionCommandRepository completionCommands;
     @Resource
-    private ApplicationEventPublisher completionEvents;
-    @Resource
     private TransactionTemplate completionTransaction;
     @Resource
     private SmartLoadingRepository smartLoadingRepository;
@@ -140,7 +137,6 @@ public class LoadingPickService {
             smartLoadingRepository.items(plan.getId()));
     }
 
-    /** 确认预装前验证作业资格和真实柜号必填。 */
     public List<Link> requirePreloadConfirmationReady(long loadingPlanId) {
         inboundHoldGuard.requirePlanNotHeld(loadingPlanId);
         List<Link> links = loadingModelBridge.requireAllocatedLinksForConfirmation(loadingPlanId);
@@ -152,7 +148,6 @@ public class LoadingPickService {
             if (booking == null || !StringUtils.hasText(booking.getContainerNo())) {
                 throw conflict("确认预装前必须录入真实集装箱号");
             }
-            requireContainerNumberBeforeStarting(booking.getContainerNo());
             var allocation = oceanBookingRepository.allocationByContainer(link.containerBookingId());
             if (allocation == null) throw conflict("确认预装前必须关联真实订舱柜");
             var oceanBooking = oceanBookingRepository.find(allocation.getOceanBookingId());
@@ -166,14 +161,12 @@ public class LoadingPickService {
         return links;
     }
 
-    /** 仅在柜号已满足完成事件要求时创建 PDA 任务，已有任务的重复同步保持原语义。 */
     @Transactional
     public void begin(long planId, String containerNo, long operatorId, String operatorName,
                       List<LoadingPlanItemEntity> planItems) {
         inboundHoldGuard.requirePlanNotHeld(planId);
         LoadingPickTaskEntity task = repository.taskByPlan(planId);
         if (task == null) {
-            requireContainerNumberBeforeStarting(containerNo);
             task = new LoadingPickTaskEntity();
             task.setLoadingPlanId(planId);
             var booking = smartLoadingRepository.booking(smartLoadingRepository.plan(planId).getContainerBookingId());
@@ -559,7 +552,6 @@ public class LoadingPickService {
                     || !completionCommands.resume(replay.getId()) || repository.resumeCompletion(taskId) != 1) {
                     throw conflict("装柜完成命令状态已变化，请刷新后重试");
                 }
-                completionEvents.publishEvent(new CompletionAccepted(replay.getId(), System.nanoTime()));
             }
             return view(requiredTask(taskId), null);
         }
@@ -606,37 +598,22 @@ public class LoadingPickService {
         if (repository.acceptCompletion(taskId, task.getVersion()) != 1) {
             throw conflict("PDA任务版本已变化，请刷新后复核");
         }
-        // 提交后立即唤醒仍经持久化租约领取；回滚不得触发结算，定时扫描继续负责故障恢复。
-        completionEvents.publishEvent(new CompletionAccepted(command.getId(), System.nanoTime()));
         return view(requiredTask(taskId), null);
     }
 
-    /** 本进程事务提交后的唤醒信号，权威命令和恢复事实仍保存在数据库。 */
-    public record CompletionAccepted(long commandId, long acceptedAtNanos) {}
-
-    /** 确认预装和创建 PDA 任务前要求柜号非空，不以 ISO 格式阻断作业。 */
-    private static void requireContainerNumberBeforeStarting(String containerNo) {
-        try {
-            RealContainerNumber.require(containerNo);
-        } catch (BizException exception) {
-            throw conflict("请先在预装运输信息中录入真实集装箱号后再确认预装或启动PDA");
-        }
-    }
-
-    /** 完成前复核真实柜号，以生成一致的跨服务装柜完成事件。 */
     private void requireCompletionContainerNumber(long taskId) {
         ContainerBookingEntity booking = repository.activeBookingByTask(taskId);
         if (booking == null || !StringUtils.hasText(booking.getContainerNo())) {
             throw conflict("PDA确认装柜完成前必须录入真实集装箱号");
         }
         try {
-            RealContainerNumber.require(booking.getContainerNo());
+            Iso6346ContainerNumber.require(booking.getContainerNo());
         } catch (BizException exception) {
-            throw conflict("PDA确认装柜完成前必须录入真实集装箱号");
+            throw conflict("PDA确认装柜完成前必须录入符合ISO 6346的真实集装箱号");
         }
     }
 
-    /** 仅在持久化租约领取成功后执行，远程结算不占用受理事务。 */
+    /** Called only by the completion worker, after its durable lease has committed. */
     public void processCompletion(LoadingCompletionCommandEntity command, String worker) {
         long taskId = command.getPickTaskId();
         inboundHoldGuard.requireTaskNotHeld(taskId);
@@ -648,55 +625,55 @@ public class LoadingPickService {
             .toList();
         if (owners.isEmpty()) throw new CompletionProcessingException("OWNER_DISCOVERY", conflict("PDA任务未关联有效入库单"));
         List<GroupSnapshot> taskGroups = coloadGroups(owners);
-        runCompletionStage(taskId, "CABINET_EVIDENCE", () ->
+        runCompletionStage("CABINET_EVIDENCE", () ->
             cabinetEvidenceService.requireComplete(task.getContainerBookingId()));
-        runCompletionStage(taskId, "COMPLETED_EVENT_READY", () ->
+        runCompletionStage("COMPLETED_EVENT_READY", () ->
             loadingListService.requireCompletedEventReady(task.getLoadingPlanId()));
 
-        // 全柜所有客户先通过只读门禁，再开始资源结算，避免后续客户失败造成前序客户局部完成。
+        // Phase 1 is read-only: cabinet evidence is checked once, then every owner must pass its business gates
+        // before any warehouse resource or inbound status can be changed. This prevents a later customer gate from
+        // leaving earlier customers partially completed.
         for (int index = 0; index < owners.size(); index++) {
             requireCompletionLease(command.getId(), worker);
             LoadingPickItemMapper.InboundOwner owner = owners.get(index);
             String checkpoint = completionCommands.checkpoint(command.getId(), owner.tenantId(), owner.inboundId());
             if (!checkpointAtLeast(checkpoint, "SETTLED")) {
-                runCompletionStage(taskId, "OWNER_READY", () -> loadingDeliveryService.requirePdaCompletionReady(
+                runCompletionStage("OWNER_READY", () -> loadingDeliveryService.requirePdaCompletionReady(
                     owner.tenantId(), owner.inboundId()));
                 if (!checkpointAtLeast(checkpoint, "READY")) {
-                    recordCompletionCheckpoint(command.getId(), worker, owner.tenantId(), owner.inboundId(),
+                    requireCompletionLease(command.getId(), worker);
+                    completionCommands.checkpoint(command.getId(), owner.tenantId(), owner.inboundId(),
                         index + 1, "READY");
                 }
             }
         }
 
-        // 全柜门禁通过后，按客户检查点和稳定幂等键逐步结算，已完成的检查点可安全续做。
+        // Phase 2 is recoverable by per-owner checkpoints and stable idempotency keys. It starts only after the
+        // complete cabinet passed phase 1, while prior deployments' completed checkpoints remain safely resumable.
         for (int index = 0; index < owners.size(); index++) {
             requireCompletionLease(command.getId(), worker);
             LoadingPickItemMapper.InboundOwner owner = owners.get(index);
             String checkpoint = completionCommands.checkpoint(command.getId(), owner.tenantId(), owner.inboundId());
             if (!checkpointAtLeast(checkpoint, "SETTLED")) {
-                runCompletionStage(taskId, "WAREHOUSE_SETTLEMENT", () -> settlementService.settleOwner(
+                runCompletionStage("WAREHOUSE_SETTLEMENT", () -> settlementService.settleOwner(
                     taskId, owner.inboundId(), command.getOperatorId(), command.getOperatorName()));
-                recordCompletionCheckpoint(command.getId(), worker, owner.tenantId(), owner.inboundId(), index + 1, "SETTLED");
+                requireCompletionLease(command.getId(), worker);
+                completionCommands.checkpoint(command.getId(), owner.tenantId(), owner.inboundId(), index + 1, "SETTLED");
             }
             if (!checkpointAtLeast(checkpoint, "INBOUND_COMPLETED")) {
-                runCompletionStage(taskId, "INBOUND_COMPLETE", () -> loadingDeliveryService.completeAfterPdaSettlement(
+                runCompletionStage("INBOUND_COMPLETE", () -> loadingDeliveryService.completeAfterPdaSettlement(
                     owner.tenantId(), owner.inboundId(),
                     command.getOperatorId(), command.getOperatorName(),
                     "PDA-" + command.getOperationId() + '-' + owner.inboundId(), command.getRemark()));
-                recordCompletionCheckpoint(command.getId(), worker, owner.tenantId(), owner.inboundId(), index + 1,
+                requireCompletionLease(command.getId(), worker);
+                completionCommands.checkpoint(command.getId(), owner.tenantId(), owner.inboundId(), index + 1,
                     "INBOUND_COMPLETED");
             }
         }
-        long transactionStarted = System.nanoTime();
+        completionTransaction.executeWithoutResult(ignored -> finalizeCompletion(command, worker, task, taskGroups));
-        try {
-            completionTransaction.executeWithoutResult(ignored -> finalizeCompletion(command, worker, task, taskGroups));
-        } finally {
-            log.info("pda_completion_transaction taskId={} durationMs={}", taskId,
-                (System.nanoTime() - transactionStarted) / 1_000_000);
-        }
     }
 
-    /** 远程结算完成后，仅在短事务内收敛 Firstleg 本地完成事实。 */
+    /** Final Firstleg convergence only; all remote owner settlement calls have completed before this short transaction. */
     private void finalizeCompletion(LoadingCompletionCommandEntity command, String worker,
                                     LoadingPickTaskEntity task, List<GroupSnapshot> taskGroups) {
         long taskId = task.getId();
@@ -711,11 +688,11 @@ public class LoadingPickService {
             insertOperation(taskId, command.getOperationId(), command.getRequestHash(), "COMPLETE_LOADING",
                 command.getOperatorId(), command.getOperatorName());
         }
-        runCompletionStage(taskId, "PLAN_COMPLETE", () -> loadingListService.finishFromPda(task.getLoadingPlanId(), taskId,
+        runCompletionStage("PLAN_COMPLETE", () -> loadingListService.finishFromPda(task.getLoadingPlanId(), taskId,
             command.getOperatorId(), command.getOperatorName()));
-        runCompletionStage(taskId, "COMPLETED_EVENT", () -> loadingListService.publishCompletedEvent(task.getLoadingPlanId()));
+        runCompletionStage("COMPLETED_EVENT", () -> loadingListService.publishCompletedEvent(task.getLoadingPlanId()));
         for (GroupSnapshot group : taskGroups) {
-            runCompletionStage(taskId, "COLOAD_CONSUME", () -> coloadGroups.consumeWholeGroup(group.groupId(),
+            runCompletionStage("COLOAD_CONSUME", () -> coloadGroups.consumeWholeGroup(group.groupId(),
                 task.getLoadingPlanId(), "PDA-CONSUME-" + hash(command.getOperationId() + '|'
                     + group.groupId()).substring(0, 48), command.getOperatorId(), command.getOperatorName()));
         }
@@ -773,14 +750,6 @@ public class LoadingPickService {
         }
     }
 
-    /** 检查点失去当前有效租约时立即停止，不再推进后续客户或柜次。 */
-    private void recordCompletionCheckpoint(long commandId, String worker, long tenantId, long inboundId,
-                                            int sequence, String stage) {
-        if (!completionCommands.checkpoint(commandId, worker, tenantId, inboundId, sequence, stage)) {
-            throw new CompletionProcessingException("LEASE_LOST", conflict("装柜完成命令租约已变化"));
-        }
-    }
-
     private static void requireSameCompletionCommand(LoadingCompletionCommandEntity command, long taskId,
                                                      String requestHash, long operatorId) {
         if (command == null || !Long.valueOf(taskId).equals(command.getPickTaskId())
@@ -795,18 +764,11 @@ public class LoadingPickService {
         return checkpoint != null && stages.indexOf(checkpoint) >= stages.indexOf(target);
     }
 
-    /** 记录实际阶段耗时，区分业务处理与调度、前端刷新等待。 */
+    private static void runCompletionStage(String stage, Runnable action) {
-    private static void runCompletionStage(long taskId, String stage, Runnable action) {
-        long started = System.nanoTime();
-        boolean succeeded = false;
         try {
             action.run();
-            succeeded = true;
         } catch (RuntimeException exception) {
             throw new CompletionProcessingException(stage, exception);
-        } finally {
-            log.info("pda_completion_stage taskId={} stage={} durationMs={} succeeded={}",
-                taskId, stage, (System.nanoTime() - started) / 1_000_000, succeeded);
         }
     }
 

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

@@ -1,53 +0,0 @@
-package com.baiyue.firstleg.service;
-
-import com.baiyue.common.core.api.ResultCode;
-import com.baiyue.common.core.exception.BizException;
-import com.baiyue.firstleg.entity.FeeItemEntity;
-import com.baiyue.firstleg.repository.FeeItemRepository;
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Service;
-
-import java.math.BigDecimal;
-import java.util.List;
-
-/** 向海外业务提供公共费用目录的只读切片，项目维护仍归头程主数据。 */
-@Service
-@RequiredArgsConstructor
-public class SharedFeeCatalogService {
-    private final FeeItemRepository repository;
-
-    /** 按收付方向返回当前可使用的费用项目。 */
-    public List<Item> list(String direction) {
-        requireDirection(direction);
-        return repository.listActiveInternationalWarehouseItems(direction).stream()
-            .map(SharedFeeCatalogService::snapshot).toList();
-    }
-
-    /** 写入业务费用前重新验证项目资格，停用或方向变化不得沿用旧选项。 */
-    public Item requireActive(String code, String direction) {
-        requireDirection(direction);
-        FeeItemEntity item = repository.findItemByCode(code);
-        if (item == null || !"ACTIVE".equals(item.getStatus())
-            || !"INTERNATIONAL".equals(item.getTradeScope())
-            || !("RECEIVABLE".equals(direction)
-                ? Boolean.TRUE.equals(item.getWarehouseReceivable())
-                : Boolean.TRUE.equals(item.getWarehousePayable()))) {
-            throw new BizException(ResultCode.CONFLICT, "费用项目未启用或不适用于本次收费");
-        }
-        return snapshot(item);
-    }
-
-    /** 校验显式收付方向，防止空方向绕过目录过滤。 */
-    private static void requireDirection(String direction) {
-        if (!"RECEIVABLE".equals(direction) && !"PAYABLE".equals(direction)) {
-            throw new BizException(ResultCode.BAD_REQUEST, "请选择费用收付方向");
-        }
-    }
-
-    /** 返回有限字段，不向其他服务暴露目录实体或审计属性。 */
-    private static Item snapshot(FeeItemEntity item) {
-        return new Item(item.getFeeCode(), item.getFeeTypeName(), item.getDefaultPrice());
-    }
-
-    public record Item(String code, String name, BigDecimal defaultPrice) { }
-}

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

@@ -9,6 +9,7 @@ import com.baiyue.firstleg.dto.TruckAppointmentDtos.*;
 import com.baiyue.firstleg.entity.*;
 import com.baiyue.firstleg.oceanbooking.entity.OceanBookingEntity;
 import com.baiyue.firstleg.oceanbooking.repository.OceanBookingRepository;
+import com.baiyue.firstleg.oceanbooking.service.OceanBookingDocumentService;
 import com.baiyue.firstleg.repository.TruckAppointmentRepository;
 import com.baiyue.firstleg.client.TruckAppointmentFileClient;
 import jakarta.annotation.Resource;
@@ -35,6 +36,7 @@ public class TruckAppointmentService {
  @Resource TruckAppointmentRepository repo;
  @Resource TruckAppointmentCompletionService completion;
  @Resource OceanBookingRepository oceanBookings;
+ @Resource OceanBookingDocumentService oceanBookingDocuments;
  @Resource TruckAppointmentFileClient files;
  @Resource WarehouseSupplierSnapshotService suppliers;
  @Resource FirstlegDocumentNumberGenerator documentNumbers;
@@ -62,13 +64,13 @@ public class TruckAppointmentService {
   return completeOperation(id,action,idem,enrich(required(id)));
  }
  @Transactional public TruckAppointmentEntity reschedule(long id,LocalDateTime at,ActionRequest r,String idem,String clientHash,long uid,String name){String action="RESCHEDULE";String requestHash=hash(action,id,new ReschedulePayload(at,r));verifyClientHash(clientHash,requestHash);TruckAppointmentEntity replay=claimOrReplay(id,action,idem,requestHash);if(replay!=null)return replay;TruckAppointmentEntity e=required(id);completion.lockBooking(e.getOceanBookingId());checkVersion(e,r.expectedVersion()); if(e.getStatus()==TruckAppointmentStatus.COMPLETED||e.getStatus()==TruckAppointmentStatus.CANCELLED)throw conflict("当前状态不可改约"); TruckAppointmentEntity active=repo.firstActiveForUpdate(e.getOceanBookingId());if(active!=null&&!Objects.equals(active.getId(),e.getId()))throw existingAppointmentConflict(active);String from=e.getStatus().name(); if(repo.reschedule(id,at,r.reason(),e.getVersion())!=1)throw conflict("状态或版本已变化，请刷新后重试");TruckAppointmentEntity after=enrich(required(id));record(after,from,"RESCHEDULED",action,r.reason(),uid,name);completion.completeForBooking(e.getOceanBookingId());return completeOperation(id,action,idem,enrich(required(id)));}
- /** 从已放舱订舱校验仓库和提单号，附件不作为预约条件。 */
  private AssociationContext validateAssociations(SaveRequest r){
   OceanBookingEntity booking=oceanBookings.find(r.oceanBookingId());
   if(booking==null)throw new BizException(ResultCode.NOT_FOUND,"关联订舱不存在");
   if(!"RELEASED".equals(booking.getStatus()))throw conflict("拖车预约只能选择已放舱订舱");
   Long warehouseId=mergeWarehouse(r.warehouseId(),booking.getWarehouseId(),"订舱");
   String billOfLadingNo=releasedBookingBill(booking,trim(r.billOfLadingNo()));
+  oceanBookingDocuments.requireActiveValidDocument(booking);
   return new AssociationContext(booking,warehouseId,billOfLadingNo);
  }
  private static void validateRequired(SaveRequest r){if(r.oceanBookingId()==null||r.oceanBookingId()<=0)throw bad("oceanBookingId不能为空");if(r.carrierId()==null||r.carrierId()<=0)throw bad("carrierId不能为空");if(r.plannedLoadingAt()==null)throw bad("plannedLoadingAt不能为空");if(r.expectedVersion()==null||r.expectedVersion()<0)throw bad("expectedVersion不合法");if(r.payableAmount()!=null&&(r.payableAmount().signum()<0||r.payableAmount().scale()>2))throw bad("拖车费必须为非负数且最多两位小数");}
@@ -83,13 +85,13 @@ public class TruckAppointmentService {
  private static void verifyClientHash(String clientHash,String serverHash){if(StringUtils.hasText(clientHash)&&!serverHash.equalsIgnoreCase(clientHash.trim()))throw bad("X-Request-Hash与请求内容不一致");}
  private static void validateKey(String key){if(!StringUtils.hasText(key)||key.trim().length()>128)throw bad("Idempotency-Key不能为空且不能超过128个字符");}
  private record ReschedulePayload(LocalDateTime plannedLoadingAt,ActionRequest request){}
- /** 派车时复核订舱放舱状态及提单号，不要求订舱附件。 */
  private String requireDispatchReady(TruckAppointmentEntity appointment){
   if(appointment.getOceanBookingId()==null)throw conflict("拖车预约缺少订舱关联");
   OceanBookingEntity booking=oceanBookings.find(appointment.getOceanBookingId());
   if(booking==null)throw new BizException(ResultCode.NOT_FOUND,"关联订舱不存在");
   if(!"RELEASED".equals(booking.getStatus()))throw conflict("关联订舱尚未放舱");
   String bill=releasedBookingBill(booking,trim(appointment.getBillOfLadingNo()));
+  oceanBookingDocuments.requireActiveValidDocument(booking);
   return bill;
  }
  private static String releasedBookingBill(OceanBookingEntity booking,String requested){String authoritative=trim(booking.getBillOfLadingNo());if(!StringUtils.hasText(authoritative))throw conflict("关联已放舱订舱缺少提单号");if(StringUtils.hasText(requested)&&!authoritative.equals(requested))throw bad("billOfLadingNo与关联订舱不一致");return authoritative;}

firstleg/src/main/java/com/baiyue/firstleg/terminaldrayage/mapper/ContainerCalendarSourceMapper.java

@@ -9,31 +9,10 @@ import java.util.List;
 
 @Mapper
 public interface ContainerCalendarSourceMapper {
-    /** 按明确来源柜读取到港事实；目的港优先显示名称，未填名称时显示已保存代码。 */
+    /** 同时选出到港、缺日期和可能还柜的有效出仓柜，最终日期由业务服务复核。 */
-    @Select("""
-        <script>
-        SELECT c.id containerBookingId,c.cabinet_no cabinetNo,c.container_no containerNo,
-          c.vessel_name vesselName,c.voyage_no voyageNo,
-          COALESCE(NULLIF(TRIM(c.destination_port_name),''),NULLIF(TRIM(c.destination_port_code),'')) destinationPortName,
-          c.destination_warehouse_code destinationWarehouseCode,
-          COALESCE(n.actual_at,c.actual_port_arrival_at,c.estimated_port_arrival_at) arrivalAt,
-          CASE WHEN COALESCE(n.actual_at,c.actual_port_arrival_at) IS NOT NULL THEN 'ACTUAL' ELSE 'ESTIMATED' END arrivalType
-        FROM fl_container_booking c
-        LEFT JOIN fl_carrier_schedule_node_fact n ON n.id=(
-          SELECT f.id FROM fl_carrier_schedule_node_fact f WHERE f.container_booking_id=c.id
-            AND f.standard_node='ARRIVED_DESTINATION_PORT' AND f.actual_at IS NOT NULL
-          ORDER BY f.observed_at DESC,f.id DESC LIMIT 1)
-        WHERE c.record_status='ACTIVE' AND c.id IN
-        <foreach collection='ids' item='id' open='(' separator=',' close=')'>#{id}</foreach>
-        </script>
-        """)
-    List<ContainerCalendarSource> byIds(@Param("ids") List<Long> ids);
-
-    /** 选出到港、缺日期和可能还柜的有效出仓柜；目的港名称为空时展示代码，最终日期由服务复核。 */
     @Select("""
         SELECT c.id containerBookingId,c.cabinet_no cabinetNo,c.container_no containerNo,
-          c.vessel_name vesselName,c.voyage_no voyageNo,
+          c.vessel_name vesselName,c.voyage_no voyageNo,c.destination_port_name destinationPortName,
-          COALESCE(NULLIF(TRIM(c.destination_port_name),''),NULLIF(TRIM(c.destination_port_code),'')) destinationPortName,
           c.destination_warehouse_code destinationWarehouseCode,
           COALESCE(n.actual_at,c.actual_port_arrival_at,c.estimated_port_arrival_at) arrivalAt,
           CASE WHEN COALESCE(n.actual_at,c.actual_port_arrival_at) IS NOT NULL THEN 'ACTUAL' ELSE 'ESTIMATED' END arrivalType

firstleg/src/main/java/com/baiyue/firstleg/terminaldrayage/repository/ContainerCalendarSourceRepository.java

@@ -11,8 +11,6 @@ public class ContainerCalendarSourceRepository {
     private final ContainerCalendarSourceMapper mapper;
     /** 使用本服务 Mapper 读取日历所需柜级来源。 */
     public ContainerCalendarSourceRepository(ContainerCalendarSourceMapper mapper) { this.mapper = mapper; }
-    /** 内部批量读取明确柜次，日期口径与平台日历一致。 */
-    public List<ContainerCalendarSource> byIds(List<Long> ids) { return mapper.byIds(ids); }
     /** 到港前移两天覆盖默认到仓，直送还柜候选额外留一天覆盖夏令时。 */
     public List<ContainerCalendarSource> sources(LocalDate from, LocalDate to) {
         return mapper.sources(from.atStartOfDay(), from.minusDays(2).atStartOfDay(),

firstleg/src/main/java/com/baiyue/firstleg/workflow/WorkflowFactMapper.java

@@ -17,8 +17,7 @@ public interface WorkflowFactMapper {
  +"EXISTS(SELECT 1 "+ACTUAL+" AND EXISTS(SELECT 1 FROM fl_carrier_schedule_node_fact n WHERE n.container_booking_id=b.id AND n.standard_node='DEPARTED_ORIGIN_PORT' AND n.actual_at IS NOT NULL)) departed,"
  +"EXISTS(SELECT 1 "+ACTUAL+" AND EXISTS(SELECT 1 FROM fl_container_document d WHERE d.container_booking_id=b.id AND d.document_type='DESTINATION_CLEARANCE' AND d.file_id IS NOT NULL)) clearance_uploaded,"
  +"EXISTS(SELECT 1 "+ACTUAL+" AND i.tax_mode='TAX_REFUND' AND NOT EXISTS(SELECT 1 FROM fl_customs_customer_document_inbound s JOIN fl_customs_customer_document d ON d.id=s.document_id AND d.tenant_id=i.tenant_id AND d.status='ACTIVE' JOIN fl_customs_container c ON c.id=d.customs_container_id AND c.loading_plan_id=p.id WHERE s.inbound_id=i.id AND s.tenant_id=i.tenant_id)) missing_customs,"
- +"EXISTS(SELECT 1 "+ACTUAL+" AND (i.tax_mode='BUY_DECLARATION' OR EXISTS(SELECT 1 FROM fl_customs_customer_document_inbound s JOIN fl_customs_customer_document d ON d.id=s.document_id AND d.tenant_id=i.tenant_id AND d.status='ACTIVE' JOIN fl_customs_container c ON c.id=d.customs_container_id AND c.loading_plan_id=p.id WHERE s.inbound_id=i.id AND s.tenant_id=i.tenant_id))) export_customs_ready,"
+ +"EXISTS(SELECT 1 "+ACTUAL+" AND (i.tax_mode='BUY_DECLARATION' OR EXISTS(SELECT 1 FROM fl_customs_customer_document_inbound s JOIN fl_customs_customer_document d ON d.id=s.document_id AND d.tenant_id=i.tenant_id AND d.status='ACTIVE' JOIN fl_customs_container c ON c.id=d.customs_container_id AND c.loading_plan_id=p.id WHERE s.inbound_id=i.id AND s.tenant_id=i.tenant_id))) export_customs_ready "
- +"EXISTS(SELECT 1 "+ACTUAL+" AND EXISTS(SELECT 1 FROM fl_customs_container c WHERE c.loading_plan_id=p.id AND c.status='COMPLETED')) customs_completed "
  +"FROM fl_inbound_order i WHERE i.deleted=0 AND NOT EXISTS(SELECT 1 FROM fl_inbound_order child WHERE child.tenant_id=i.tenant_id AND child.parent_inbound_id=i.id AND child.inbound_role='CHILD' AND (child.split_purpose IS NULL OR child.split_purpose != 'REMAINDER') AND child.deleted=0) AND i.process_status != 'CANCELLED' AND i.id IN "
  +"<foreach collection='ids' item='id' open='(' separator=',' close=')'>#{id}</foreach></script>")
  List<WorkflowFacts.Fact> facts(@Param("ids") List<Long> ids);

firstleg/src/main/java/com/baiyue/firstleg/workflow/WorkflowFacts.java

@@ -5,7 +5,7 @@ public final class WorkflowFacts {
  /** 仅承载事实查询契约，不允许实例化。 */
  private WorkflowFacts() {}
  public record Fact(long tenantId,long inboundId,long orderId,String reviewStatus,
- boolean departed,boolean clearanceUploaded,boolean missingCustoms,boolean exportCustomsReady,boolean customsCompleted) {}
+ boolean departed,boolean clearanceUploaded,boolean missingCustoms,boolean exportCustomsReady) {}
  public record Source(long tenantId,long inboundId) {}
  public record Request(List<Source> sources) {}
  public record Overseas(long tenantId,long inboundId,boolean outboundExists,boolean pendingOutbound,boolean delivering,boolean unloaded) {}

firstleg/src/main/java/com/baiyue/firstleg/workflow/WorkflowTabService.java

@@ -24,7 +24,7 @@ public class WorkflowTabService {
  var facts=repository.facts(batch.stream().map(InboundOrderEntity::getId).toList());
  // 确认页签复用已推送费用版本。
  for(var fee:repository.feeConfirmationRows(facts.stream().map(WorkflowFacts.Fact::inboundId).toList())) {
- if(facts.stream().noneMatch(f->f.tenantId()==fee.tenantId() && f.orderId()==fee.orderId())) throw unavailable("费用确认事实不属于本批入仓来源");
+ if(facts.stream().noneMatch(f->f.tenantId()==fee.tenantId() && f.orderId()==fee.orderId())) throw unavailable();
  result.putIfAbsent(fee.orderId()+":"+fee.mainStatus(),fee);
  }
  var sources=facts.stream().filter(WorkflowFacts.Fact::departed).map(f->new WorkflowFacts.Source(f.tenantId(),f.inboundId())).distinct().toList();
@@ -32,24 +32,19 @@ public class WorkflowTabService {
  if(!sources.isEmpty()) {
  try {
  var response=lastleg.read(token,new WorkflowFacts.Request(sources));
- if(response==null || !response.successful() || response.data()==null) throw unavailable(
+ if(response==null || !response.successful() || response.data()==null) throw unavailable();
-     "尾程事实响应无效 code="+(response==null?null:response.code())
-     +" requestId="+(response==null?null:response.requestId())+" traceId="+(response==null?null:response.traceId()));
  var allowed=new HashSet<>(sources);
  for(var fact:response.data()) {
- if(fact==null || !allowed.contains(new WorkflowFacts.Source(fact.tenantId(),fact.inboundId()))) throw unavailable("尾程事实包含空记录或本批以外的客户/入仓来源");
+ if(fact==null || !allowed.contains(new WorkflowFacts.Source(fact.tenantId(),fact.inboundId()))) throw unavailable();
  overseas.merge(fact.tenantId()+":"+fact.inboundId(),fact,(a,b)->new WorkflowFacts.Overseas(a.tenantId(),a.inboundId(),a.outboundExists()||b.outboundExists(),a.pendingOutbound()||b.pendingOutbound(),a.delivering()||b.delivering(),a.unloaded()&&b.unloaded()));
  }
- if(overseas.size()!=sources.size()) throw unavailable("尾程事实缺少来源 expected="+sources.size()+" actual="+overseas.size()
+ if(overseas.size()!=sources.size()) throw unavailable();
-     +" missing="+sources.stream().filter(s->!overseas.containsKey(s.tenantId()+":"+s.inboundId())).limit(20).toList());
+ } catch(BizException e) { throw e; } catch(Exception e) { throw unavailable(); }
- } catch(BizException e) { throw e; } catch(Exception e) {
-     throw (BizException) new BizException(ResultCode.SERVICE_UNAVAILABLE,"订单业务页签事实暂不可用，请稍后重试").initCause(e);
- }
  }
  // SQL排除仅作汇总的父票；保留承接实际装柜数量的来源票及独立余量票。
  for(var fact:facts) {
  var inbound=expected.get(fact.inboundId());
- if(inbound==null || !Objects.equals(inbound.getTenantId(),fact.tenantId()) || !Objects.equals(inbound.getOrderId(),fact.orderId())) throw unavailable("头程事实与入仓单归属不一致 inboundId="+fact.inboundId());
+ if(inbound==null || !Objects.equals(inbound.getTenantId(),fact.tenantId()) || !Objects.equals(inbound.getOrderId(),fact.orderId())) throw unavailable();
  var o=overseas.get(fact.tenantId()+":"+fact.inboundId());
  for(String key:classify(fact,inbound.getProcessStatus(),o)) result.putIfAbsent(fact.orderId()+":"+key,new StatusRow(fact.tenantId(),fact.orderId(),key));
  }
@@ -61,18 +56,16 @@ public class WorkflowTabService {
  Set<String> keys=new LinkedHashSet<>();
  if("MEASURE_PENDING".equals(process) && "PENDING".equals(f.reviewStatus())) keys.add("MEASUREMENT_REVIEW");
  boolean signed="DELIVERED".equals(process);
- // 人工补录或船司查询的实际开船节点才推进阶段，报关完成和提前上传资料不能代替开船。
+ // 报关页签按资料与实装事实汇总，不依赖点击开始报关；实际开船后转入清关链路。
- boolean clearanceStage=f.departed();
+ if(!f.departed() && !signed) {
- if(!clearanceStage && !signed) {
  if(f.missingCustoms()) keys.add("WAIT_CUSTOMS_DOCS");
- if(f.exportCustomsReady() || f.customsCompleted()) keys.add("EXPORT_CUSTOMS");
+ if(f.exportCustomsReady()) keys.add("EXPORT_CUSTOMS");
  }
  if(signed) keys.add("SIGNED");
- if(clearanceStage && !signed) {
+ if(f.departed() && !signed) {
  if(!f.clearanceUploaded()) keys.add("SAILING_CLEARANCE");
- // 清关资料保存成功后才进入海外待办；出库事实优先于拆柜和排车待办。
+ if(o!=null) {
- if(f.clearanceUploaded() && o!=null) {
+ if(f.clearanceUploaded() && !o.unloaded()) keys.add("WAIT_UNLOAD");
- if(!o.outboundExists() && !o.unloaded()) keys.add("WAIT_UNLOAD");
  // 取消的出库不构成有效覆盖，读取事实后自动回显，不能保存永久隐藏标志。
  if(!o.outboundExists()) keys.add("WAIT_DISPATCH");
  if(o.pendingOutbound()) keys.add("OUTBOUND_DOCUMENT");
@@ -82,9 +75,5 @@ public class WorkflowTabService {
  return keys;
  }
  /** 下游缺失或归属异常不能生成部分数量。 */
- private static BizException unavailable(String reason) {
+ private static BizException unavailable() { return new BizException(ResultCode.SERVICE_UNAVAILABLE,"订单业务页签事实暂不可用，请稍后重试"); }
-     // 诊断信息只进入服务日志，公开响应保持稳定，不暴露内部来源标识。
-     return (BizException) new BizException(ResultCode.SERVICE_UNAVAILABLE,"订单业务页签事实暂不可用，请稍后重试")
-         .initCause(new IllegalStateException(reason));
- }
 }

firstleg/src/main/resources/db/phase3-ocean-booking-schema.sql

@@ -4,7 +4,7 @@ USE baiyue_firstleg;
 CREATE TABLE IF NOT EXISTS fl_ocean_booking (
   id BIGINT UNSIGNED NOT NULL COMMENT '海运订舱ID',
   booking_no VARCHAR(40) NOT NULL COMMENT '平台海运订舱编号',
-  status VARCHAR(24) NOT NULL DEFAULT 'DRAFT' COMMENT '订舱状态：DRAFT草稿、RELEASED已放舱，运输快照冻结且实货量受控补录',
+  status VARCHAR(24) NOT NULL DEFAULT 'DRAFT' COMMENT '订舱状态：DRAFT草稿、RELEASED已发布且永久只读',
   customer_id BIGINT UNSIGNED NULL COMMENT '可选客户ID快照',
   customer_name VARCHAR(128) NULL COMMENT '可选客户名称快照',
   channel_code VARCHAR(64) NULL COMMENT '订舱计划物流渠道组编码快照',
@@ -27,17 +27,6 @@ CREATE TABLE IF NOT EXISTS fl_ocean_booking (
   estimated_sailing_at DATETIME(3) NULL COMMENT '当前确认预计开船时间',
   estimated_arrival_at DATETIME(3) NULL COMMENT '当前确认预计到港时间',
   remark VARCHAR(1000) NULL COMMENT '平台内部备注',
-  freight_term VARCHAR(64) NULL COMMENT '运费条款',
-  service_term VARCHAR(64) NULL COMMENT '运输条款',
-  package_unit VARCHAR(16) NULL COMMENT '包装单位：CARTONS、PCS或PALLETS',
-  cargo_description VARCHAR(1000) NULL COMMENT '货物品名及托运要求',
-  marks_and_nos VARCHAR(1000) NULL COMMENT '唛头和号码',
-  declared_package_count INT UNSIGNED NULL COMMENT '订舱预报件数（委）',
-  declared_gross_weight_kg DECIMAL(15,3) NULL COMMENT '订舱预报毛重kg（委）',
-  declared_volume_cbm DECIMAL(15,3) NULL COMMENT '订舱预报体积cbm（委）',
-  actual_package_count INT UNSIGNED NULL COMMENT '客服手工实货件数',
-  actual_gross_weight_kg DECIMAL(15,3) NULL COMMENT '客服手工实货毛重kg',
-  actual_volume_cbm DECIMAL(15,3) NULL COMMENT '客服手工实货体积cbm',
   created_by BIGINT UNSIGNED NOT NULL COMMENT '创建操作人ID',
   created_by_name VARCHAR(64) NULL COMMENT '创建操作人姓名快照',
   created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '订舱记录创建时间',
@@ -55,14 +44,6 @@ CREATE TABLE IF NOT EXISTS fl_ocean_booking (
     ('DRAFT','RELEASED')),
   CONSTRAINT chk_ocean_booking_carrier_code CHECK
     (carrier_code IS NULL OR carrier_code IN ('MATSON','SML','ZIM','COSCO','EMC','HEDE','OTHER')),
-  CONSTRAINT chk_ocean_booking_cargo CHECK (
-    (package_unit IS NULL OR package_unit IN ('CARTONS','PCS','PALLETS'))
-    AND (declared_package_count IS NULL OR declared_package_count BETWEEN 1 AND 999999999)
-    AND (actual_package_count IS NULL OR actual_package_count BETWEEN 1 AND 999999999)
-    AND (declared_gross_weight_kg IS NULL OR declared_gross_weight_kg > 0)
-    AND (actual_gross_weight_kg IS NULL OR actual_gross_weight_kg > 0)
-    AND (declared_volume_cbm IS NULL OR declared_volume_cbm > 0)
-    AND (actual_volume_cbm IS NULL OR actual_volume_cbm > 0)),
   CONSTRAINT chk_ocean_booking_schedule CHECK
     (estimated_sailing_at IS NULL OR estimated_arrival_at IS NULL OR estimated_arrival_at >= estimated_sailing_at)
 ) ENGINE=InnoDB COMMENT='独立海运订舱聚合；柜次仍由fl_container_booking承载';
@@ -129,8 +110,6 @@ CREATE TABLE IF NOT EXISTS fl_ocean_booking_party (
   address VARCHAR(1000) NULL COMMENT '关系方地址快照',
   contact_name VARCHAR(128) NULL COMMENT '关系方联系人快照',
   contact_phone VARCHAR(64) NULL COMMENT '关系方联系电话快照',
-  contact_email VARCHAR(255) NULL COMMENT '关系方联系邮箱',
-  tax_no VARCHAR(128) NULL COMMENT '关系方税号',
   PRIMARY KEY (id),
   UNIQUE KEY uk_ocean_booking_party (ocean_booking_id,party_type),
   CONSTRAINT fk_ocean_booking_party FOREIGN KEY (ocean_booking_id) REFERENCES fl_ocean_booking(id) ON DELETE CASCADE,
@@ -232,46 +211,8 @@ DROP TRIGGER IF EXISTS trg_ocean_booking_before_update;
 DELIMITER $$
 CREATE TRIGGER trg_ocean_booking_before_update BEFORE UPDATE ON fl_ocean_booking FOR EACH ROW
 BEGIN
-  -- 已放舱只允许预计到港、实货量及审计元数据变化，其余运输和预报快照保持冻结。
+  IF OLD.status = 'RELEASED' THEN
-  IF OLD.status = 'RELEASED' AND NOT (
+    SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='已放舱订舱不可修改';
-    (NEW.id <=> OLD.id)
-    AND (NEW.booking_no <=> OLD.booking_no)
-    AND (NEW.status <=> OLD.status)
-    AND (NEW.customer_id <=> OLD.customer_id)
-    AND (NEW.customer_name <=> OLD.customer_name)
-    AND (NEW.channel_code <=> OLD.channel_code)
-    AND (NEW.channel_name <=> OLD.channel_name)
-    AND (NEW.warehouse_id <=> OLD.warehouse_id)
-    AND (NEW.warehouse_name <=> OLD.warehouse_name)
-    AND (NEW.bill_of_lading_no <=> OLD.bill_of_lading_no)
-    AND (NEW.shipping_company_id <=> OLD.shipping_company_id)
-    AND (NEW.shipping_company_name <=> OLD.shipping_company_name)
-    AND (NEW.carrier_code <=> OLD.carrier_code)
-    AND (NEW.booking_agent_id <=> OLD.booking_agent_id)
-    AND (NEW.booking_agent_name <=> OLD.booking_agent_name)
-    AND (NEW.vessel_name <=> OLD.vessel_name)
-    AND (NEW.voyage_no <=> OLD.voyage_no)
-    AND (NEW.departure_port_code <=> OLD.departure_port_code)
-    AND (NEW.departure_port_name <=> OLD.departure_port_name)
-    AND (NEW.destination_port_code <=> OLD.destination_port_code)
-    AND (NEW.destination_port_name <=> OLD.destination_port_name)
-    AND (NEW.place_of_delivery <=> OLD.place_of_delivery)
-    AND (NEW.estimated_sailing_at <=> OLD.estimated_sailing_at)
-    AND (NEW.remark <=> OLD.remark)
-    AND (NEW.freight_term <=> OLD.freight_term)
-    AND (NEW.service_term <=> OLD.service_term)
-    AND (NEW.package_unit <=> OLD.package_unit)
-    AND (NEW.cargo_description <=> OLD.cargo_description)
-    AND (NEW.marks_and_nos <=> OLD.marks_and_nos)
-    AND (NEW.declared_package_count <=> OLD.declared_package_count)
-    AND (NEW.declared_gross_weight_kg <=> OLD.declared_gross_weight_kg)
-    AND (NEW.declared_volume_cbm <=> OLD.declared_volume_cbm)
-    AND (NEW.created_by <=> OLD.created_by)
-    AND (NEW.created_by_name <=> OLD.created_by_name)
-    AND (NEW.created_at <=> OLD.created_at)
-    AND NEW.version = OLD.version + 1
-  ) THEN
-    SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='已放舱仅允许维护预计到港及补录实货量';
   END IF;
   IF OLD.status <> NEW.status AND NOT (
        (OLD.status='DRAFT' AND NEW.status='RELEASED')) THEN

firstleg/src/main/resources/db/phase3-smart-loading-schema.sql

@@ -35,7 +35,7 @@ CREATE TABLE IF NOT EXISTS fl_document_sequence (
 
 CREATE TABLE IF NOT EXISTS fl_container_booking (
   id BIGINT UNSIGNED NOT NULL COMMENT '货柜预订ID（雪花ID）',
-  container_no VARCHAR(64) NULL COMMENT '国内柜次真实集装箱号权威快照；订舱关联不限制ISO格式；同一订舱内唯一，不同提单允许复用；订舱关联可选写入、提柜后可原子补录、预装纠错命令可修改',
+  container_no VARCHAR(64) NULL COMMENT '国内柜次真实集装箱号权威快照；ISO 6346标准格式；同一订舱内唯一，不同提单允许复用；订舱关联可选写入、提柜后可原子补录、预装纠错命令可修改',
   cabinet_no VARCHAR(64) NOT NULL COMMENT '平台唯一内部柜号',
   source_type VARCHAR(24) NOT NULL DEFAULT 'SIMULATION' COMMENT '记录来源：SIMULATION内部模拟柜、OCEAN_BOOKING订舱真实柜',
   record_status VARCHAR(16) NOT NULL DEFAULT 'ACTIVE' COMMENT '记录状态：ACTIVE可操作、MERGED已合并历史',
@@ -100,7 +100,9 @@ CREATE TABLE IF NOT EXISTS fl_container_booking (
   CONSTRAINT chk_container_booking_record_status CHECK (record_status IN ('ACTIVE','MERGED')),
   CONSTRAINT chk_container_booking_capacity CHECK (capacity_cbm IS NULL OR capacity_cbm > 0),
   CONSTRAINT chk_container_booking_weight CHECK (max_weight_kg IS NULL OR max_weight_kg > 0),
-  CONSTRAINT chk_container_booking_pickup_code CHECK (pickup_code IS NULL OR pickup_code REGEXP '^[0-9]{1,64}$')
+  CONSTRAINT chk_container_booking_pickup_code CHECK (pickup_code IS NULL OR pickup_code REGEXP '^[0-9]{1,64}$'),
+  CONSTRAINT chk_container_booking_iso6346 CHECK
+    (container_no IS NULL OR container_no REGEXP '^[A-Z]{3}[UJZ][0-9]{7}$')
 ) ENGINE=InnoDB COMMENT='平台货柜预订资料；预装状态唯一来源为装柜计划';
 
 CREATE TABLE IF NOT EXISTS fl_container_event_inbox (
@@ -226,6 +228,11 @@ BEGIN
     ALTER TABLE fl_container_booking ADD CONSTRAINT chk_container_booking_record_status
       CHECK (record_status IN ('ACTIVE','MERGED'));
   END IF;
+  IF NOT EXISTS (SELECT 1 FROM information_schema.table_constraints WHERE constraint_schema=DATABASE()
+      AND table_name='fl_container_booking' AND constraint_name='chk_container_booking_iso6346') THEN
+    ALTER TABLE fl_container_booking ADD CONSTRAINT chk_container_booking_iso6346
+      CHECK (container_no IS NULL OR container_no REGEXP '^[A-Z]{3}[UJZ][0-9]{7}$');
+  END IF;
   IF NOT EXISTS (SELECT 1 FROM information_schema.table_constraints WHERE constraint_schema=DATABASE()
       AND table_name='fl_container_booking' AND constraint_name='chk_container_booking_pickup_code') THEN
     ALTER TABLE fl_container_booking ADD CONSTRAINT chk_container_booking_pickup_code

firstleg/src/main/resources/openapi/appointment-calendar-sources-v1.yaml

@@ -40,7 +40,7 @@ paths:
                             containerNo: {type: string, nullable: true}
                             vesselName: {type: string, nullable: true}
                             voyageNo: {type: string, nullable: true}
-                            destinationPortName: {type: string, nullable: true, description: 目的港展示值，优先名称，名称为空时使用已保存的港口代码，两者均为空时返回null}
+                            destinationPortName: {type: string, nullable: true}
                             destinationWarehouseCode: {type: string, nullable: true}
                             arrivalAt: {type: string, format: date-time, nullable: true}
                             arrivalType: {type: string, enum: [ACTUAL, ESTIMATED]}

firstleg/src/main/resources/openapi/appointment-forecasts-internal-v1.yaml

@@ -34,7 +34,6 @@ paths:
                       properties:
                         containerBookingId: {type: string}
                         timeBasis: {type: string, enum: [SOURCE_LOCAL_UNSPECIFIED]}
-                        portArrivalAt: {type: string, format: date-time, nullable: true, description: 与预约日历相同的权威到港当地时间，最新有效实际到港优先，其次柜资料实际到港及预计到港；未知保持空}
                         latest: {$ref: '#/components/schemas/Fact'}
                         previous: {$ref: '#/components/schemas/Fact'}
         '401': {description: 内部身份缺失、错误或服务端未配置}