feat(numbering): unify daily business document numbers (backend)

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();

deploy/sql/README.md

@@ -1,7 +1,5 @@
 # 单测试环境数据库空库初始化
 
-仓储转运到仓取货、本土卡车接入现有排车的**可重复执行汇总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 数据不倒推历史归属，匹配版本按新原生样本验收。

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/头程数据库统一增量-MySQL8.sql

@@ -4437,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;
@@ -8399,4 +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, 229 AS initialized_tables;
+SELECT 'PASS' AS initialization_status, 'CN' AS region, 230 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

@@ -416,7 +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 '任务类型：仓库派送、到仓取货、本土卡车',
   trip_id BIGINT NOT NULL COMMENT '本趟唯一车辆资源记录ID',
   overseas_warehouse_id VARCHAR(128) NOT NULL COMMENT '真实起运海外仓ID',
   overseas_warehouse_code VARCHAR(128) NULL COMMENT '起运海外仓编码快照',
@@ -1657,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 '尾程单号',
@@ -3211,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 '客户送仓或人工安排提货回仓',
@@ -3226,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),
@@ -4873,7 +4876,6 @@ 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 (
   dispatch_id BIGINT NOT NULL COMMENT '原排车内部主键',
   resource_mode VARCHAR(16) NOT NULL COMMENT '原排车资源模式MASTER或EXTERNAL',
@@ -4953,30 +4955,6 @@ CREATE TABLE IF NOT EXISTS 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 '业务前缀与北京时间日期组成的全局序列键',
@@ -4985,4 +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, 234 AS initialized_tables;
+SELECT 'PASS' AS initialization_status, 'OVERSEAS' AS region, 232 AS initialized_tables;

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/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/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/FinancePhase1OperationService.java

@@ -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;
@@ -438,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 {
-            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 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 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/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[] 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 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 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,
-                                    com.baiyue.finance.repository.FinanceSettlementDetailRepository details) {
+                                    FinanceDocumentNumberGenerator documentNumbers) {
         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);
-        if (records.isEmpty()) throw error("FIN_404", "结算单不存在");
-        SettlementSummary summary = summary(records.get(0));
-        List<SettlementLine> lines = details.lines(summary.customerId(), settlementId)
+        Map<String, Object> row = one(
+            SETTLEMENT_SUMMARY_SELECT + "WHERE s.id=?",
+            "结算单不存在", 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)
-            .stream().map(this::transaction).toList());
+        List<SettlementTransaction> transactions = new ArrayList<>(jdbc.queryForList(
+            "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())
-                .stream().map(this::transaction).toList());
+            transactions.addAll(jdbc.queryForList(
+                "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 {
-            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_001", "幂等请求哈希失败"); }
+        try { return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(json(value).getBytes(StandardCharsets.UTF_8))); }
+        catch (Exception exception) { throw error("FIN_001", "幂等请求哈希失败"); }
     }
 
     private static LocalDateTime localTime(Object value) {

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(
-            Map.entry("id", 501L), Map.entry("transaction_no", "PAY202610210001"), Map.entry("transaction_type", "PAYMENT"),
+        when(jdbc.queryForList(startsWith("SELECT id,transaction_type"), eq(10L), eq(88L))).thenReturn(List.of(Map.ofEntries(
+            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);
-    }
-}

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/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
-                 WHERE d.container_booking_id=owned.container_booking_id
-                   AND d.document_type='DESTINATION_CLEARANCE' AND d.file_id IS NOT NULL) THEN 3
+               WHEN EXISTS (SELECT 1 FROM fl_carrier_schedule_node_fact n
+                 WHERE n.container_booking_id=owned.container_booking_id
+                   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/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/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 EXISTS(SELECT 1 FROM fl_customs_container c WHERE c.loading_plan_id=p.id AND c.status='COMPLETED')) customs_completed "
+ +"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 "
  +"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,32 +24,27 @@ 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(f->f.departed() || f.clearanceUploaded()).map(f->new WorkflowFacts.Source(f.tenantId(),f.inboundId())).distinct().toList();
+ var sources=facts.stream().filter(WorkflowFacts.Fact::departed).map(f->new WorkflowFacts.Source(f.tenantId(),f.inboundId())).distinct().toList();
  Map<String,WorkflowFacts.Overseas> overseas=new HashMap<>();
  if(!sources.isEmpty()) {
  try {
  var response=lastleg.read(token,new WorkflowFacts.Request(sources));
- 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()));
+ if(response==null || !response.successful() || response.data()==null) throw unavailable();
  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()
-     +" missing="+sources.stream().filter(s->!overseas.containsKey(s.tenantId()+":"+s.inboundId())).limit(20).toList());
- } catch(BizException e) { throw e; } catch(Exception e) {
-     throw (BizException) new BizException(ResultCode.SERVICE_UNAVAILABLE,"订单业务页签事实暂不可用，请稍后重试").initCause(e);
- }
+ if(overseas.size()!=sources.size()) throw unavailable();
+ } catch(BizException e) { throw e; } catch(Exception e) { throw unavailable(); }
  }
  // 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.customsCompleted() || f.departed() || f.clearanceUploaded();
- if(!clearanceStage && !signed) {
+ // 报关页签按资料与实装事实汇总，不依赖点击开始报关；实际开船后转入清关链路。
+ if(!f.departed() && !signed) {
  if(f.missingCustoms()) keys.add("WAIT_CUSTOMS_DOCS");
  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(f.clearanceUploaded() && o!=null) {
- if(!o.outboundExists() && !o.unloaded()) keys.add("WAIT_UNLOAD");
+ if(o!=null) {
+ if(f.clearanceUploaded() && !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) {
-     // 诊断信息只进入服务日志，公开响应保持稳定，不暴露内部来源标识。
-     return (BizException) new BizException(ResultCode.SERVICE_UNAVAILABLE,"订单业务页签事实暂不可用，请稍后重试")
-         .initCause(new IllegalStateException(reason));
- }
+ private static BizException unavailable() { return new BizException(ResultCode.SERVICE_UNAVAILABLE,"订单业务页签事实暂不可用，请稍后重试"); }
 }

firstleg/src/main/resources/openapi/coload-groups-v1.yaml

@@ -45,8 +45,8 @@ paths:
       summary: 按入仓码查询同柜组业务摘要
       description: >-
         需要 platform:firstleg:smart-loading:list。使用任一有效成员的全局唯一 inboundCode 查询；
-        返回真实业务组号 groupNo、组业务状态、有效成员数和全部唯一成员入仓码。任一冻结成员缺少有效 inboundCode 时失败关闭；
-        页面不持有或展示 groupId、orderId，也不得从技术ID或订单号推导入仓码。
+        仅返回组业务状态、有效成员数和全部唯一成员入仓码。任一冻结成员缺少有效 inboundCode 时失败关闭；
+        页面不持有或展示 groupId、groupNo、orderId，也不得从技术ID或订单号推导入仓码。
       parameters:
         - name: inboundCode
           in: path
@@ -147,9 +147,8 @@ components:
     ColoadGroupBusinessSummary:
       type: object
       additionalProperties: false
-      required: [groupNo, status, memberCount, members]
+      required: [status, memberCount, members]
       properties:
-        groupNo: {type: string, pattern: "^CLG[0-9]{12}$", description: 真实同柜业务组号；与创建及重放结果一致}
         status: {type: string, enum: [ACTIVE, LOCKED, CONSUMED]}
         memberCount: {type: integer, minimum: 1}
         members:

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

@@ -392,7 +392,7 @@ paths:
                       customsOrderIds: {type: array, items: {type: integer, format: int64}}
                       progress:
                         type: array
-                        description: 实际装载片段投影；报关要求COMPLETED，目的港清关以本柜DESTINATION_CLEARANCE资料成功绑定file_id为准，不等待PICKUP_READY船节点。
+                        description: 实际装载片段投影；报关要求COMPLETED，目的港清关要求PICKUP_READY实际时间，缺失节点不推测。
                         items:
                           type: object
                           required: [orderId, stage, partial]
@@ -1679,7 +1679,7 @@ components:
           type: string
           enum: [PENDING_REVIEW, WAIT_MEASURE, WAIT_PALLETIZE, WAIT_SPLIT, LOADING, LOADED, DELIVERED, WAIT_WEIGHT_CONFIRM, WEIGHT_CONFIRMED, WAIT_CUSTOMS_DOCS, EXPORT_CUSTOMS, SAILING_CLEARANCE, WAIT_UNLOAD, WAIT_DISPATCH, OUTBOUND_DOCUMENT, DELIVERING, SIGNED, MEASUREMENT_REVIEW]
           nullable: true
-          description: WAIT_SPLIT 为唯一待分柜筛选值；WAIT_CUSTOMS_DOCS 为实际装柜后缺少本票客户报关资料；EXPORT_CUSTOMS 按本票资料已上传且实际装柜完成汇总，买单无需客户退税资料，不依赖点击开始报关，报关完成或实际开船后移出；SAILING_CLEARANCE 在整柜报关完成后进入，也接受实际离港事实；清关资料保存成功后才进入 WAIT_UNLOAD/WAIT_DISPATCH。WAIT_UNLOAD 持续到实际卸柜或生成有效出库单；生成出库单后进入 OUTBOUND_DOCUMENT，实际出库后进入 DELIVERING，派送完成进入 SIGNED。
+          description: WAIT_SPLIT 为唯一待分柜筛选值；WAIT_CUSTOMS_DOCS 为实际装柜后缺少本票客户报关资料；EXPORT_CUSTOMS 按本票资料已上传且实际装柜完成汇总，买单无需客户退税资料，不依赖点击开始报关，实际开船后移出；SAILING_CLEARANCE 按手动或拉取的实际离港节点进入，清关资料上传后进入 WAIT_UNLOAD，实际卸柜完成后移出。
         customerId: {type: integer, format: int64, nullable: true}
         receivingWarehouseId: {type: integer, format: int64, nullable: true}
         destinationWarehouseId: {type: integer, format: int64, nullable: true}

firstleg/src/test/java/com/baiyue/firstleg/loading/coload/ColoadGroupOpenApiContractTest.java

@@ -55,7 +55,7 @@ class ColoadGroupOpenApiContractTest {
             .doesNotContain("destinationCode")
             .doesNotContain("expectedVersion")
             .doesNotContain("platform:firstleg:coload");
-        assertThat(summaryProperties).containsOnlyKeys("groupNo", "status", "memberCount", "members");
+        assertThat(summaryProperties).containsOnlyKeys("status", "memberCount", "members");
         assertThat(memberProperties).containsOnlyKeys("inboundCode");
     }
 }

firstleg/src/test/java/com/baiyue/firstleg/loading/coload/ColoadGroupServiceTest.java

@@ -37,7 +37,7 @@ import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-@SpringJUnitConfig({ColoadGroupService.class, ColoadGroupServiceTest.Numbers.class, com.baiyue.firstleg.loading.coload.persistence.ColoadGroupQueryRepository.class})
+@SpringJUnitConfig({ColoadGroupService.class, ColoadGroupServiceTest.Numbers.class})
 class ColoadGroupServiceTest {
     @org.springframework.context.annotation.Configuration
     static class Numbers {
@@ -71,7 +71,6 @@ class ColoadGroupServiceTest {
 
         var result = service.queryByInboundCode(" IN-A ");
 
-        assertThat(result.groupNo()).isEqualTo("CLG202610210001");
         assertThat(result.status()).isEqualTo("ACTIVE");
         assertThat(result.memberCount()).isEqualTo(2);
         assertThat(result.members()).extracting("inboundCode").containsExactly("IN-A", "IN-B");
@@ -575,7 +574,6 @@ class ColoadGroupServiceTest {
     private static InboundGroupLookupRow lookup(long groupId, String status) {
         InboundGroupLookupRow value = new InboundGroupLookupRow();
         value.setGroupId(groupId);
-        value.setGroupNo("CLG202610210001");
         value.setGroupStatus(status);
         return value;
     }

firstleg/src/test/java/com/baiyue/firstleg/loading/coload/ColoadGroupSqlContractTest.java

@@ -86,8 +86,7 @@ class ColoadGroupSqlContractTest {
             .contains("requested.inbound_code=#{inboundCode}")
             .contains("requested.deleted=0")
             .contains("'ACTIVE','LOCKED','CONSUMED'")
-            .contains("group_row.group_no groupNo")
-            .doesNotContain("order_id=#{");
+            .doesNotContain("group_no", "order_id=#{");
         assertThat(memberSql)
             .contains("member.id memberId", "member.inbound_id inboundId", "inbound.inbound_code inboundCode")
             .contains("LEFT JOIN fl_inbound_order inbound")

firstleg/src/test/java/com/baiyue/firstleg/portschedule/repository/CarrierScheduleQuerySqlContractTest.java

@@ -44,9 +44,8 @@ class CarrierScheduleQuerySqlContractTest {
         }
     }
 
-    /** 保留批量读取，实际到港与日历采用相同的最新观测顺序。 */
     @Test
-    void batchesActualContainerFactsWithLatestObservedArrivalAndWithoutEstimatedTimes() throws Exception {
+    void batchesActualContainerFactsWithoutEstimatedOrPerNodeQueries() throws Exception {
         String sql = String.join("\n", CarrierScheduleQueryMapper.class
             .getMethod("selectContainerActualFacts", List.class)
             .getAnnotation(Select.class).value());
@@ -56,16 +55,13 @@ class CarrierScheduleQuerySqlContractTest {
             .contains("f.actual_at IS NOT NULL")
             .contains("MAX(CASE WHEN f.standard_node='DEPARTED_WAREHOUSE'")
             .contains("MAX(CASE WHEN f.standard_node='DEPARTED_ORIGIN_PORT'")
-            .contains("MAX(arrival.actual_at) AS arrivedDestinationPortAt")
-            .contains("a.standard_node='ARRIVED_DESTINATION_PORT' AND a.actual_at IS NOT NULL")
-            .contains("ORDER BY a.observed_at DESC,a.id DESC LIMIT 1")
-            .doesNotContain("MAX(CASE WHEN f.standard_node='ARRIVED_DESTINATION_PORT'")
+            .contains("MAX(CASE WHEN f.standard_node='ARRIVED_DESTINATION_PORT'")
             .contains("MAX(CASE WHEN f.standard_node='PICKUP_READY'")
             .contains("MAX(CASE WHEN f.standard_node='PICKED_UP'")
             .contains("MAX(CASE WHEN f.standard_node='EMPTY_RETURNED'")
             .contains("ORDER BY b.id")
             .doesNotContain("estimated_at");
-        assertThat(count(sql, "fl_carrier_schedule_node_fact")).isEqualTo(5);
+        assertThat(count(sql, "fl_carrier_schedule_node_fact")).isEqualTo(3);
         assertThat(count(sql, "SELECT f2.id FROM fl_carrier_schedule_node_fact f2")).isEqualTo(1);
     }
 

firstleg/src/test/java/com/baiyue/firstleg/repository/MerchantWorkbenchFilterMapperTest.java

@@ -30,7 +30,6 @@ class MerchantWorkbenchFilterMapperTest {
         jdbc.execute("ALTER TABLE fl_loading_plan_item ADD id BIGINT GENERATED BY DEFAULT AS IDENTITY");
         jdbc.execute("CREATE TABLE fl_loading_pick_task(id BIGINT,loading_plan_id BIGINT,task_status VARCHAR(32))");
         jdbc.execute("CREATE TABLE fl_loading_pick_item(pick_task_id BIGINT,loading_plan_item_id BIGINT,item_status VARCHAR(32),picked_package_count INT)");
-        jdbc.execute("CREATE TABLE fl_container_document(container_booking_id BIGINT,document_type VARCHAR(40),file_id BIGINT)");
         jdbc.execute("CREATE TABLE fl_carrier_schedule_node_fact(container_booking_id BIGINT,standard_node VARCHAR(64),actual_at TIMESTAMP)");
         var config=new MybatisConfiguration();config.setMapUnderscoreToCamelCase(true);config.addMapper(MerchantWorkbenchFilterMapper.class);
         var factory=new MybatisSqlSessionFactoryBean();factory.setDataSource(ds);factory.setConfiguration(config);
@@ -96,12 +95,6 @@ class MerchantWorkbenchFilterMapperTest {
         jdbc.update("INSERT INTO fl_carrier_schedule_node_fact VALUES(100,'PICKUP_READY',NULL)");
         assertThat(mapper.progressFragments(11, null)).allMatch(f->f.stage()==2);
         jdbc.update("UPDATE fl_carrier_schedule_node_fact SET actual_at=CURRENT_TIMESTAMP");
-        assertThat(mapper.progressFragments(11, null)).allMatch(f->f.stage()==2);
-        // 其他柜、其他资料类型或未绑定文件不能视为清关资料提交成功。
-        jdbc.update("INSERT INTO fl_container_document VALUES(999,'DESTINATION_CLEARANCE',1),(100,'DELIVERY_ORDER',2),(100,'DESTINATION_CLEARANCE',NULL)");
-        assertThat(mapper.progressFragments(11, null)).allMatch(f->f.stage()==2);
-        jdbc.update("UPDATE fl_carrier_schedule_node_fact SET actual_at=NULL");
-        jdbc.update("UPDATE fl_container_document SET file_id=3 WHERE document_type='DESTINATION_CLEARANCE' AND container_booking_id=100");
         assertThat(mapper.progressFragments(11, null)).allMatch(f->f.stage()==3);
         assertThat(mapper.progressFragments(11,List.of(101L))).singleElement().satisfies(f->{assertThat(f.orderId()).isEqualTo(101);assertThat(f.stage()).isEqualTo(3);});
         jdbc.update("UPDATE fl_container_booking SET record_status='CANCELLED'");

firstleg/src/test/java/com/baiyue/firstleg/repository/Phase3FinalUnifiedSqlContractTest.java

@@ -80,7 +80,7 @@ class Phase3FinalUnifiedSqlContractTest {
     @Test
     void initializationPassIsUniqueAndFinal() throws Exception {
         String sql = sql();
-        int expectedTables = 229;
+        int expectedTables = 230;
         long actualTables = java.util.regex.Pattern.compile("(?m)^CREATE TABLE\\s+")
             .matcher(sql).results().count();
         assertThat(actualTables).isEqualTo(expectedTables);

firstleg/src/test/java/com/baiyue/firstleg/terminaldrayage/mapper/ContainerCalendarSourceMapperTest.java

@@ -2,7 +2,6 @@ package com.baiyue.firstleg.terminaldrayage.mapper;
 
 import com.baomidou.mybatisplus.core.MybatisConfiguration;
 import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
-import com.baiyue.firstleg.portschedule.mapper.CarrierScheduleQueryMapper;
 import org.apache.ibatis.mapping.Environment;
 import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
 import org.h2.jdbcx.JdbcDataSource;
@@ -11,51 +10,6 @@ import java.time.LocalDateTime;
 import static org.junit.jupiter.api.Assertions.*;
 
 class ContainerCalendarSourceMapperTest {
-    /** 后续观测可将实际到港修正为更早日期，两入口须取同一条最新实际记录。 */
-    @Test
-    void usesLatestObservedArrivalIncludingSameObservationIdTieBreakAcrossBothEntrypoints() throws Exception {
-        var ds = new JdbcDataSource();
-        ds.setURL("jdbc:h2:mem:arrival-source-correction;MODE=MySQL;DB_CLOSE_DELAY=-1");
-        try (var connection = ds.getConnection(); var sql = connection.createStatement()) {
-            sql.execute("CREATE TABLE fl_container_booking(id BIGINT PRIMARY KEY,cabinet_no VARCHAR,container_no VARCHAR," +
-                "vessel_name VARCHAR,voyage_no VARCHAR,destination_port_name VARCHAR,destination_warehouse_code VARCHAR," +
-                "actual_port_arrival_at TIMESTAMP,estimated_port_arrival_at TIMESTAMP,unloading_completed_at TIMESTAMP,record_status VARCHAR)");
-            sql.execute("CREATE TABLE fl_terminal_drayage(container_booking_id BIGINT,actual_empty_return_at TIMESTAMP)");
-            sql.execute("CREATE TABLE fl_carrier_schedule_query(id BIGINT,version INT,status VARCHAR)");
-            sql.execute("CREATE TABLE fl_carrier_schedule_node_fact(id BIGINT,query_id BIGINT,container_booking_id BIGINT," +
-                "standard_node VARCHAR,actual_at TIMESTAMP,observed_at TIMESTAMP)");
-            sql.execute("CREATE TABLE fl_direct_delivery_unloading(container_booking_id BIGINT,actual_at TIMESTAMP)");
-            sql.execute("CREATE TABLE fl_outbound_dispatch(container_booking_id BIGINT,confirmed_at TIMESTAMP,reversed_at TIMESTAMP,status VARCHAR)");
-            sql.execute("INSERT INTO fl_container_booking(id,cabinet_no,estimated_port_arrival_at,record_status) VALUES " +
-                "(1,'D1','2026-10-29 08:00:00','ACTIVE'),(2,'D2','2026-10-29 08:00:00','ACTIVE')");
-            sql.execute("INSERT INTO fl_carrier_schedule_query VALUES(1,0,'READY'),(2,0,'READY')");
-            sql.execute("INSERT INTO fl_outbound_dispatch SELECT id,'2026-10-01 00:00:00',NULL,'WAITING_FOR_LOADING' FROM fl_container_booking");
-            sql.execute("INSERT INTO fl_carrier_schedule_node_fact VALUES " +
-                "(1,1,1,'ARRIVED_DESTINATION_PORT','2026-10-23 14:00:00','2026-10-24 14:00:00')," +
-                "(2,1,1,'ARRIVED_DESTINATION_PORT','2026-10-21 14:00:00','2026-10-25 14:00:00')," +
-                "(3,1,1,'ARRIVED_DESTINATION_PORT',NULL,'2026-10-26 14:00:00')," +
-                "(4,2,2,'ARRIVED_DESTINATION_PORT','2026-10-24 14:00:00','2026-10-25 14:00:00')," +
-                "(5,2,2,'ARRIVED_DESTINATION_PORT','2026-10-22 14:00:00','2026-10-25 14:00:00')");
-        }
-        var config = new MybatisConfiguration();
-        config.setEnvironment(new Environment("test", new JdbcTransactionFactory(), ds));
-        config.addMapper(ContainerCalendarSourceMapper.class);
-        config.addMapper(CarrierScheduleQueryMapper.class);
-        try (var session = new MybatisSqlSessionFactoryBuilder().build(config).openSession()) {
-            var from = LocalDateTime.parse("2026-10-01T00:00:00");
-            var calendar = session.getMapper(ContainerCalendarSourceMapper.class).sources(from, from.minusDays(2), from.minusDays(4), from.plusMonths(1));
-            var workbench = session.getMapper(CarrierScheduleQueryMapper.class).selectContainerActualFacts(java.util.List.of(1L, 2L));
-            assertEquals(2, calendar.size());
-            assertEquals(2, workbench.size());
-            for (int index = 0; index < calendar.size(); index++) {
-                var expected = LocalDateTime.parse(index == 0 ? "2026-10-21T14:00:00" : "2026-10-22T14:00:00");
-                assertEquals(expected, calendar.get(index).arrivalAt());
-                assertEquals("ACTUAL", calendar.get(index).arrivalType());
-                assertEquals(expected, workbench.get(index).arrivedDestinationPortAt());
-                assertEquals(calendar.get(index).arrivalAt().plusDays(2).toLocalDate(), workbench.get(index).arrivedDestinationPortAt().plusDays(2).toLocalDate());
-            }
-        }
-    }
     /** 使用实际 Mapper 核对跨月默认日期候选、缺日期与真实出仓边界。 */
     @Test
     void selectsShiftedArrivalUndatedAndOlderReturnCandidatesWithoutInactiveOrUndepartedContainers() throws Exception {

firstleg/src/test/java/com/baiyue/firstleg/workflow/WorkflowBoundaryTest.java

@@ -13,7 +13,7 @@ import static org.mockito.Mockito.*;
 class WorkflowBoundaryTest {
     /** 真实开船来源的测试事实。 */
     private WorkflowFacts.Fact fact() {
-        return new WorkflowFacts.Fact(11,1,101,"APPROVED",true,false,false,false,false);
+        return new WorkflowFacts.Fact(11,1,101,"APPROVED",true,false,false,false);
     }
 
     /** 下游漏来源或返回其他客户均整体失败。 */
@@ -25,34 +25,12 @@ class WorkflowBoundaryTest {
         inbound.setOrderId(101L);inbound.setProcessStatus("LOADED");
         when(repository.facts(List.of(1L))).thenReturn(List.of(fact()));
         when(downstream.read(any(),any())).thenReturn(ApiResponse.success(List.of()));
-        assertThatThrownBy(()->service.rows(List.of(inbound))).isInstanceOf(BizException.class)
-            .hasMessage("订单业务页签事实暂不可用，请稍后重试")
-            .hasRootCauseMessage("尾程事实缺少来源 expected=1 actual=0 missing=[Source[tenantId=11, inboundId=1]]");
+        assertThatThrownBy(()->service.rows(List.of(inbound))).isInstanceOf(BizException.class);
         when(downstream.read(any(),any())).thenReturn(ApiResponse.success(List.of(
             new WorkflowFacts.Overseas(22,1,true,true,false,true))));
         assertThatThrownBy(()->service.rows(List.of(inbound))).isInstanceOf(BizException.class);
-        var failure=new IllegalStateException("unavailable");
-        when(downstream.read(any(),any())).thenThrow(failure);
-        assertThatThrownBy(()->service.rows(List.of(inbound))).isInstanceOf(BizException.class).hasCause(failure);
-    }
-
-    /** 未记录离港时，报关完成即可待清关；上传清关资料后也必须查询精确海外来源。 */
-    @Test void completedCustomsAndClearanceUploadDoNotWaitForDeparture() {
-        var repository=mock(WorkflowFactRepository.class);
-        var downstream=mock(LastlegWorkflowClient.class);
-        var service=new WorkflowTabService(repository,downstream);
-        var inbound=new InboundOrderEntity();inbound.setId(1L);inbound.setTenantId(11L);
-        inbound.setOrderId(101L);inbound.setProcessStatus("LOADED");
-        when(repository.facts(List.of(1L))).thenReturn(List.of(
-            new WorkflowFacts.Fact(11,1,101,"APPROVED",false,false,false,true,true)));
-        assertThat(service.rows(List.of(inbound))).extracting(r->r.mainStatus()).containsExactly("SAILING_CLEARANCE");
-        verifyNoInteractions(downstream);
-        when(repository.facts(List.of(1L))).thenReturn(List.of(
-            new WorkflowFacts.Fact(11,1,101,"APPROVED",false,true,false,true,true)));
-        when(downstream.read(any(),any())).thenReturn(ApiResponse.success(List.of(
-            new WorkflowFacts.Overseas(11,1,false,false,false,false))));
-        assertThat(service.rows(List.of(inbound))).extracting(r->r.mainStatus()).containsExactly("WAIT_UNLOAD","WAIT_DISPATCH");
-        verify(downstream).read(any(),eq(new WorkflowFacts.Request(List.of(new WorkflowFacts.Source(11,1)))));
+        when(downstream.read(any(),any())).thenThrow(new IllegalStateException("unavailable"));
+        assertThatThrownBy(()->service.rows(List.of(inbound))).isInstanceOf(BizException.class);
     }
 
 }

firstleg/src/test/java/com/baiyue/firstleg/workflow/WorkflowBusinessTest.java

@@ -3,46 +3,33 @@ import org.junit.jupiter.api.Test;
 import static org.assertj.core.api.Assertions.*;
 /** 取消回显、分柜隔离和资料页签回归。 */
 class WorkflowBusinessTest {
-    /** 报关完成进入待清关，清关资料保存后才进入拆柜与排车待办。 */
+    /** 报关资料齐备进入汇总，实际开船及清关资料分别驱动后续页签。 */
     @Test void customsDocumentsDepartureAndClearanceDriveTabs() {
-        var missing=new WorkflowFacts.Fact(11,1,101,"APPROVED",false,false,true,false,false);
-        var uploaded=new WorkflowFacts.Fact(11,1,101,"APPROVED",false,false,false,true,false);
-        var departed=new WorkflowFacts.Fact(11,1,101,"APPROVED",true,false,false,true,false);
-        var cleared=new WorkflowFacts.Fact(11,1,101,"APPROVED",true,true,false,true,false);
-        var completed=new WorkflowFacts.Fact(11,1,101,"APPROVED",false,false,false,true,true);
-        var uploadedBeforeDeparture=new WorkflowFacts.Fact(11,1,101,"APPROVED",false,true,false,true,false);
+        var missing=new WorkflowFacts.Fact(11,1,101,"APPROVED",false,false,true,false);
+        var uploaded=new WorkflowFacts.Fact(11,1,101,"APPROVED",false,false,false,true);
+        var departed=new WorkflowFacts.Fact(11,1,101,"APPROVED",true,false,false,true);
+        var cleared=new WorkflowFacts.Fact(11,1,101,"APPROVED",true,true,false,true);
+        var uploadedBeforeDeparture=new WorkflowFacts.Fact(11,1,101,"APPROVED",false,true,false,true);
         var pendingUnload=new WorkflowFacts.Overseas(11,1,false,false,false,false);
         var unloaded=new WorkflowFacts.Overseas(11,1,false,false,false,true);
         assertThat(WorkflowTabService.classify(missing,"LOADED",null))
             .contains("WAIT_CUSTOMS_DOCS").doesNotContain("EXPORT_CUSTOMS","SAILING_CLEARANCE","WAIT_UNLOAD");
         assertThat(WorkflowTabService.classify(uploaded,"LOADED",null))
             .contains("EXPORT_CUSTOMS").doesNotContain("WAIT_CUSTOMS_DOCS","SAILING_CLEARANCE","WAIT_UNLOAD");
-        assertThat(WorkflowTabService.classify(completed,"LOADED",null))
-            .containsExactly("SAILING_CLEARANCE");
         assertThat(WorkflowTabService.classify(uploadedBeforeDeparture,"LOADED",pendingUnload))
-            .containsExactly("WAIT_UNLOAD","WAIT_DISPATCH");
+            .contains("EXPORT_CUSTOMS").doesNotContain("SAILING_CLEARANCE","WAIT_UNLOAD");
         assertThat(WorkflowTabService.classify(departed,"LOADED",pendingUnload))
-            .containsExactly("SAILING_CLEARANCE");
+            .contains("SAILING_CLEARANCE").doesNotContain("WAIT_CUSTOMS_DOCS","EXPORT_CUSTOMS","WAIT_UNLOAD");
         assertThat(WorkflowTabService.classify(cleared,"LOADED",pendingUnload))
-            .containsExactly("WAIT_UNLOAD","WAIT_DISPATCH");
+            .contains("WAIT_UNLOAD").doesNotContain("WAIT_CUSTOMS_DOCS","EXPORT_CUSTOMS","SAILING_CLEARANCE");
         assertThat(WorkflowTabService.classify(cleared,"LOADED",unloaded))
             .doesNotContain("WAIT_UNLOAD","SAILING_CLEARANCE","EXPORT_CUSTOMS");
         assertThat(WorkflowTabService.classify(uploaded,"DELIVERED",unloaded))
             .contains("SIGNED").doesNotContain("EXPORT_CUSTOMS","WAIT_CUSTOMS_DOCS");
     }
-    /** 清关前不能被海外建单事实提前推进，清关后出库与派送依次替换待办。 */
-    @Test void downstreamFactsCannotBypassClearanceAndOutboundReplacesQueues() {
-        var pending=new WorkflowFacts.Overseas(11,1,true,true,false,false);
-        var shipped=new WorkflowFacts.Overseas(11,1,true,false,true,false);
-        assertThat(WorkflowTabService.classify(fact(1,false),"LOADED",pending)).containsExactly("SAILING_CLEARANCE");
-        assertThat(WorkflowTabService.classify(fact(1,false),"LOADED",shipped)).containsExactly("SAILING_CLEARANCE");
-        assertThat(WorkflowTabService.classify(fact(1,true),"LOADED",pending)).containsExactly("OUTBOUND_DOCUMENT");
-        assertThat(WorkflowTabService.classify(fact(1,true),"LOADED",shipped)).containsExactly("DELIVERING");
-        assertThat(WorkflowTabService.classify(fact(1,true),"DELIVERED",shipped)).containsExactly("SIGNED");
-    }
     /** 构造独立分柜来源。 */
     private WorkflowFacts.Fact fact(long id,boolean uploaded) {
-        return new WorkflowFacts.Fact(11,id,100+id,"APPROVED",true,uploaded,false,false,false);
+        return new WorkflowFacts.Fact(11,id,100+id,"APPROVED",true,uploaded,false,false);
     }
     /** 有效建单移出待排车，取消后恢复；实际出库不计未出库单。 */
     @Test void cancellationRestoresDispatchQueue() {
@@ -58,9 +45,9 @@ class WorkflowBusinessTest {
     /** 一柜资料上传不覆盖另一柜；签收不再进入待排。 */
     @Test void independentSlicesAndUploadedClearance() {
         assertThat(WorkflowTabService.classify(fact(1,false),"LOADED",new WorkflowFacts.Overseas(11,1,false,false,false,false)))
-            .containsExactly("SAILING_CLEARANCE");
+            .contains("SAILING_CLEARANCE","WAIT_DISPATCH").doesNotContain("WAIT_UNLOAD");
         assertThat(WorkflowTabService.classify(fact(2,true),"LOADED",new WorkflowFacts.Overseas(11,2,true,true,false,false)))
-            .containsExactly("OUTBOUND_DOCUMENT");
+            .contains("WAIT_UNLOAD","OUTBOUND_DOCUMENT").doesNotContain("SAILING_CLEARANCE","WAIT_DISPATCH");
         assertThat(WorkflowTabService.classify(fact(1,false),"DELIVERED",null)).contains("SIGNED").doesNotContain("WAIT_DISPATCH");
     }
 }

firstleg/src/test/java/com/baiyue/firstleg/workflow/WorkflowFactPersistenceTest.java

@@ -60,11 +60,10 @@ class WorkflowFactPersistenceTest {
         db.update("INSERT INTO fl_customs_customer_document VALUES(10,11,'ACTIVE',8)");
         db.update("INSERT INTO fl_customs_customer_document_inbound VALUES(1,11,10)");
         assertThat(mapper.facts(List.of(1L))).singleElement().satisfies(f->{assertThat(f.missingCustoms()).isFalse();assertThat(f.exportCustomsReady()).isTrue();});
-        // 本票资料上传后进入出口报关汇总，报关完成事实独立驱动待清关。
+        // 本票上传后即可汇总，不必等同柜其他票或点击开始报关；完成报关后仍等待实际开船。
         for (String status : List.of("READY_TO_START", "DECLARING", "COMPLETED")) {
             db.update("UPDATE fl_customs_container SET status=? WHERE id=8", status);
             assertThat(mapper.facts(List.of(1L)).get(0).exportCustomsReady()).isTrue();
-            assertThat(mapper.facts(List.of(1L)).get(0).customsCompleted()).isEqualTo("COMPLETED".equals(status));
         }
         db.update("UPDATE fl_customs_customer_document SET status='DELETED' WHERE id=10");
         assertThat(mapper.facts(List.of(1L))).singleElement().satisfies(f->{

lastleg-service/AGENTS.md

@@ -17,8 +17,6 @@
 
 拼车余位发布查 `fleet/trip/FleetCapacityOfferService.java`；整车建单与准备查 `dispatch/controller/DispatchAggregateController.java` 和 `dispatch/service/DispatchAggregateService.java`，本土业务接线查 `fleet/business/`；既有外接登记衔接合同为 `fleet-preparation-v1.yaml`，排车流程按 `../../docs/海外仓业务/排车列表统一作业改造契约.md`。
 
-原排车装车后运营视图分别查 `fleet/ownedbusiness/`、`fleet/outsourcedbusiness/` 与各自 `fleet-*-business-v1.yaml`；自有/外配按同事务捕获的车辆归属，不按货源区分。两入口可信作用域及权限独立，外配仅整车承运金额、逐目的仓到达和五装车照片；复用四张附加表，不修改原履约/库存/财务状态。共同业务规则见 `../../docs/海外仓业务/自有业务首版开发契约.md`、`../../docs/海外仓业务/外配业务首版开发契约.md`，实际发布及HTTP只查部署主契约。
-
 事件重试：`controller/EventOperationsController.java`，内部 `/internal/lastleg/event-operations/{entryId}` 查询、`/retry` 写入；仅卸柜、派送、暂扣、资金及费用事件，以 `EVENT_OPERATIONS_TOKEN` 保护。原事件不可改，DEAD→PENDING 与 `event_delivery_retry_audit` 同事务；脚本 `scripts/event-outbox-operations.mjs`。
 
 沿代码追踪；状态、权限、资源或接口边界不明时，定向检索 `docs/business-index.md`；局部任务不扩读无关约束。

lastleg-service/docs/business-index.md

@@ -86,7 +86,6 @@
 - 车次成本：`fleet/trip/FleetTripCostService.java`、`fleet-trip-costs-v1.yaml`；按DEPART实测及外接实收分摊，不产生客户账单/付款。
 - 报价/统计：`fleet/quote/`、`fleet/reporting/`，合同`fleet-quotes-v1.yaml`、`fleet-operations-v1.yaml`；实测凭证按车次归属，仅当前/历史版本引用可下载。
 - 自有业务运营：`fleet/ownedbusiness/`、`fleet-owned-business-v1.yaml`，共同规则见`../../../docs/海外仓业务/自有业务首版开发契约.md`；原排车装车后三阶段按装车时自有车辆归属展示，仅补金额、逐目的地到达、里程、油耗与照片。原详情只经`dispatch.port.DispatchDetailReader`读取，原装车事务经`OwnedBusinessOwnershipCapture`捕获归属，不另建履约流程。
-- 外配业务运营：`fleet/outsourcedbusiness/`、`fleet-outsourced-business-v1.yaml`，共同规则见`../../../docs/海外仓业务/外配业务首版开发契约.md`；原排车装车后三阶段按冻结DISPATCHED归属展示，包括正式MASTER/EXTERNAL两种资源模式。只登记整车承运金额、逐目的仓到达和五装车照片，无里程/油耗或成本拆分。内部可信作用域复用四表，入口权限与自有严格分开，不引入第二履约模型。
 - 外接选价合同：`fleet-quote-candidates-v1.yaml`、`fleet-trips-v1.yaml`；来源快照与成交价分开，确认承运复验。
 - 在途交接：`fleet/exception/`、`fleet-handovers-v1.yaml`；后台确认交接，旧资源分别结束任务，DEPART不重写。
 

lastleg-service/scripts/analyze-lastleg-dependencies.test.mjs

@@ -50,10 +50,7 @@ test('fleet stays a business slice and its policies have no infrastructure depen
   const policyClasses = classes.filter(entry => entry.packageName === 'com.baiyue.lastleg.fleet.domain');
   assert.equal(policyClasses.length, 3);
   for (const entry of policyClasses) assert.ok(entry.imports.every(imported => imported.startsWith('java.')));
-  const reviewed = JSON.parse(readFileSync(contract, 'utf8')).reviewedClassDependencies;
-  const commercialEdges = report.classDependencies.filter(edge => edge.source.startsWith('com.baiyue.lastleg.fleet.') && /com\.baiyue\.lastleg\.(trucking|looseboard|procurement)\./.test(edge.target));
-  assert.ok(commercialEdges.every(edge => reviewed.some(allowed => allowed.source === edge.source && allowed.target === edge.target)), 'commercial integration only uses individually reviewed class references');
-  assert.deepEqual(report.sliceEdges.filter(edge => edge.source === 'fleet').map(edge => edge.target).sort(), ['dispatch-delivery', 'overseas-master-data', ...(commercialEdges.length ? ['procurement-trucking-looseboard'] : []), 'shared-technical']);
+  assert.deepEqual(report.sliceEdges.filter(edge => edge.source === 'fleet').map(edge => edge.target).sort(), ['dispatch-delivery', 'overseas-master-data', 'shared-technical']);
   for (const edge of report.classDependencies.filter(edge => edge.source.startsWith('com.baiyue.lastleg.fleet.') && edge.target.startsWith(vehiclePrefix))) {
     assert.ok(edge.target.startsWith(vehiclePrefix + '.application.'), 'fleet must use vehicle application ports, not persistence adapters');
   }
@@ -71,13 +68,7 @@ test('fleet stays a business slice and its policies have no infrastructure depen
     || edge.source === 'com.baiyue.lastleg.dispatch.fleet.PdaFleetHandoverController'
       && edge.target === 'com.baiyue.lastleg.fleet.exception.FleetHandoverPdaQuery'
     || edge.source === 'com.baiyue.lastleg.dispatch.service.DispatchAggregateService'
-      && edge.target === 'com.baiyue.lastleg.fleet.ownedbusiness.port.OwnedBusinessOwnershipCapture'
-    || [
-      'TransportTaskModels->pickup.FleetPickupModels', 'TransportTaskModels->trip.FleetTripModels',
-      'TransportTaskProjection->trip.FleetTripEntity', 'TransportTaskProjection->trip.TransportTripChanged',
-      'TransportTaskService->business.FleetPoolOrderQueries', 'TransportTaskService->driver.DriverService',
-      'TransportTaskService->reporting.TripOperationsEvidenceGateway',
-    ].some(reference => `${edge.source}->${edge.target}` === `com.baiyue.lastleg.dispatch.transport.${reference.replace('->', '->com.baiyue.lastleg.fleet.')}`)),
+      && edge.target === 'com.baiyue.lastleg.fleet.ownedbusiness.port.OwnedBusinessOwnershipCapture'),
     'dispatch must use fleet ports and guards, not its persistence mappers');
   const incomingEdges = report.classDependencies.filter(edge => edge.source.startsWith('com.baiyue.lastleg.transfer.') && edge.target.startsWith('com.baiyue.lastleg.fleet.'));
   assert.ok(incomingEdges.length > 0);

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/entity/DispatchAggregate.java

@@ -8,7 +8,6 @@ import java.time.LocalDateTime;
 public class DispatchAggregate {
     private Long id;
     private String dispatchNo;
-    private String taskType;
     private Long tripId;
     private String overseasWarehouseId;
     private String overseasWarehouseCode;

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/mapper/DispatchAggregateMapper.java

@@ -14,11 +14,7 @@ public interface DispatchAggregateMapper {
         <if test='q.dispatchNo != null'> AND d.dispatch_no LIKE CONCAT('%',#{q.dispatchNo},'%')</if>
         <if test='q.vehiclePlate != null'> AND d.vehicle_plate LIKE CONCAT('%',#{q.vehiclePlate},'%')</if>
         <if test='q.warehouseId != null'> AND d.overseas_warehouse_id=#{q.warehouseId}</if>
-        <if test='q.customerId != null'> AND (
-          EXISTS(SELECT 1 FROM ll_dispatch_item i WHERE i.dispatch_order_id=d.id AND i.customer_id=#{q.customerId})
-          OR EXISTS(SELECT 1 FROM ll_dispatch_truck_task t WHERE t.dispatch_no=d.dispatch_no AND t.customer_id=#{q.customerId})
-          OR EXISTS(SELECT 1 FROM ll_fleet_pickup_task p JOIN ll_fleet_trip f ON f.trip_no=p.trip_no WHERE f.id=d.trip_id AND p.customer_id=#{q.customerId})
-        )</if>
+        <if test='q.customerId != null'> AND EXISTS(SELECT 1 FROM ll_dispatch_item i WHERE i.dispatch_order_id=d.id AND i.customer_id=#{q.customerId})</if>
         <if test='q.fbaAppointmentNo != null'> AND EXISTS(SELECT 1 FROM ll_dispatch_appointment_allocation a JOIN ll_inbound_fba_appointment ap ON a.batch_key=CONCAT('FBA_APPOINTMENT:',ap.id) WHERE a.dispatch_id=d.id AND ap.confirmation_no=#{q.fbaAppointmentNo})</if>
         """;
     String REVIEW_DISPATCH = "CASE d.review_state WHEN 'DRAFT' THEN 'NOT_SUBMITTED' WHEN 'DISPATCH_PENDING' THEN 'PENDING' WHEN 'DISPATCH_REJECTED' THEN 'REJECTED' ELSE 'APPROVED' END";
@@ -37,12 +33,12 @@ public interface DispatchAggregateMapper {
 
     /** 首次创建整车所有权及初始版本，不写customer_id。 */
     @Insert("""
-        INSERT INTO ll_dispatch_order(id,dispatch_no,task_type,trip_id,overseas_warehouse_id,overseas_warehouse_code,
+        INSERT INTO ll_dispatch_order(id,dispatch_no,trip_id,overseas_warehouse_id,overseas_warehouse_code,
           overseas_warehouse_name,status,stage,record_version,cargo_revision,cargo_hash,review_state,review_round,
           dispatch_review_json,loading_review_json,resources_json,vehicle_plate,route,planned_departure_at,
           estimated_arrival_at,item_count,pallet_count,package_count,picked_package_count,shipped_package_count,
           remark,created_by,created_at,updated_at)
-        VALUES(#{r.id},#{r.dispatchNo},COALESCE(#{r.taskType},'DELIVERY'),#{r.tripId},#{r.overseasWarehouseId},#{r.overseasWarehouseCode},
+        VALUES(#{r.id},#{r.dispatchNo},#{r.tripId},#{r.overseasWarehouseId},#{r.overseasWarehouseCode},
           #{r.overseasWarehouseName},#{r.status},#{r.stage},#{r.recordVersion},#{r.cargoRevision},#{r.cargoHash},
           #{r.reviewState},#{r.reviewRound},#{r.dispatchReviewJson},#{r.loadingReviewJson},#{r.resourcesJson},
           #{r.vehiclePlate},#{r.route},#{r.plannedDepartureAt},#{r.estimatedArrivalAt},#{r.itemCount},#{r.palletCount},

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/port/DispatchViews.java

@@ -29,7 +29,7 @@ public final class DispatchViews {
     public record Page(List<ListRow> records, long total, long page, long size, long pages,
                          Statistics statistics, Instant snapshotAt) { }
 
-    public record ListRow(String dispatchNo, String taskType, Status status, Stage stage, long recordVersion,
+    public record ListRow(String dispatchNo, Status status, Stage stage, long recordVersion,
                             ReviewState reviewState, Reviews reviews, Resources resources,
                             String warehouseId, String warehouseCode, String warehouseName,
                             Instant plannedDepartureAt, Instant departedAt, Counts counts,
@@ -56,7 +56,7 @@ public final class DispatchViews {
                                 String sourceBusinessType, String sourceBusinessNo) { }
 
     /** 页头元数据和四个内容对象固定，附加能力不扩展为新页签。 */
-    public record Detail(String dispatchNo, String taskType, Status status, Stage stage, long recordVersion,
+    public record Detail(String dispatchNo, Status status, Stage stage, long recordVersion,
                            ReviewState reviewState, Reviews reviews, Counts counts,
                            boolean pickingReconciled, Map<Action, Gate> actions,
                            VehicleInfo vehicleInfo, DispatchInfo dispatchInfo, Documents documents,

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/service/DispatchAggregateService.java

@@ -665,7 +665,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
             d.outboundNo(),d.deliveryNo(),new Destination(com.baiyue.lastleg.fleet.trip.FleetDispatchGateway.destinationKey(d.type(),d.warehouseCode(),d.warehouseCode(),d.address(),d.postalCode()),d.type(),d.warehouseId(),d.warehouseCode(),d.warehouseName(),d.address(),d.postalCode(),d.contactName(),d.contactPhone()),
             d.status(),d.packageCount(),d.palletCount())).toList();
         var documents=new DispatchViews.Documents(number,repository.outbounds(row.getId()),deliveries,instant(row.getCreatedAt()),instant(row.getUpdatedAt()),row.getRemark());
-        return new DispatchViews.Detail(number,row.getTaskType()==null?"DELIVERY":row.getTaskType(),Status.valueOf(row.getStatus()),Stage.valueOf(row.getStage()),row.getRecordVersion(),ReviewState.valueOf(row.getReviewState()),
+        return new DispatchViews.Detail(number,Status.valueOf(row.getStatus()),Stage.valueOf(row.getStage()),row.getRecordVersion(),ReviewState.valueOf(row.getReviewState()),
             reviews(row),counts(row),reconciled(row),actions(actor,row),new DispatchViews.VehicleInfo(resources.vehicle(),resources.driver()),
             new DispatchViews.DispatchInfo(row.getRoute(),instant(row.getPlannedDepartureAt()),instant(row.getDepartedAt()),instant(row.getEstimatedArrivalAt()),appointments,batchRefs),
             documents,orderDetails(cargo));
@@ -772,12 +772,6 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
 
     /** 动作快照只反映实际当前资格，写入仍须再次加锁校验。 */
     Map<Action,Gate> actions(Actor actor,DispatchAggregate row) {
-        // 到仓取货和本土卡车沿运输任务执行，不能进入仓内拣货、扣库存和转派送链。
-        if (row.getTaskType()!=null && !"DELIVERY".equals(row.getTaskType())) {
-            var blocked=new EnumMap<Action,Gate>(Action.class);
-            for(var action:Action.values())blocked.put(action,new Gate(false,"TRANSPORT_TASK","请在排车运输任务中操作"));
-            return Collections.unmodifiableMap(blocked);
-        }
         var gates=new EnumMap<Action,Gate>(Action.class); boolean active=Status.ACTIVE.name().equals(row.getStatus());
         Stage stage=Stage.valueOf(row.getStage()); ReviewState review=ReviewState.valueOf(row.getReviewState());
         for(var action:Action.values()) {
@@ -831,7 +825,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
 
     /** 列表不逐行读取明细、附件或派送。 */
     private DispatchViews.ListRow listRow(Actor actor,DispatchAggregate row) {
-        return new DispatchViews.ListRow(row.getDispatchNo(),row.getTaskType()==null?"DELIVERY":row.getTaskType(),Status.valueOf(row.getStatus()),Stage.valueOf(row.getStage()),row.getRecordVersion(),ReviewState.valueOf(row.getReviewState()),
+        return new DispatchViews.ListRow(row.getDispatchNo(),Status.valueOf(row.getStatus()),Stage.valueOf(row.getStage()),row.getRecordVersion(),ReviewState.valueOf(row.getReviewState()),
             reviews(row),read(row.getResourcesJson(),Resources.class),row.getOverseasWarehouseId(),row.getOverseasWarehouseCode(),row.getOverseasWarehouseName(),instant(row.getPlannedDepartureAt()),instant(row.getDepartedAt()),counts(row),reconciled(row),row.getArrangementKey()!=null,actions(actor,row));
     }
 

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/transport/TransportTaskController.java

@@ -1,91 +0,0 @@
-package com.baiyue.lastleg.dispatch.transport;
-
-import com.baiyue.common.core.api.ApiResponse;
-import com.baiyue.common.security.AuthenticatedUser;
-import com.baiyue.lastleg.fleet.pickup.*;
-import com.baiyue.lastleg.fleet.trip.*;
-import jakarta.validation.Valid;
-import org.springframework.http.*;
-import org.springframework.security.access.prepost.PreAuthorize;
-import org.springframework.security.core.annotation.AuthenticationPrincipal;
-import org.springframework.web.bind.annotation.*;
-import org.springframework.web.multipart.MultipartFile;
-import org.springframework.web.server.ResponseStatusException;
-
-/** 两类原单通过现有排车权限接入，禁止客户主体借同名权限调用。 */
-@RestController
-@RequestMapping("/api/platform/v1/last-leg/dispatches/transport-tasks")
-public class TransportTaskController {
-    private final TransportTaskService service;
-    private final FleetPickupService pickups;
-    private final FleetTripService trips;
-    private final FleetTripCompletionService completion;
-    /** 注入运输业务和现有现场执行能力。 */
-    public TransportTaskController(TransportTaskService service,FleetPickupService pickups,FleetTripService trips,FleetTripCompletionService completion){this.service=service;this.pickups=pickups;this.trips=trips;this.completion=completion;}
-    /** 自动汇入审核后的上门取货需求。 */
-    @GetMapping("/pickup-candidates") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:list')")
-    public ApiResponse<?> pickupCandidates(@AuthenticationPrincipal AuthenticatedUser user,@Valid FleetPickupModels.Query query){operator(user);return ApiResponse.success(pickups.candidates(query));}
-    /** 自动汇入本土卡车待派车需求。 */
-    @GetMapping("/truck-candidates") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:list')")
-    public ApiResponse<?> truckCandidates(@AuthenticationPrincipal AuthenticatedUser user){operator(user);return ApiResponse.success(service.truckCandidates());}
-    /** 创建入仓取货排车。 */
-    @PostMapping("/pickup") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:create')")
-    public ApiResponse<?> pickup(@AuthenticationPrincipal AuthenticatedUser user,@Valid @RequestBody FleetPickupModels.Create request){return ApiResponse.success(service.createPickup(operator(user),request));}
-    /** 创建本土卡车排车。 */
-    @PostMapping("/truck") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:create')")
-    public ApiResponse<?> truck(@AuthenticationPrincipal AuthenticatedUser user,@Valid @RequestBody TransportTaskModels.TruckCreate request){return ApiResponse.success(service.createTruck(operator(user),request));}
-    /** 当前排车详情的运输执行面板。 */
-    @GetMapping("/{number}") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:list')")
-    public ApiResponse<?> detail(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number){operator(user);return ApiResponse.success(service.detail(number));}
-    /** 分配或改派真实车辆司机。 */
-    @PostMapping("/{number}/assign") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<?> assign(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number,@Valid @RequestBody FleetTripModels.Assign request){return ApiResponse.success(service.assign(number,operator(user),request));}
-    /** 取消未发车任务，来源回到待安排。 */
-    @PostMapping("/{number}/cancel") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:cancel')")
-    public ApiResponse<?> cancel(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number,@Valid @RequestBody FleetTripModels.Cancel request){return ApiResponse.success(service.cancel(number,operator(user),request));}
-    /** 候选搜索复用统一资源占用真相。 */
-    @PostMapping("/{number}/resource-occupancy") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:list')")
-    public ApiResponse<?> occupancy(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number,@Valid @RequestBody FleetTripModels.ResourceQuery query){operator(user);return ApiResponse.success(trips.resourceOccupancy(service.transport(number,false).getTripNo(),query));}
-    /** 实际任务结束后分别释放车辆与司机。 */
-    @PostMapping("/{number}/release") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<?> release(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number,@Valid @RequestBody FleetCompletionModels.Release request){return ApiResponse.success(completion.release(service.transport(number,false).getTripNo(),operator(user),request));}
-    /** 取货发车仅推进运输。 */
-    @PostMapping("/{number}/pickup/depart") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:depart')")
-    public ApiResponse<?> departPickup(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number,@Valid @RequestBody FleetPickupModels.Command request){return ApiResponse.success(pickups.depart(service.transport(number,false).getTripNo(),operator(user),request));}
-    /** 全部送仓后结束取货运输。 */
-    @PostMapping("/{number}/pickup/complete") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<?> completePickup(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number,@Valid @RequestBody FleetPickupModels.Command request){return ApiResponse.success(pickups.complete(service.transport(number,false).getTripNo(),operator(user),request));}
-    /** 凭证归属具体客户原单。 */
-    @PostMapping(value="/{number}/pickup/{customer}/{source}/files",consumes=MediaType.MULTIPART_FORM_DATA_VALUE) @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<?> pickupFile(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number,@PathVariable String customer,@PathVariable String source,@RequestPart MultipartFile file){return ApiResponse.success(pickups.upload(service.transport(number,false).getTripNo(),customer,source,operator(user),file));}
-    /** 确认实提箱数和原单凭证。 */
-    @PostMapping("/{number}/pickup/{customer}/{source}/picked") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<?> picked(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number,@PathVariable String customer,@PathVariable String source,@Valid @RequestBody FleetPickupModels.Pickup request){return ApiResponse.success(pickups.picked(service.transport(number,false).getTripNo(),customer,source,operator(user),request));}
-    /** 送仓只开放原单收货门禁。 */
-    @PostMapping("/{number}/pickup/{customer}/{source}/arrive") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<?> arrive(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number,@PathVariable String customer,@PathVariable String source,@Valid @RequestBody FleetPickupModels.Command request){return ApiResponse.success(pickups.arrive(service.transport(number,false).getTripNo(),customer,source,operator(user),request));}
-    /** 取货凭证同时核对当前排车和原单归属。 */
-    @GetMapping("/{number}/pickup/{customer}/{source}/files/{fileId}") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:list')")
-    public ResponseEntity<byte[]> pickupEvidence(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number,@PathVariable String customer,@PathVariable String source,@PathVariable long fileId){
-        operator(user);var trip=service.transport(number,false);
-        if(pickups.tasks(trip.getTripNo()).stream().noneMatch(task->task.customerId().equals(customer)&&task.transferNo().equals(source)))throw new ResponseStatusException(HttpStatus.NOT_FOUND,"当前排车没有该原单");
-        return ResponseEntity.ok().contentType(MediaType.APPLICATION_OCTET_STREAM).body(pickups.evidence(customer,source,fileId));
-    }
-    /** 本土卡车按真实运输发车。 */
-    @PostMapping("/{number}/truck/depart") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:depart')")
-    public ApiResponse<?> departTruck(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number,@Valid @RequestBody TransportTaskModels.Command request){return ApiResponse.success(service.truckCommand(number,operator(user),"depart",request));}
-    /** 本土卡车提供运输完成凭证后结案。 */
-    @PostMapping("/{number}/truck/complete") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<?> completeTruck(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number,@Valid @RequestBody TransportTaskModels.Command request){return ApiResponse.success(service.truckCommand(number,operator(user),"complete",request));}
-    /** 本土卡车凭证绑定本次排车资源记录。 */
-    @PostMapping(value="/{number}/truck/files",consumes=MediaType.MULTIPART_FORM_DATA_VALUE) @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<?> truckFile(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number,@RequestPart MultipartFile file){return ApiResponse.success(service.upload(number,operator(user),file));}
-    /** 完成凭证经排车归属授权后下载。 */
-    @GetMapping("/{number}/truck/files/{fileId}") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:list')")
-    public ResponseEntity<byte[]> evidence(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number,@PathVariable long fileId){operator(user);return ResponseEntity.ok().contentType(MediaType.APPLICATION_OCTET_STREAM).header(HttpHeaders.CONTENT_DISPOSITION,"attachment; filename=transport-evidence").body(service.evidence(number,fileId));}
-    /** 认证身份来自网关安全上下文。 */
-    private static String operator(AuthenticatedUser user){
-        if(user==null || user.userId()==null)throw new ResponseStatusException(HttpStatus.UNAUTHORIZED,"请重新登录");
-        if(!"PLATFORM".equals(user.appCode()) || !Long.valueOf(0).equals(user.tenantId()))throw new ResponseStatusException(HttpStatus.FORBIDDEN,"仅平台可以操作排车");return user.userId().toString();
-    }
-}

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/transport/TransportTaskMapper.java

@@ -1,42 +0,0 @@
-package com.baiyue.lastleg.dispatch.transport;
-
-import com.baiyue.lastleg.dispatch.entity.DispatchAggregate;
-import org.apache.ibatis.annotations.*;
-
-/** 运输任务与现有排车主单的一对一关系及本土卡车原单关联。 */
-@Mapper
-public interface TransportTaskMapper {
-    /** 已成功命令持久化的凭证引用可在刷新后恢复。 */
-    @Select("SELECT evidence_json FROM ll_dispatch_transport_command WHERE dispatch_no=#{number} ORDER BY created_at,request_key")
-    java.util.List<String> evidence(String number);
-    /** 运输命令独立幂等账本，摘要包含动作与版本。 */
-    @Select("SELECT request_hash FROM ll_dispatch_transport_command WHERE dispatch_no=#{number} AND request_key=#{key}")
-    String commandHash(@Param("number") String number,@Param("key") String key);
-    /** 仅在执行成功同事务记账。 */
-    @Insert("INSERT INTO ll_dispatch_transport_command(dispatch_no,request_key,request_hash,evidence_json) VALUES(#{number},#{key},#{hash},#{evidence})")
-    int command(@Param("number") String number,@Param("key") String key,@Param("hash") String hash,@Param("evidence") String evidence);
-    /** 创建键关联原始请求摘要，避免修改来源后重放。 */
-    @Select("SELECT request_hash FROM ll_dispatch_transport_create WHERE trip_no=#{trip}")
-    String createHash(String trip);
-    /** 保存首次本土卡车安排内容。 */
-    @Insert("INSERT INTO ll_dispatch_transport_create(trip_no,request_hash) VALUES(#{trip},#{hash})")
-    int createHashSave(@Param("trip") String trip,@Param("hash") String hash);
-    /** 仅返回已完成原单收货分配且没有承运安排的本土卡车需求。 */
-    @Select("SELECT o.* FROM ll_us_truck_order o WHERE o.status='PENDING_DISPATCH' AND NOT EXISTS(SELECT 1 FROM ll_dispatch_truck_task t WHERE t.customer_id=o.customer_id AND t.order_no=o.order_no AND t.active_order IS NOT NULL) AND NOT EXISTS(SELECT 1 FROM ll_fleet_pool_order_link p WHERE p.customer_id=o.customer_id AND p.business_type='US_TRUCK' AND p.business_order_id=o.id) ORDER BY o.created_at,o.id LIMIT 100")
-    java.util.List<com.baiyue.lastleg.trucking.entity.UsTruckOrder> candidates();
-    /** 原取货创建请求重放时恢复同一排车号。 */
-    @Select("SELECT * FROM ll_dispatch_order WHERE trip_id=#{trip}")
-    DispatchAggregate byTrip(long trip);
-    /** 原单仅允许一个有效承运任务，取消后保留历史。 */
-    @Insert("INSERT INTO ll_dispatch_truck_task(dispatch_no,trip_no,customer_id,order_no,active_order) VALUES(#{dispatchNo},#{tripNo},#{customerId},#{orderNo},CONCAT(#{customerId},':',#{orderNo}))")
-    int insert(TransportTaskModels.TruckLink row);
-    /** 按排车号读取本土卡车关联。 */
-    @Select("SELECT dispatch_no,trip_no,customer_id,order_no FROM ll_dispatch_truck_task WHERE dispatch_no=#{number}")
-    TransportTaskModels.TruckLink truck(String number);
-    /** 取消任务解除有效单唯一约束，历史关联不删除。 */
-    @Update("UPDATE ll_dispatch_truck_task SET active_order=NULL WHERE dispatch_no=#{number}")
-    int cancel(String number);
-    /** 查询排车唯一资源记录。 */
-    @Select("SELECT trip_no FROM ll_fleet_trip WHERE id=#{id}")
-    String tripNo(long id);
-}

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/transport/TransportTaskModels.java

@@ -1,23 +0,0 @@
-package com.baiyue.lastleg.dispatch.transport;
-
-import com.baiyue.lastleg.fleet.trip.FleetTripModels;
-import com.baiyue.lastleg.fleet.pickup.FleetPickupModels;
-import jakarta.validation.Valid;
-import jakarta.validation.constraints.*;
-import java.time.Instant;
-import java.util.List;
-
-/** 排车列表中的到仓取货与本土卡车运输命令。 */
-public final class TransportTaskModels {
-    /** 仅承载契约。 */
-    private TransportTaskModels() { }
-    public record TruckCreate(@NotBlank String customerId,@NotBlank String orderNo,
-        @NotNull @Positive Long warehouseId,@NotNull Instant plannedDepartureAt,
-        @NotNull Instant expectedDriverEndAt,@NotBlank @Size(min=8,max=128) String idempotencyKey) { }
-    public record Command(@NotNull @Min(0) Long recordVersion,@NotBlank @Size(min=8,max=128) String idempotencyKey,
-        @NotBlank @Size(max=1000) String reason,List<@Positive Long> evidenceFileIds) { }
-    public record Detail(String dispatchNo,String taskType,FleetTripModels.Detail execution,
-        String customerId,String orderNo,List<FleetPickupModels.Task> pickups,
-        List<com.baiyue.lastleg.fleet.reporting.TripOperationsRecordModels.EvidenceFile> completionEvidence) { }
-    public record TruckLink(String dispatchNo,String tripNo,String customerId,String orderNo) { }
-}

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/transport/TransportTaskProjection.java

@@ -1,84 +0,0 @@
-package com.baiyue.lastleg.dispatch.transport;
-
-import com.baomidou.mybatisplus.core.toolkit.IdWorker;
-import com.baiyue.lastleg.dispatch.entity.DispatchAggregate;
-import com.baiyue.lastleg.dispatch.repository.DispatchAggregateRepository;
-import com.baiyue.lastleg.dispatch.service.DispatchNumberGenerator;
-import com.baiyue.lastleg.fleet.trip.FleetTripEntity;
-import com.baiyue.lastleg.fleet.trip.TransportTripChanged;
-import com.baiyue.lastleg.trucking.entity.*;
-import com.baiyue.lastleg.trucking.repository.UsTruckOrderRepository;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.springframework.context.event.EventListener;
-import org.springframework.stereotype.Service;
-import java.time.*;
-import java.util.*;
-import static com.baiyue.lastleg.dispatch.port.DispatchContracts.*;
-import static com.baiyue.lastleg.dispatch.port.DispatchTypes.*;
-
-/** 现有排车主单与运输事实同步，旧执行入口也不能留下不同步的单据。 */
-@Service
-public class TransportTaskProjection {
-    private final DispatchAggregateRepository roots;
-    private final TransportTaskRepository links;
-    private final UsTruckOrderRepository trucks;
-    private final DispatchNumberGenerator numbers;
-    private final ObjectMapper json;
-    /** 注入本地聚合与原单持久化能力，无跨服务数据库访问。 */
-    public TransportTaskProjection(DispatchAggregateRepository roots,TransportTaskRepository links,UsTruckOrderRepository trucks,DispatchNumberGenerator numbers,ObjectMapper json) {
-        this.roots=roots;this.links=links;this.trucks=trucks;this.numbers=numbers;this.json=json;
-    }
-    /** 注册真实排车号；来源行锁和唯一 trip_id 防止重复建单。 */
-    public DispatchAggregate register(FleetTripEntity trip,int items,int pallets,int packages,String operator) {
-        var existing=links.byTrip(trip.getId());if(existing!=null)return existing;
-        var row=new DispatchAggregate();row.setId(IdWorker.getId());row.setDispatchNo(numbers.next());row.setTaskType(trip.getTripPurpose());
-        row.setTripId(trip.getId());row.setOverseasWarehouseId(trip.getWarehouseId().toString());
-        row.setOverseasWarehouseCode(trip.getWarehouseCode());row.setOverseasWarehouseName(trip.getWarehouseName());
-        row.setStatus("ACTIVE");row.setStage("BEFORE_LOADING");row.setRecordVersion(trip.getRecordVersion());row.setCargoRevision(0L);
-        row.setCargoHash(trip.getRequestHash());row.setReviewState("DRAFT");row.setReviewRound(0L);
-        var review=new Review(ReviewStatus.NOT_SUBMITTED,null,null,null,0,null,null);
-        row.setDispatchReviewJson(write(review));row.setLoadingReviewJson(write(review));
-        resources(row,trip);row.setPlannedDepartureAt(trip.getPlannedDepartureAt());row.setEstimatedArrivalAt(trip.getExpectedDriverEndAt());
-        row.setRoute(("PICKUP".equals(trip.getTripPurpose())?"到仓取货":"本土卡车")+" · "+items+"单 · "+trip.getWarehouseCode());row.setItemCount(items);row.setPalletCount(pallets);row.setPackageCount(packages);
-        row.setPickedPackageCount(0);row.setShippedPackageCount(0);row.setRemark(trip.getRemark());row.setCreatedBy(operator);
-        row.setCreatedAt(LocalDateTime.now(ZoneOffset.UTC));row.setUpdatedAt(row.getCreatedAt());roots.insert(row);
-        roots.history(IdWorker.getId(),row,"TRANSPORT_CREATE",operator,"接入现有排车",write(row),row.getUpdatedAt());return row;
-    }
-    /** 与资源事实同事务更新主单，兼容仍被集成调用的旧执行接口。 */
-    @EventListener
-    public void changed(TransportTripChanged event) {
-        var trip=event.trip();if(!Set.of("PICKUP","LOCAL_TRUCK").contains(Objects.toString(trip.getTripPurpose(),"")))return;
-        var found=links.byTrip(trip.getId());if(found==null)return;
-        var row=roots.lock(found.getDispatchNo());long version=row.getRecordVersion();
-        row.setRecordVersion(trip.getRecordVersion());row.setUpdatedAt(trip.getUpdatedAt());
-        row.setStatus("CANCELLED".equals(trip.getStatus())?"CANCELLED":"ACTIVE");
-        row.setStage(switch(trip.getStatus()){case "IN_TRANSIT"->"DELIVERING";case "COMPLETED"->"DELIVERED";default->"BEFORE_LOADING";});
-        row.setDepartedAt(trip.getDepartedAt());row.setDeliveryCompletedAt(trip.getCompletedAt());
-        row.setPlannedDepartureAt(trip.getPlannedDepartureAt());row.setEstimatedArrivalAt(trip.getExpectedDriverEndAt());row.setRemark(trip.getRemark());resources(row,trip);
-        if(roots.saveState(row,version)!=1)throw new IllegalStateException("运输排车版本保存失败");
-        roots.history(IdWorker.getId(),row,event.action(),event.operator(),event.reason(),write(row),trip.getUpdatedAt());
-        var link=links.truck(row.getDispatchNo());if(link==null)return;
-        String target=switch(trip.getStatus()){case "CANCELLED"->"PENDING_DISPATCH";case "IN_TRANSIT"->"IN_TRANSIT";case "COMPLETED"->"COMPLETED";default->"DISPATCHED";};
-        transition(link.customerId(),link.orderNo(),target,event.action(),event.operator(),event.reason(),row.getDispatchNo()+":"+trip.getRecordVersion());
-        if("CANCELLED".equals(trip.getStatus()))links.cancel(row.getDispatchNo());
-    }
-    /** 本土卡车只回写真实运输状态并追加原业务不可变历史。 */
-    public void transition(String customer,String number,String target,String action,String operator,String reason,String key) {
-        var order=trucks.lockNo(customer,number);if(order==null)throw new IllegalStateException("关联本土卡车单不存在");
-        String from=order.getStatus();if(target.equals(from))return;
-        boolean allowed=("PENDING_DISPATCH".equals(from)&&"DISPATCHED".equals(target)) || ("DISPATCHED".equals(from)&&Set.of("PENDING_DISPATCH","IN_TRANSIT").contains(target)) || ("IN_TRANSIT".equals(from)&&"COMPLETED".equals(target));
-        if(!allowed)throw new IllegalStateException("本土卡车原单状态与排车执行不一致");
-        order.setStatus(target);order.setVersion(order.getVersion()+1);order.setUpdatedAt(LocalDateTime.now(ZoneOffset.UTC));trucks.updateOrder(order);
-        var history=new UsTruckOrderStatusHistory();history.setId(IdWorker.getId());history.setOrderId(order.getId());history.setCustomerId(customer);
-        history.setOperationType(action);history.setFromStatus(from);history.setToStatus(target);history.setOperatorId(operator);history.setIdempotencyKey(key);
-        history.setRemark(reason);history.setCreatedAt(order.getUpdatedAt());trucks.insertHistory(history);
-    }
-    /** 主单仅展示真实主档分配，不伪造临时证照或仓库装载事实。 */
-    private void resources(DispatchAggregate row,FleetTripEntity trip) {
-        row.setVehiclePlate(trip.getVehiclePlate());row.setResourcesJson(write(new Resources(
-            trip.getVehicleId()==null?null:new VehicleSnapshot(ResourceMode.MASTER,trip.getVehicleId(),trip.getVehiclePlate(),null,null,new Capacity(trip.getMaxPalletSpaces(),trip.getMaxLoadKg(),trip.getMaxVolumeCbm()),List.of()),
-            trip.getDriverId()==null?null:new DriverSnapshot(ResourceMode.MASTER,trip.getDriverId(),trip.getDriverName(),trip.getDriverPhone(),null))));
-    }
-    /** 保存明确的业务快照，失败时终止事务。 */
-    private String write(Object value){try{return json.writeValueAsString(value);}catch(Exception e){throw new IllegalStateException("运输快照序列化失败",e);}}
-}

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/transport/TransportTaskRepository.java

@@ -1,34 +0,0 @@
-package com.baiyue.lastleg.dispatch.transport;
-
-import com.baiyue.lastleg.dispatch.entity.DispatchAggregate;
-import org.springframework.stereotype.Repository;
-
-/** 运输关联持久化边界，不在此决定业务状态。 */
-@Repository
-public class TransportTaskRepository {
-    private final TransportTaskMapper mapper;
-    /** 注入本域 Mapper。 */
-    public TransportTaskRepository(TransportTaskMapper mapper) { this.mapper=mapper; }
-    /** 已确认完成凭证引用。 */
-    public java.util.List<String> evidence(String number){return mapper.evidence(number);}
-    /** 读取已成功执行的运输命令摘要。 */
-    public String commandHash(String number,String key){return mapper.commandHash(number,key);}
-    /** 成功后记账。 */
-    public void command(String number,String key,String hash,String evidence){mapper.command(number,key,hash,evidence);}
-    /** 读取原创建内容摘要。 */
-    public String createHash(String trip){return mapper.createHash(trip);}
-    /** 保存创建内容摘要。 */
-    public void createHash(String trip,String hash){mapper.createHashSave(trip,hash);}
-    /** 按资源记录恢复排车主单。 */
-    public DispatchAggregate byTrip(long trip) { return mapper.byTrip(trip); }
-    /** 保存原本土卡车单关联。 */
-    public void insert(TransportTaskModels.TruckLink row) { mapper.insert(row); }
-    /** 读取原单关联。 */
-    public TransportTaskModels.TruckLink truck(String number) { return mapper.truck(number); }
-    /** 取消后允许原单重新安排。 */
-    public void cancel(String number) { mapper.cancel(number); }
-    /** 解析主单对应资源业务号。 */
-    public String tripNo(long id) { return mapper.tripNo(id); }
-    /** 最早的一百票待派车原单，安排成功后自动移出候选。 */
-    public java.util.List<com.baiyue.lastleg.trucking.entity.UsTruckOrder> candidates() { return mapper.candidates(); }
-}

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/transport/TransportTaskService.java

@@ -1,158 +0,0 @@
-package com.baiyue.lastleg.dispatch.transport;
-
-import com.baiyue.lastleg.dispatch.repository.DispatchAggregateRepository;
-import com.baiyue.lastleg.fleet.pickup.*;
-import com.baiyue.lastleg.fleet.trip.*;
-import com.baiyue.lastleg.fleet.driver.DriverService;
-import com.baiyue.lastleg.fleet.reporting.TripOperationsEvidenceGateway;
-import com.baiyue.lastleg.fleet.business.FleetPoolOrderQueries;
-import com.baiyue.lastleg.trucking.entity.UsTruckOrder;
-import com.baiyue.lastleg.trucking.repository.UsTruckOrderRepository;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-import org.springframework.http.HttpStatus;
-import org.springframework.web.server.ResponseStatusException;
-import org.springframework.web.multipart.MultipartFile;
-import java.time.*;
-import java.util.*;
-import java.nio.charset.StandardCharsets;
-import java.security.MessageDigest;
-
-/** 现有排车入口编排运输任务，不调用仓内拣货、装车审核及扣库存命令。 */
-@Service
-public class TransportTaskService {
-    private final DispatchAggregateRepository roots;
-    private final TransportTaskRepository links;
-    private final TransportTaskProjection projection;
-    private final FleetTripRepository tripRepo;
-    private final FleetTripService trips;
-    private final FleetPickupService pickups;
-    private final FleetPickupRepository pickupFacts;
-    private final UsTruckOrderRepository trucks;
-    private final FleetPoolOrderQueries pool;
-    private final DriverService drivers;
-    private final FleetTransportVehicleGuard vehicles;
-    private final TripOperationsEvidenceGateway files;
-    private final ObjectMapper json;
-    /** 复用已有资格、占用、原单及凭证能力。 */
-    public TransportTaskService(DispatchAggregateRepository roots,TransportTaskRepository links,TransportTaskProjection projection,
-        FleetTripRepository tripRepo,FleetTripService trips,FleetPickupService pickups,FleetPickupRepository pickupFacts,
-        UsTruckOrderRepository trucks,FleetPoolOrderQueries pool,DriverService drivers,FleetTransportVehicleGuard vehicles,TripOperationsEvidenceGateway files,ObjectMapper json) {
-        this.roots=roots;this.links=links;this.projection=projection;this.tripRepo=tripRepo;this.trips=trips;this.pickups=pickups;this.pickupFacts=pickupFacts;
-        this.trucks=trucks;this.pool=pool;this.drivers=drivers;this.vehicles=vehicles;this.files=files;this.json=json;
-    }
-    /** 待排本土卡车仅展示未被独立排车或拼车承运占用的原单。 */
-    public List<UsTruckOrder> truckCandidates(){return links.candidates();}
-    /** 同仓取货沿用原任务规则，并注册一个真实排车主单。 */
-    @Transactional
-    public TransportTaskModels.Detail createPickup(String operator,FleetPickupModels.Create request) {
-        var created=pickups.create(operator,request);var trip=tripRepo.lockTrip(created.trip().tripNo());
-        var tasks=pickups.tasks(trip.getTripNo());var row=projection.register(trip,tasks.size(),0,tasks.stream().mapToInt(FleetPickupModels.Task::packageCount).sum(),operator);
-        return detail(row.getDispatchNo());
-    }
-    /** 原单锁和有效关联唯一约束共同阻止同单重复排车。 */
-    @Transactional
-    public TransportTaskModels.Detail createTruck(String operator,TransportTaskModels.TruckCreate request) {
-        String hash=hash(write(request));var prior=tripRepo.findCreated(operator,request.idempotencyKey());
-        if(prior!=null)return replayCreate(prior,hash);
-        var order=trucks.lockNo(request.customerId(),request.orderNo());if(order==null)throw missing("本土卡车单不存在");
-        prior=tripRepo.findCreated(operator,request.idempotencyKey());if(prior!=null)return replayCreate(prior,hash);
-        pool.requireStandalone(order.getCustomerId(),"US_TRUCK",order.getId());
-        if(!"PENDING_DISPATCH".equals(order.getStatus()) || trucks.hasActiveDispatch(order.getCustomerId(),order.getOrderNo()))throw conflict("仅待派车且未安排承运的本土卡车单可以接入排车");
-        if(order.getOriginAddress()==null || order.getOriginAddress().isBlank() || order.getDestinationAddress()==null || order.getDestinationAddress().isBlank())throw conflict("请先补齐原单起终点地址");
-        var created=trips.createLocalTruck(operator,new FleetTripModels.Create(request.warehouseId(),request.plannedDepartureAt(),request.expectedDriverEndAt(),
-            List.of(new FleetTripModels.Stop(order.getOrigin(),order.getOriginAddress(),null),new FleetTripModels.Stop(order.getDestination(),order.getDestinationAddress(),null)),"本土卡车："+order.getOrderNo(),request.idempotencyKey()));
-        var trip=tripRepo.lockTrip(created.trip().tripNo());var row=projection.register(trip,1,value(order.getPalletCount()),value(order.getPackageCount()),operator);
-        links.insert(new TransportTaskModels.TruckLink(row.getDispatchNo(),trip.getTripNo(),order.getCustomerId(),order.getOrderNo()));links.createHash(trip.getTripNo(),hash);
-        projection.transition(order.getCustomerId(),order.getOrderNo(),"DISPATCHED","TRANSPORT_ASSIGN",operator,"接入排车："+row.getDispatchNo(),request.idempotencyKey());
-        return detail(row.getDispatchNo());
-    }
-    /** 重放只返回同一原始请求，不受后续原单状态推进影响。 */
-    private TransportTaskModels.Detail replayCreate(FleetTripEntity trip,String hash) {
-        if(!"LOCAL_TRUCK".equals(trip.getTripPurpose()) || !hash.equals(links.createHash(trip.getTripNo())))throw conflict("同一安排请求不能更换来源或时间");
-        var row=links.byTrip(trip.getId());if(row==null)throw conflict("原安排尚未完成，请重试");return detail(row.getDispatchNo());
-    }
-    /** 通过排车号读取运输执行，不要求访问已隐藏的管理页面。 */
-    @Transactional(readOnly=true)
-    public TransportTaskModels.Detail detail(String number) {
-        var trip=transport(number,false);var row=links.byTrip(trip.getId());var link=links.truck(number);
-        return new TransportTaskModels.Detail(number,row.getTaskType(),trips.detail(trip.getTripNo()),link==null?null:link.customerId(),link==null?null:link.orderNo(),
-            "PICKUP".equals(row.getTaskType())?pickups.tasks(trip.getTripNo()):List.of(),
-            evidenceIds(number).stream().map(id->files.metadata(trip.getId(),id)).toList());
-    }
-    /** 仅允许读取已确认属于本排车的完成凭证，文件元数据再次核对资源归属。 */
-    public byte[] evidence(String number,long id){var trip=transport(number,false);if(!evidenceIds(number).contains(id))throw missing("当前排车没有该完成凭证");files.metadata(trip.getId(),id);return files.download(trip.getId(),id);}
-    /** 账本引用去重，不把上传但未确认的文件当作运输完成证据。 */
-    private List<Long> evidenceIds(String number){return links.evidence(number).stream().filter(Objects::nonNull).flatMap(value->{try{return json.readValue(value,new com.fasterxml.jackson.core.type.TypeReference<List<Long>>(){}).stream();}catch(Exception e){throw new IllegalStateException("运输凭证引用读取失败",e);}}).distinct().toList();}
-    /** 所有命令先锁资源父记录，再由既有服务核对公共执行版本。 */
-    public FleetTripEntity transport(String number,boolean lock) {
-        var root=roots.find(number);if(root==null)throw missing("排车单不存在");
-        if(!Set.of("PICKUP","LOCAL_TRUCK").contains(Objects.toString(root.getTaskType(),"")))throw conflict("当前排车单不是运输任务");
-        String tripNo=links.tripNo(root.getTripId());var trip=lock?tripRepo.lockTrip(tripNo):tripRepo.findTrip(tripNo);if(trip==null)throw missing("运输资源记录不存在");return trip;
-    }
-    /** 分配实际资源，容量超限时整次分配回滚。 */
-    @Transactional
-    public TransportTaskModels.Detail assign(String number,String operator,FleetTripModels.Assign request) {
-        var trip=transport(number,true);trips.assign(trip.getTripNo(),operator,request);
-        if("LOCAL_TRUCK".equals(trip.getTripPurpose()))capacity(tripRepo.findTrip(trip.getTripNo()),truck(number));return detail(number);
-    }
-    /** 取消运输并保留原单、排车及资源审计。 */
-    @Transactional
-    public TransportTaskModels.Detail cancel(String number,String operator,FleetTripModels.Cancel request) {
-        var trip=transport(number,true);trips.cancel(trip.getTripNo(),operator,request);return detail(number);
-    }
-    /** 本土卡车发车和完成不制造仓库收发货记录。 */
-    @Transactional
-    public TransportTaskModels.Detail truckCommand(String number,String operator,String action,TransportTaskModels.Command request) {
-        var trip=transport(number,true);if(!"LOCAL_TRUCK".equals(trip.getTripPurpose()))throw conflict("当前不是本土卡车运输任务");
-        String hash=hash(action+":"+write(request));String prior=links.commandHash(number,request.idempotencyKey());
-        if(prior!=null){if(!prior.equals(hash))throw conflict("同一请求标识不能提交不同内容");return detail(number);}
-        if(!Objects.equals(trip.getRecordVersion(),request.recordVersion()))throw conflict("运输任务已变化，请刷新后重试");
-        var order=truck(number);
-        if("depart".equals(action)) {
-            if(!"PLANNED".equals(trip.getStatus()) || !"DISPATCHED".equals(order.getStatus()))throw conflict("仅已派车的计划任务可发车");
-            requireResources(trip);capacity(trip,order);trip.setStatus("IN_TRANSIT");trip.setDepartedAt(now());
-        } else if("complete".equals(action)) {
-            if(!"IN_TRANSIT".equals(trip.getStatus()) || !"IN_TRANSIT".equals(order.getStatus()))throw conflict("请先确认发车");
-            if(request.evidenceFileIds()==null || request.evidenceFileIds().isEmpty())throw conflict("请上传至少一份本次运输完成凭证");
-            for(long id:request.evidenceFileIds())files.metadata(trip.getId(),id);
-            trip.setStatus("COMPLETED");trip.setCompletedAt(now());
-            trip.setCompletionJson(write(new FleetCompletionModels.Completed(request.idempotencyKey(),hash,trip.getCompletedAt().toInstant(ZoneOffset.UTC),Instant.now(),operator,List.of())));
-        } else throw conflict("不支持的运输动作");
-        trips.recordExecution(trip,request.recordVersion(),"LOCAL_TRUCK_"+action.toUpperCase(Locale.ROOT),request.reason(),operator);
-        links.command(number,request.idempotencyKey(),hash,write(request.evidenceFileIds()==null?List.of():request.evidenceFileIds()));return detail(number);
-    }
-    /** 上传只接受当前任务执行期间的真实文件，文件服务强制归属此资源记录。 */
-    @Transactional
-    public com.baiyue.lastleg.fleet.reporting.TripOperationsRecordModels.EvidenceFile upload(String number,String operator,MultipartFile file) {
-        var trip=transport(number,true);if(!"LOCAL_TRUCK".equals(trip.getTripPurpose()) || !Set.of("PLANNED","IN_TRANSIT").contains(trip.getStatus()))throw conflict("当前任务不能上传运输凭证");
-        if(file==null || file.isEmpty() || file.getSize()>10L*1024*1024)throw conflict("请上传不超过10MB的凭证");return files.upload(trip.getId(),operator,file);
-    }
-    /** 原单在执行时锁定，不能通过普通原单手工推进绕过排车。 */
-    private UsTruckOrder truck(String number){var link=links.truck(number);if(link==null)throw missing("本土卡车关联不存在");var order=trucks.lockNo(link.customerId(),link.orderNo());if(order==null)throw missing("本土卡车原单不存在");return order;}
-    /** 发车再次核对占用及证照，不把候选阶段校验当成执行资格。 */
-    private void requireResources(FleetTripEntity trip) {
-        if(trip.getVehicleId()==null || trip.getDriverId()==null || !pickupFacts.ownsResources(trip.getId(),trip.getVehicleId(),trip.getDriverId()))throw conflict("请先分配有效车辆和司机");
-        vehicles.validate(trip);
-        var driver=drivers.requireDispatchable(trip.getDriverId(),trip.getExpectedDriverEndAt().toInstant(ZoneOffset.UTC));if(!"OVERSEAS".equals(driver.details().region()))throw conflict("请选择海外司机");
-    }
-    /** 原单实收托量、申报重量和体积均不得超过已分配车辆能力。 */
-    private void capacity(FleetTripEntity trip,UsTruckOrder order) {
-        if(trip.getMaxPalletSpaces()==null || value(order.getPalletCount())>trip.getMaxPalletSpaces() || trip.getMaxLoadKg()==null || trip.getMaxVolumeCbm()==null
-            || (order.getTotalWeightKg()!=null && order.getTotalWeightKg().compareTo(trip.getMaxLoadKg())>0)
-            || (order.getTotalVolumeCbm()!=null && order.getTotalVolumeCbm().compareTo(trip.getMaxVolumeCbm())>0))throw conflict("本土卡车货量超过所选车辆托位、载重或容积");
-    }
-    /** 可空业务数量按零显示，不产生虚构实收。 */
-    private static int value(Integer value){return value==null?0:value;}
-    /** 固定 UTC 记录执行时刻。 */
-    private static LocalDateTime now(){return LocalDateTime.now(ZoneOffset.UTC).withNano(0);}
-    /** 稳定序列化请求摘要。 */
-    private String write(Object value){try{return json.writeValueAsString(value);}catch(Exception e){throw new IllegalStateException(e);}}
-    /** 不在账本保存原始隐私内容。 */
-    private static String hash(String value){try{return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(value.getBytes(StandardCharsets.UTF_8)));}catch(Exception e){throw new IllegalStateException(e);}}
-    /** 返回业务冲突。 */
-    private static ResponseStatusException conflict(String value){return new ResponseStatusException(HttpStatus.CONFLICT,value);}
-    /** 返回不可访问资源。 */
-    private static ResponseStatusException missing(String value){return new ResponseStatusException(HttpStatus.NOT_FOUND,value);}
-}

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/business/FleetLooseboardDemandMapper.java

@@ -1,29 +0,0 @@
-package com.baiyue.lastleg.fleet.business;
-
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.baiyue.lastleg.looseboard.entity.LocalLooseboardOrder;
-import org.apache.ibatis.annotations.*;
-import java.util.Collection;
-import java.util.List;
-
-@Mapper
-public interface FleetLooseboardDemandMapper {
-    /** 分页读取未匹配且没有独立实物履约的客户散板需求。 */
-    @Select("<script>SELECT o.* FROM ll_local_looseboard_order o WHERE o.status='PENDING_ACCEPTANCE' AND o.lastleg_order_id IS NULL "
-        + "AND NOT EXISTS (SELECT 1 FROM ll_fleet_external_booking b WHERE b.customer_id=o.customer_id AND b.source_looseboard_order_id=o.id AND b.status!='CANCELLED') "
-        + "<if test='keyword != null and keyword != &quot;&quot;'>AND (o.order_no LIKE CONCAT('%',#{keyword},'%') OR o.origin LIKE CONCAT('%',#{keyword},'%') OR o.destination LIKE CONCAT('%',#{keyword},'%'))</if> "
-        + "ORDER BY o.created_at DESC,o.id DESC</script>")
-    Page<LocalLooseboardOrder> pending(Page<LocalLooseboardOrder> page,@Param("keyword") String keyword);
-    /** 原单锁内查询生效匹配，防止跨车次重复接单。 */
-    @Select("SELECT 1 FROM ll_fleet_external_booking WHERE customer_id=#{customer} AND source_looseboard_order_id=#{id} AND status!='CANCELLED' LIMIT 1 FOR UPDATE")
-    Integer active(@Param("customer") String customer,@Param("id") long id);
-    /** 保存预订不可变来源，取消后保留历史。 */
-    @Update("UPDATE ll_fleet_external_booking SET source_looseboard_order_id=#{id} WHERE id=#{booking} AND customer_id=#{customer} AND source_looseboard_order_id IS NULL")
-    int attach(@Param("booking") long booking,@Param("customer") String customer,@Param("id") long id);
-    /** 锁定当前预订对应的同客户原单。 */
-    @Select("SELECT o.* FROM ll_local_looseboard_order o JOIN ll_fleet_external_booking b ON b.source_looseboard_order_id=o.id AND b.customer_id=o.customer_id WHERE b.id=#{booking} AND b.customer_id=#{customer} FOR UPDATE")
-    LocalLooseboardOrder source(@Param("booking") long booking,@Param("customer") String customer);
-    /** 批量读取草稿或取消记录的原单编号。 */
-    @Select("<script>SELECT b.id AS booking_id,o.order_no AS business_order_no FROM ll_fleet_external_booking b JOIN ll_local_looseboard_order o ON o.id=b.source_looseboard_order_id AND o.customer_id=b.customer_id WHERE b.id IN <foreach collection='ids' item='id' open='(' separator=',' close=')'>#{id}</foreach></script>")
-    List<FleetPoolOrderLink> sourceNumbers(@Param("ids") Collection<Long> ids);
-}

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/business/FleetLooseboardDemandRepository.java

@@ -1,28 +0,0 @@
-package com.baiyue.lastleg.fleet.business;
-
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.baiyue.lastleg.looseboard.entity.LocalLooseboardOrder;
-import com.baiyue.lastleg.looseboard.mapper.LocalLooseboardOrderMapper;
-import org.springframework.stereotype.Repository;
-import java.util.Collection;
-import java.util.List;
-
-@Repository
-public class FleetLooseboardDemandRepository {
-    private final FleetLooseboardDemandMapper demands;
-    private final LocalLooseboardOrderMapper orders;
-    /** 注入需求查询和原单仓储。 */
-    public FleetLooseboardDemandRepository(FleetLooseboardDemandMapper demands,LocalLooseboardOrderMapper orders) { this.demands=demands;this.orders=orders; }
-    /** 分页读取待匹配原单。 */
-    public Page<LocalLooseboardOrder> pending(int page,int size,String keyword) { return demands.pending(Page.of(page,size),keyword); }
-    /** 锁定客户原单。 */
-    public LocalLooseboardOrder lock(String customer,String number) { return orders.lockNo(customer,number); }
-    /** 核对生效匹配。 */
-    public boolean active(String customer,long id) { return demands.active(customer,id)!=null; }
-    /** 关联不可变来源。 */
-    public int attach(long booking,String customer,long id) { return demands.attach(booking,customer,id); }
-    /** 锁定匹配来源。 */
-    public LocalLooseboardOrder source(long booking,String customer) { return demands.source(booking,customer); }
-    /** 批量读取原单编号。 */
-    public List<FleetPoolOrderLink> sourceNumbers(Collection<Long> ids) { return demands.sourceNumbers(ids); }
-}

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/business/FleetLooseboardDemandService.java

@@ -1,52 +0,0 @@
-package com.baiyue.lastleg.fleet.business;
-
-import com.baiyue.common.core.api.PageResult;
-import com.baiyue.lastleg.looseboard.entity.LocalLooseboardOrder;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-import org.springframework.web.server.ResponseStatusException;
-import org.springframework.http.HttpStatus;
-import java.util.Objects;
-
-@Service
-public class FleetLooseboardDemandService {
-    private final FleetLooseboardDemandRepository repository;
-    /** 注入原单需求仓储。 */
-    public FleetLooseboardDemandService(FleetLooseboardDemandRepository repository) { this.repository=repository; }
-    /** 已授权平台入口读取待匹配原单。 */
-    @Transactional(readOnly=true)
-    public PageResult<Demand> pending(int page,int size,String keyword) {
-        var rows=repository.pending(page,size,keyword);
-        return new PageResult<>(rows.getRecords().stream().map(Demand::from).toList(),rows.getCurrent(),rows.getSize(),rows.getTotal(),rows.getPages());
-    }
-    public record Demand(String orderNo,String customerId,long version,String origin,String destination,String productName,
-        Integer estimatedPalletCount,Integer packageCount,java.math.BigDecimal totalWeightKg,java.math.BigDecimal totalVolumeCbm,
-        String currency,String originContactName,String originContactPhone,String remark) {
-        /** 仅输出匹配所需资料，不泄露原单幂等键与请求哈希。 */
-        static Demand from(LocalLooseboardOrder o) { return new Demand(o.getOrderNo(),o.getCustomerId(),o.getVersion(),o.getOrigin(),o.getDestination(),o.getProductName(),o.getEstimatedPalletCount(),o.getPackageCount(),o.getTotalWeightKg(),o.getTotalVolumeCbm(),o.getCurrency(),o.getOriginContactName(),o.getOriginContactPhone(),o.getRemark()); }
-    }
-    /** 锁定原单并校验客户、版本与唯一匹配，不预留容量。 */
-    @Transactional(propagation=org.springframework.transaction.annotation.Propagation.MANDATORY)
-    public LocalLooseboardOrder prepare(String customer,String type,String number,Long version) {
-        if(number==null||number.isBlank()) { if(version!=null)throw conflict("来源版本必须与散板原单一起提交"); return null; }
-        if(!"LOCAL_LOOSEBOARD".equals(type))throw conflict("散板原单只能匹配本土散板承运");
-        var order=repository.lock(customer,number);
-        if(order==null||version==null||!Objects.equals(version,order.getVersion()))throw conflict("散板原单不存在或已变化，请刷新待匹配需求");
-        if(!"PENDING_ACCEPTANCE".equals(order.getStatus())||order.getLastlegOrderId()!=null||repository.active(customer,order.getId()))throw conflict("散板原单已有承运或独立履约，请核对原单");
-        return order;
-    }
-    /** 原单锁保持到事务提交，跨车次匹配只允许成功一次。 */
-    @Transactional(propagation=org.springframework.transaction.annotation.Propagation.MANDATORY)
-    public void attach(long booking,LocalLooseboardOrder order) {
-        if(order!=null&&repository.attach(booking,order.getCustomerId(),order.getId())!=1)throw conflict("原单匹配失败，请刷新重试");
-    }
-    /** 匹配后禁止改写业务类型或替换来源，允许省略已有来源参数。 */
-    @Transactional(propagation=org.springframework.transaction.annotation.Propagation.MANDATORY)
-    public void validateEdit(long booking,String customer,String type,String number) {
-        var source=repository.source(booking,customer);
-        if(source!=null&&(!"LOCAL_LOOSEBOARD".equals(type)||number!=null&&!number.equals(source.getOrderNo())))throw conflict("已匹配散板原单不能替换，请取消登记后重新匹配");
-        if(source==null&&number!=null&&!number.isBlank())throw conflict("请从待匹配散板需求创建新的登记");
-    }
-    /** 返回业务冲突。 */
-    private static ResponseStatusException conflict(String message) { return new ResponseStatusException(HttpStatus.CONFLICT,message); }
-}

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/business/FleetPoolOrderBridge.java

@@ -20,7 +20,6 @@ import static com.baiyue.lastleg.fleet.business.FleetPoolOrderModels.*;
 /** Same-database bridge. Never creates inventory, publishes fees, or locks a parent trip. */
 @Service
 public class FleetPoolOrderBridge {
-    @jakarta.annotation.Resource private FleetLooseboardDemandRepository demands;
     private final FleetPoolOrderRepository repository;
     private final com.baiyue.lastleg.service.LastlegDocumentNumberGenerator numbers;
     private final ObjectMapper json;
@@ -48,20 +47,16 @@ public class FleetPoolOrderBridge {
         validate(in);
         String hash=hash(in); var prior=repository.lockBooking(in.bookingId());
         if(prior!=null){if(!hash.equals(prior.getCreationRequestHash()))throw conflict("同一承运来源不能创建不同商业订单");return ref(prior);}
-        var source=demands.source(in.bookingId(),in.customerId());
-        if(source!=null&&(!"LOCAL_LOOSEBOARD".equals(in.businessType())||!"PENDING_ACCEPTANCE".equals(source.getStatus())||source.getLastlegOrderId()!=null))throw conflict("散板原单履约状态已变化");
         var now=LocalDateTime.now();var row=new FleetPoolOrderLink();
         row.setId(IdWorker.getId());row.setBookingId(in.bookingId());row.setBookingNo(in.bookingNo());
-        row.setCustomerId(in.customerId());row.setBusinessType(in.businessType());row.setBusinessOrderId(source==null?IdWorker.getId():source.getId());
-        row.setBusinessOrderNo(source==null?numbers.next("US_TRUCK".equals(in.businessType())?"TR":"LB"):source.getOrderNo());
+        row.setCustomerId(in.customerId());row.setBusinessType(in.businessType());row.setBusinessOrderId(IdWorker.getId());
+        row.setBusinessOrderNo(numbers.next("US_TRUCK".equals(in.businessType())?"TR":"LB"));
         row.setWarehouseId(in.warehouseId());row.setDestinationKey(in.destinationKey());
         row.setDeliveryMode(in.deliveryMode());row.setDeliveryInstructions(in.deliveryInstructions());
         row.setFulfillmentStage("WAITING_INBOUND");row.setStageOccurredAt(now);row.setRecordVersion(0L);
         row.setCreationRequestHash(hash);row.setCreatedBy(operator);row.setCreatedAt(now);row.setUpdatedAt(now);
         String transport=in.destinationKey().startsWith("FBA:")?"WAREHOUSE_TO_WAREHOUSE":"WAREHOUSE_TO_DOOR";
-        if(source!=null) {
-            source.setStatus("WAITING_INBOUND");source.setVersion(source.getVersion()+1);source.setUpdatedAt(now);repository.updateLoose(source);
-        } else if("LOCAL_LOOSEBOARD".equals(in.businessType())) {
+        if("LOCAL_LOOSEBOARD".equals(in.businessType())) {
             var order=new LocalLooseboardOrder();order.setId(row.getBusinessOrderId());order.setCustomerId(in.customerId());order.setOrderNo(row.getBusinessOrderNo());
             order.setTransportType(transport);
             // 货名与预计托数沿真实询价保存；不从数量推断打盘服务，也不预设取送时间。
@@ -84,7 +79,7 @@ public class FleetPoolOrderBridge {
             order.setRequestHash(hash);order.setCreatedBy(operator);order.setVersion(0L);order.setCreatedAt(now);order.setUpdatedAt(now);
             repository.insertTruck(order); // No simulated ll_us_truck_order_pallet rows.
         }
-        repository.insertLink(row);history(row,source==null?null:"PENDING_ACCEPTANCE",row.getFulfillmentStage(),operator,source==null?"确认承运并建立商业委托":"原单匹配车次并确认承运",now);
+        repository.insertLink(row);history(row,null,row.getFulfillmentStage(),operator,"确认承运并建立商业委托",now);
         return ref(row);
     }
     /** 锁定预订并关联唯一真实来货，不创建第二份实物来源。 */
@@ -182,7 +177,6 @@ public class FleetPoolOrderBridge {
     /** 批量读取预订的业务编号。 */
     public Map<Long,String> businessOrderNumbers(Collection<Long> ids) {
         if(ids==null||ids.isEmpty())return Map.of();var result=new HashMap<Long,String>();
-        demands.sourceNumbers(ids).forEach(row->result.put(row.getBookingId(),row.getBusinessOrderNo()));
         repository.bookings(ids).forEach(row->result.put(row.getBookingId(),row.getBusinessOrderNo()));return result;
     }
     static void validate(ConfirmedBooking in) {

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/business/FleetPoolOrderMapper.java

@@ -38,9 +38,7 @@ public interface FleetPoolOrderMapper extends BaseMapper<FleetPoolOrderLink> {
     FleetPoolOrderLink lockIncoming(@Param("customerId") String customerId,@Param("no") String no);
     @Select("SELECT * FROM ll_fleet_pool_order_link WHERE customer_id=#{customerId} AND dispatch_no=#{no} ORDER BY id FOR UPDATE")
     List<FleetPoolOrderLink> lockDispatch(@Param("customerId") String customerId,@Param("no") String no);
-    /** 原单锁内使用当前读，避免等待匹配提交后仍按旧快照放行独立修改。 */
-    @Select("SELECT COALESCE((SELECT 1 FROM ll_fleet_pool_order_link WHERE customer_id=#{customerId} AND business_type=#{type} AND business_order_id=#{id} LIMIT 1 FOR UPDATE),0) + "
-        + "COALESCE((SELECT 1 FROM ll_fleet_external_booking WHERE customer_id=#{customerId} AND #{type}='LOCAL_LOOSEBOARD' AND source_looseboard_order_id=#{id} AND status!='CANCELLED' LIMIT 1 FOR UPDATE),0)")
+    @Select("SELECT COUNT(*) FROM ll_fleet_pool_order_link WHERE customer_id=#{customerId} AND business_type=#{type} AND business_order_id=#{id}")
     int linked(@Param("customerId") String customerId,@Param("type") String type,@Param("id") long id);
     @Select("SELECT COUNT(*) FROM ll_fleet_pool_order_link WHERE customer_id=#{customerId} AND incoming_no=#{no}")
     int linkedIncoming(@Param("customerId") String customerId,@Param("no") String no);

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/trip/FleetCapacityOfferModels.java

@@ -36,16 +36,7 @@ public final class FleetCapacityOfferModels {
         @NotBlank @Pattern(regexp="SELF_DELIVERY|MANUAL_PICKUP_TO_WAREHOUSE") String deliveryMode,
         Instant estimatedArrivalAt,@Min(1) Integer expectedPalletCount,
         @NotNull @Valid FleetBookingModels.Cargo cargo,@Valid FleetQuoteCandidateModels.QuoteRef quoteRef,
-        @NotBlank @Size(min=8,max=128) String idempotencyKey,
-        @Size(max=64) String sourceOrderNo,@Min(0) Long sourceOrderVersion) {
-        /** 保留无原单人工登记的构造方式。 */
-        public InquiryWrite(Long tripRecordVersion,Long offerRecordVersion,Long recordVersion,Long customerId,
-            String businessType,String deliveryMode,Instant estimatedArrivalAt,Integer expectedPalletCount,
-            FleetBookingModels.Cargo cargo,FleetQuoteCandidateModels.QuoteRef quoteRef,String idempotencyKey) {
-            this(tripRecordVersion,offerRecordVersion,recordVersion,customerId,businessType,deliveryMode,
-                estimatedArrivalAt,expectedPalletCount,cargo,quoteRef,idempotencyKey,null,null);
-        }
-    }
+        @NotBlank @Size(min=8,max=128) String idempotencyKey) { }
     public record InquiryCommand(@NotNull @Min(0) Long tripRecordVersion,@NotNull @Min(0) Long offerRecordVersion,
         @NotNull @Min(0) Long recordVersion,@NotBlank @Size(min=8,max=128) String idempotencyKey,
         @Size(max=1000) String reason) { }

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/trip/FleetCapacityOfferService.java

@@ -26,8 +26,6 @@ import java.util.*;
 @Service
 public class FleetCapacityOfferService {
     @jakarta.annotation.Resource private com.baiyue.lastleg.service.LastlegDocumentNumberGenerator documentNumbers;
-
-    @jakarta.annotation.Resource private com.baiyue.lastleg.fleet.business.FleetLooseboardDemandService demands;
     public static final String LIST="platform:fleet:capacity-offer:list", MANAGE="platform:fleet:capacity-offer:manage";
     private final FleetCapacityOfferMapper offers;
     private final FleetCapacityOfferCommandMapper commands;
@@ -53,11 +51,6 @@ public class FleetCapacityOfferService {
         this.offers=offers;this.commands=commands;this.trips=trips;this.bookings=bookings;this.bookingService=bookingService;
         this.reservations=reservations;this.execution=execution;this.customers=customers;this.orders=orders;this.json=json;this.clock=clock;
     }
-    /** 平台需求池分页读取客户已下的散板原单。 */
-    @Transactional(readOnly=true)
-    public PageResult<com.baiyue.lastleg.fleet.business.FleetLooseboardDemandService.Demand> pendingDemands(FleetCapacityOfferModels.InquiryQuery query) {
-        writePermission("inquiry-create");return demands.pending(query.page(),query.size(),query.keyword());
-    }
     @Transactional(readOnly=true,isolation=Isolation.REPEATABLE_READ)
     public PageResult<FleetCapacityOfferModels.Offer> page(FleetCapacityOfferModels.Query query){
         readPermission();
@@ -180,20 +173,17 @@ public class FleetCapacityOfferService {
         touch(row);var result=new FleetCapacityOfferModels.OfferResult(project(row,trip),false);
         saveCommand(trip,action,number,request.idempotencyKey(),request,result);return result;
     }
-    /** 同一事务登记意向及原单来源，确认前不占位。 */
     @Transactional
     public FleetCapacityOfferModels.InquiryResult createInquiry(String number,FleetCapacityOfferModels.InquiryWrite request){
         writePermission("inquiry-create");var initial=offer(number,false);var trip=trip(initial.getTripNo(),true);var row=offer(number,true);
         var replay=replay(trip,"INQUIRY_CREATE",number,request.idempotencyKey(),request,FleetCapacityOfferModels.InquiryResult.class);
         if(replay!=null)return replayed(replay);
         versions(trip,row,request.tripRecordVersion(),request.offerRecordVersion());requireInquiryOpen(row,trip);validateInquiry(trip,request);
-        var source=demands.prepare(request.customerId().toString(),request.businessType(),request.sourceOrderNo(),request.sourceOrderVersion());
         var created=bookingService.create(trip.getTripNo(),operator(),new FleetBookingModels.Create(trip.getRecordVersion(),request.customerId(),request.cargo(),"POOL:"+hash(Arrays.asList(number,request.idempotencyKey())),request.quoteRef()));
         if(created.replayed())throw conflict("意向创建记录不完整，请保留原请求联系调度核对");
         var booking=bookings.lock(trip.getId(),created.booking().bookingNo());booking.setOfferId(row.getId());booking.setSalesOwnerUserId(operator());apply(booking,request);
-        bookings.updateById(booking);demands.attach(booking.getId(),source);var result=inquiryResult(row,booking);saveCommand(trip,"INQUIRY_CREATE",number,request.idempotencyKey(),request,result);return result;
+        bookings.updateById(booking);var result=inquiryResult(row,booking);saveCommand(trip,"INQUIRY_CREATE",number,request.idempotencyKey(),request,result);return result;
     }
-    /** 编辑登记资料时保持客户及原单来源不可变。 */
     @Transactional
     public FleetCapacityOfferModels.InquiryResult updateInquiry(String number,FleetCapacityOfferModels.InquiryWrite request){
         writePermission("inquiry-edit");var initial=inquiryRow(number);own(initial);var trip=trip(initial.getTripNo(),true);var row=offers.lock(offers.selectById(initial.getOfferId()).getOfferNo());
@@ -201,7 +191,6 @@ public class FleetCapacityOfferService {
         var replay=replay(trip,"INQUIRY_EDIT",number,request.idempotencyKey(),request,FleetCapacityOfferModels.InquiryResult.class);if(replay!=null)return replayed(replay);
         versions(trip,row,request.tripRecordVersion(),request.offerRecordVersion());requireInquiryOpen(row,trip);validateInquiry(trip,request);
         if(!Objects.equals(booking.getCustomerId(),request.customerId().toString()))throw conflict("意向客户不能改写，请取消草稿后重新登记");
-        demands.validateEdit(booking.getId(),booking.getCustomerId(),request.businessType(),request.sourceOrderNo());
         if(request.recordVersion()==null)throw bad("缺少意向版本");
         bookingService.updatePool(trip.getTripNo(),number,operator(),new FleetBookingModels.Update(trip.getRecordVersion(),request.recordVersion(),request.cargo(),request.quoteRef()));
         booking=bookings.lock(trip.getId(),number);apply(booking,request);bookings.updateById(booking);

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/trip/FleetTransportVehicleGuard.java

@@ -1,20 +0,0 @@
-package com.baiyue.lastleg.fleet.trip;
-
-import com.baiyue.lastleg.masterdata.vehicle.application.port.out.VehicleRepository;
-import org.springframework.stereotype.Service;
-import org.springframework.http.HttpStatus;
-import org.springframework.web.server.ResponseStatusException;
-
-/** 运输执行仍由车队应用边界核对车辆主档，不向排车暴露车辆持久化。 */
-@Service
-public class FleetTransportVehicleGuard {
-    private final VehicleRepository vehicles;
-    /** 复用车辆应用端口及其行锁。 */
-    public FleetTransportVehicleGuard(VehicleRepository vehicles){this.vehicles=vehicles;}
-    /** 发车核对实时车辆资格，并冻结当次有效容量供业务量复核。 */
-    public void validate(FleetTripEntity trip){
-        var vehicle=vehicles.lockById(trip.getVehicleId()).orElseThrow(()->new ResponseStatusException(HttpStatus.CONFLICT,"车辆不存在"));
-        if(!"OVERSEAS".equals(vehicle.region()) || !"IN_SERVICE".equals(vehicle.status()))throw new ResponseStatusException(HttpStatus.CONFLICT,"当前车辆不可出车");
-        trip.setMaxPalletSpaces(vehicle.maxPalletSpaces());trip.setMaxLoadKg(vehicle.maxLoadKg());trip.setMaxVolumeCbm(vehicle.maxVolumeCbm());
-    }
-}

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/trip/FleetTripCalendarRepository.java

@@ -1,27 +0,0 @@
-package com.baiyue.lastleg.fleet.trip;
-
-import java.time.LocalDateTime;
-import java.util.List;
-import org.springframework.stereotype.Repository;
-
-/** 日历只读访问保留真实主单范围，整批读取原货物快照而不逐车查询。 */
-@Repository
-public class FleetTripCalendarRepository {
-    public record Source(String dispatchNo, String sourceSnapshotJson) { }
-    private final FleetTripMapper mapper;
-
-    /** 装配现有车次Mapper，日历服务不直接访问SQL。 */
-    public FleetTripCalendarRepository(FleetTripMapper mapper) { this.mapper = mapper; }
-
-    /** 按真实UTC时间窗口读取有唯一整车主单的运输记录。 */
-    public List<FleetTripCalendarRow> calendar(LocalDateTime from, LocalDateTime to) {
-        return mapper.calendar(from, to);
-    }
-
-    /** 一次读取指定主单的全部货物快照，空窗口不发送空IN查询。 */
-    public List<Source> sourceSnapshots(List<String> dispatchNumbers) {
-        if (dispatchNumbers.isEmpty()) return List.of();
-        return mapper.calendarSources(dispatchNumbers).stream()
-            .map(row -> new Source(row.dispatchNo(), row.sourceSnapshotJson())).toList();
-    }
-}

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/trip/FleetTripCalendarService.java

@@ -6,7 +6,6 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Isolation;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.server.ResponseStatusException;
 import java.time.*;
@@ -19,29 +18,27 @@ public class FleetTripCalendarService {
         String originWarehouseCode, String originWarehouseName, String originCountryCode,
         String originTimezone, String originWarehouseStatus, Instant plannedDepartureAt,
         Instant expectedDriverEndAt, Instant departedAt, Instant completedAt,
-        List<FleetTripModels.Stop> stops, List<String> containerNumbers, List<String> incompleteReasons) { }
+        List<FleetTripModels.Stop> stops, List<String> incompleteReasons) { }
     public record Result(List<Entry> records, List<Entry> unresolvedRecords) { }
     private static final Set<String> COUNTRIES = Set.of(Locale.getISOCountries());
-    private final FleetTripCalendarRepository trips;
+    private final FleetTripMapper trips;
     private final FleetWarehouseClient warehouses;
     private final ObjectMapper json;
     private final String token;
 
-    /** 装配日历持久化入口与真实仓库元数据提供者。 */
-    public FleetTripCalendarService(FleetTripCalendarRepository trips, FleetWarehouseClient warehouses, ObjectMapper json,
+    public FleetTripCalendarService(FleetTripMapper trips, FleetWarehouseClient warehouses, ObjectMapper json,
         @Value("${baiyue.security.internal-service-token:}") String token) {
         this.trips=trips; this.warehouses=warehouses; this.json=json; this.token=token;
     }
 
-    /** 同一快照批读真实主单和货物，仓库资料只查询一次，保留原业务地点时区。 */
-    @Transactional(readOnly=true,isolation=Isolation.REPEATABLE_READ)
+    /** 一次读取真实排车及一次仓库资料查询，按业务地点判定日历归属。 */
+    @Transactional(readOnly=true)
     public Result calendar(Instant from, Instant to) {
         if (from==null || to==null || !to.isAfter(from) || Duration.between(from,to).compareTo(Duration.ofDays(44))>0)
             throw new ResponseStatusException(HttpStatus.BAD_REQUEST,"查询须为不超过44天的UTC时间范围");
         var rows=trips.calendar(LocalDateTime.ofInstant(from,ZoneOffset.UTC),LocalDateTime.ofInstant(to,ZoneOffset.UTC));
         if (rows.size()>2000) throw new ResponseStatusException(HttpStatus.BAD_REQUEST,"排车过多，请缩小查询日期范围");
         if (rows.isEmpty()) return new Result(List.of(),List.of());
-        var containers=containerNumbers(rows);
         var ids=rows.stream().map(FleetTripEntity::getWarehouseId).filter(Objects::nonNull).filter(id->id>0).distinct().sorted().toList();
         var metadata=metadata(ids);
         var records=new ArrayList<Entry>(); var unresolved=new ArrayList<Entry>();
@@ -67,35 +64,12 @@ public class FleetTripCalendarService {
             var entry=new Entry("DISPATCH",row.getDispatchNo(),row.getStatus(),row.getWarehouseId()==null?null:row.getWarehouseId().toString(),
                 warehouse==null?row.getWarehouseCode():warehouse.warehouseCode(),warehouse==null?row.getWarehouseName():warehouse.warehouseName(),
                 country,zone,warehouse==null?null:warehouse.status(),instant(row.getPlannedDepartureAt()),instant(row.getExpectedDriverEndAt()),
-                instant(row.getDepartedAt()),instant(row.getCompletedAt()),stops,containers.getOrDefault(row.getDispatchNo(),List.of()),List.copyOf(reasons));
+                instant(row.getDepartedAt()),instant(row.getCompletedAt()),stops,List.copyOf(reasons));
             (unresolvedOrigin?unresolved:records).add(entry);
         }
         return new Result(List.copyOf(records),List.copyOf(unresolved));
     }
 
-    /** 柜号只取排车建单时正式保存的SourceDisplay.containerNo，不反查或推测其他来源。 */
-    private Map<String,List<String>> containerNumbers(List<FleetTripCalendarRow> rows) {
-        var numbers=rows.stream().map(FleetTripCalendarRow::getDispatchNo).distinct().sorted().toList();
-        var requested=new HashSet<>(numbers);var grouped=new LinkedHashMap<String,LinkedHashSet<String>>();
-        for(var source:trips.sourceSnapshots(numbers)) {
-            if(source==null || !requested.contains(source.dispatchNo()) || source.sourceSnapshotJson()==null || source.sourceSnapshotJson().isBlank())
-                throw sourceUnavailable();
-            try {
-                var snapshot=json.reader().with(com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_TRAILING_TOKENS)
-                    .readTree(source.sourceSnapshotJson());
-                if(snapshot==null || !snapshot.isObject())throw sourceUnavailable();
-                var value=snapshot.get("containerNo");
-                if(value==null || value.isNull())continue;
-                if(!value.isTextual())throw sourceUnavailable();
-                var number=value.textValue().strip();
-                if(!number.isEmpty())grouped.computeIfAbsent(source.dispatchNo(),ignored->new LinkedHashSet<>()).add(number);
-            } catch(com.fasterxml.jackson.core.JsonProcessingException invalid) { throw sourceUnavailable(); }
-        }
-        var result=new LinkedHashMap<String,List<String>>();
-        grouped.forEach((number,values)->result.put(number,List.copyOf(values)));return Map.copyOf(result);
-    }
-
-    /** 元数据批次必须完整覆盖请求身份，未知地点保持显式未核实。 */
     private Map<Long,FleetWarehouseClient.Metadata> metadata(List<Long> ids) {
         if (ids.isEmpty()) return Map.of();
         try {
@@ -111,10 +85,6 @@ public class FleetTripCalendarService {
             return result;
         } catch (RuntimeException failure) { throw unavailable(); }
     }
-    /** 持久UTC时间只转换为UTC瞬时，不套用浏览器日期。 */
     private static Instant instant(LocalDateTime value) { return value==null?null:value.toInstant(ZoneOffset.UTC); }
-    /** 仓库服务失败明确报错，不能把未知时区伪装成完整空日历。 */
     private static ResponseStatusException unavailable() { return new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE,"仓库时区资料暂不可用，请重试"); }
-    /** 损坏货物快照保留明确错误，不静默丢弃真实排车或柜号。 */
-    private static ResponseStatusException sourceUnavailable() { return new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE,"排车货物柜号资料暂不可用，请重试"); }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/trip/FleetTripExecutionService.java

@@ -276,7 +276,7 @@ public class FleetTripExecutionService {
     }
     /** 出库装载只能用于派送车次，取货必须沿专用运输链执行。 */
     private static void requireVersionAndPlan(FleetTripEntity trip, long version) {
-        if (java.util.Set.of("PICKUP","LOCAL_TRUCK").contains(java.util.Objects.toString(trip.getTripPurpose(),""))) throw conflict("运输排车请使用对应运输任务操作");
+        if ("PICKUP".equals(trip.getTripPurpose())) throw conflict("取货车次请使用取货任务操作");
         if (trip.getRecordVersion() != version) throw conflict("车次已被修改，请刷新后重新确认");
         if (!"PLANNED".equals(trip.getStatus())) throw conflict("仅计划中的车次允许此操作");
     }

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/trip/FleetTripMapper.java

@@ -19,18 +19,6 @@ public interface FleetTripMapper extends BaseMapper<FleetTripEntity> {
         ORDER BY COALESCE(t.departed_at,t.planned_departure_at),d.dispatch_no LIMIT 2001
         """)
     java.util.List<FleetTripCalendarRow> calendar(@Param("from") java.time.LocalDateTime from,@Param("to") java.time.LocalDateTime to);
-    record CalendarSource(String dispatchNo, String sourceSnapshotJson) { }
-    /** 主查询限额之后批量读取原货物快照，不以货物JOIN放大整车记录或截断多柜。 */
-    @Select("""
-        <script>
-        SELECT d.dispatch_no AS dispatchNo,i.source_snapshot_json AS sourceSnapshotJson
-        FROM ll_dispatch_order d JOIN ll_dispatch_item i ON i.dispatch_order_id=d.id
-        WHERE d.status='ACTIVE' AND d.dispatch_no IN
-          <foreach collection='numbers' item='number' open='(' separator=',' close=')'>#{number}</foreach>
-        ORDER BY d.dispatch_no,i.id
-        </script>
-        """)
-    java.util.List<CalendarSource> calendarSources(@Param("numbers") java.util.List<String> dispatchNumbers);
     @Select("SELECT * FROM ll_fleet_trip WHERE trip_no=#{tripNo} FOR UPDATE")
     FleetTripEntity lockByNo(@Param("tripNo") String tripNo);
     @Select("SELECT * FROM ll_fleet_trip WHERE trip_no=#{tripNo}")

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/trip/FleetTripService.java

@@ -28,8 +28,6 @@ import java.util.*;
 @Service
 public class FleetTripService {
     @jakarta.annotation.Resource private com.baiyue.lastleg.service.LastlegDocumentNumberGenerator documentNumbers;
-
-    @org.springframework.beans.factory.annotation.Autowired(required=false) private org.springframework.context.ApplicationEventPublisher transportEvents;
     @jakarta.annotation.Resource private com.baiyue.lastleg.fleet.trip.work.AppointmentWorkTripChanges workChanges;
     @jakarta.annotation.Resource private com.baiyue.lastleg.appointmentwork.AppointmentWorkDispatchPort appointmentAllocations;
     private final FleetTripRepository repository;
@@ -104,12 +102,6 @@ public class FleetTripService {
         return createPlan(operator, request, "PICKUP");
     }
 
-    /** 本土卡车运输使用同一资源占用与司机资格规则。 */
-    @Transactional
-    public FleetTripModels.Detail createLocalTruck(String operator, FleetTripModels.Create request) {
-        return createPlan(operator, request, "LOCAL_TRUCK");
-    }
-
     /** 主单创建事务内建立空资源记录，允许未知计划/临时资料，审核时再核齐。 */
     @Transactional(propagation = org.springframework.transaction.annotation.Propagation.MANDATORY)
     public FleetExecutionModels.DispatchShell createDispatchShell(String operator, FleetExecutionModels.DispatchShellRequest request) {
@@ -385,7 +377,7 @@ public class FleetTripService {
 
     /** 两类车次共用建档逻辑，幂等摘要包含用途以防串用。 */
     private FleetTripModels.Detail createPlan(String operator, FleetTripModels.Create request, String purpose) {
-        String hash = hash(("DELIVERY".equals(purpose) ? "" : purpose+":") + write(request));
+        String hash = hash(("PICKUP".equals(purpose) ? "PICKUP:" : "") + write(request));
         var existing = repository.findCreated(operator, request.idempotencyKey());
         if (existing != null) return replay(existing, hash);
         validatePlan(request.plannedDepartureAt(), request.expectedDriverEndAt(), request.stops());
@@ -456,7 +448,7 @@ public class FleetTripService {
         bookingReservations.requireRoute(trip, request.stops());
         if (trip.getDriverId() != null) drivers.requireDispatchable(trip.getDriverId(), request.expectedDriverEndAt());
         boolean unchangedRoute = response(trip).stops().equals(request.stops());
-        if (Set.of("PICKUP","LOCAL_TRUCK").contains(Objects.toString(trip.getTripPurpose(),"")) && !unchangedRoute) throw conflict("运输路线由原单确定，不能修改来源地址");
+        if ("PICKUP".equals(trip.getTripPurpose()) && !unchangedRoute) throw conflict("取货路线由原单地址和入仓仓库确定，不能修改为出库路线");
         boolean unchangedPlan = unchangedRoute && trip.getPlannedDepartureAt().equals(utc(request.plannedDepartureAt()))
             && trip.getExpectedDriverEndAt().equals(utc(request.expectedDriverEndAt()));
         trip.setPlannedDepartureAt(utc(request.plannedDepartureAt())); trip.setExpectedDriverEndAt(utc(request.expectedDriverEndAt()));
@@ -652,7 +644,6 @@ public class FleetTripService {
     }
     /** 为当前版本保存操作人、原因和完整车次历史。 */
     private void record(FleetTripEntity trip, String action, String reason, String operator) {
-        if(transportEvents!=null)transportEvents.publishEvent(new TransportTripChanged(trip,action,reason,operator));
         workChanges.changed(trip);
         var event = new FleetTripHistory(); event.setId(IdWorker.getId()); event.setTripId(trip.getId()); event.setRecordVersion(trip.getRecordVersion());
         event.setAction(action); event.setReason(trim(reason)); event.setOperatorId(operator); event.setOccurredAt(trip.getUpdatedAt());

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/trip/PlatformFleetCapacityOfferController.java

@@ -29,9 +29,6 @@ public class PlatformFleetCapacityOfferController {
     public ApiResponse<FleetCapacityOfferModels.OfferResult> resume(@PathVariable String offerNo,@Valid @RequestBody FleetCapacityOfferModels.Command request){return ApiResponse.success(service.command(offerNo,"RESUME",request));}
     @PostMapping("/{offerNo}/close") @PreAuthorize("hasAuthority('platform:fleet:capacity-offer:manage')")
     public ApiResponse<FleetCapacityOfferModels.OfferResult> close(@PathVariable String offerNo,@Valid @RequestBody FleetCapacityOfferModels.Command request){return ApiResponse.success(service.command(offerNo,"CLOSE",request));}
-    /** 读取客户已提交、等待车次匹配的散板原单。 */
-    @GetMapping("/pending-looseboard-demands") @PreAuthorize("hasAuthority('platform:fleet:capacity-offer:manage') or (hasAuthority('platform:fleet:capacity-offer:list') and hasAuthority('platform:fleet:capacity-offer:inquiry-create'))")
-    public ApiResponse<PageResult<com.baiyue.lastleg.fleet.business.FleetLooseboardDemandService.Demand>> pendingDemands(@Valid FleetCapacityOfferModels.InquiryQuery query){return ApiResponse.success(service.pendingDemands(query));}
     @GetMapping("/inquiries") @PreAuthorize("hasAnyAuthority('platform:fleet:capacity-offer:list','platform:fleet:capacity-offer:manage')")
     public ApiResponse<PageResult<FleetCapacityOfferModels.Inquiry>> inquiries(@Valid FleetCapacityOfferModels.InquiryQuery query){return ApiResponse.success(service.inquiries(query));}
     @GetMapping("/inquiries/{bookingNo}") @PreAuthorize("hasAnyAuthority('platform:fleet:capacity-offer:list','platform:fleet:capacity-offer:manage')")

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/trip/TransportTripChanged.java

@@ -1,5 +0,0 @@
-package com.baiyue.lastleg.fleet.trip;
-
-
-/** 同步事务内的运输事实；任一投影失败时原执行一起回滚。 */
-public record TransportTripChanged(FleetTripEntity trip,String action,String reason,String operator) { }

lastleg-service/src/main/java/com/baiyue/lastleg/looseboard/service/LocalLooseboardService.java

@@ -51,7 +51,7 @@ public class LocalLooseboardService {
     @Resource private LastlegOrderNoGenerator lastlegOrderNoGenerator;
     @Resource private ObjectMapper objectMapper;
 
-    /** 在同一事务保存客户需求及创建历史，等待需求池匹配后登记真实来货，创建键重复时核对请求哈希。 */
+    /** 在同一事务保存客户需求、唯一尾程来源及创建历史，创建键重复时核对请求哈希。 */
     @Transactional
     public LocalLooseboardResponses.Detail create(String customerId, String operatorId,
                                                    LocalLooseboardRequests.Create request) {
@@ -75,7 +75,8 @@ public class LocalLooseboardService {
         order.setVersion(0L);
         order.setCreatedAt(now);
         order.setUpdatedAt(now);
-        // 下单只保存池内需求，实际收货时再创建唯一实物尾程单。
+        LastlegOrder lastlegOrder = createLastlegOrder(order, requestHash, now);
+        order.setLastlegOrderId(lastlegOrder.getId());
         try {
             repository.insertOrder(order);
         } catch (DuplicateKeyException exception) {
@@ -85,7 +86,8 @@ public class LocalLooseboardService {
         }
         history(order, "CREATE", null, PENDING_ACCEPTANCE, operatorId,
             key, null, request.remark(), now);
-
+        lastlegHistory(customerId, lastlegOrder.getId(), null, lastlegOrder.getCurrentStatus(),
+            "Local looseboard order submitted", now);
         return detail(customerId, order.getOrderNo());
     }
 
@@ -156,7 +158,6 @@ public class LocalLooseboardService {
         }
         if (!request.version().equals(value(order.getVersion()))) throw conflict("Order was changed; refresh and retry");
         String next = norm(request.status());
-        if (order.getLastlegOrderId() == null && !CANCELLED.equals(next)) throw conflict("请从散板需求池匹配车次，沿实际收货、排车和签收推进");
         if (!STATUSES.contains(next)) throw badRequest("Unsupported looseboard order status");
         String from = order.getStatus();
         if (next.equals(from)) return response(order);

lastleg-service/src/main/java/com/baiyue/lastleg/mapper/CustomerOrderProgressMapper.java

@@ -4,23 +4,62 @@ import com.baiyue.lastleg.dto.CustomerOrderProgress;
 import org.apache.ibatis.annotations.*;
 import java.util.List;
 
-/** 按客户及不可变来源明细读取进度，不使用混托的代表订单。 */
+/** Batch read of every actual source, never the representative MIN(order_id) on a shared pallet. */
 @Mapper
 public interface CustomerOrderProgressMapper {
-    /** 已排车只统计有效待出库单的来源数量，与平台出库单节点一致；在途仍要求实际发车。 */
+    /** 本客户明细决定归属，真实主阶段和实际发车时间决定待排及在途数量。 */
     @Select("""
         <script>
         WITH scheduled AS (
-          SELECT i.source_order_id AS order_id,SUM(i.package_count) AS packages
-          FROM ll_outbound_order b
-          JOIN ll_outbound_pallet_item i ON i.outbound_order_id=b.id AND i.customer_id=b.customer_id
+          SELECT line.order_id,SUM(a.planned_package_count) AS packages
+          FROM ll_dispatch_order d
+          JOIN ll_dispatch_item i ON i.dispatch_order_id=d.id
+          JOIN ll_inbound_plan_pallet_allocation a ON a.pallet_id=i.plan_pallet_id
+          JOIN ll_inbound_plan_line line ON line.id=a.line_id AND line.customer_id=i.customer_id
           <if test="orderIds != null">
-          JOIN ll_order outbound_source ON outbound_source.id=i.source_order_id AND outbound_source.customer_id=#{customerId}
-            AND outbound_source.source_order_id IN <foreach collection="orderIds" item="id" open="(" separator="," close=")">#{id}</foreach>
+          JOIN ll_order planned_source ON planned_source.id=line.order_id AND planned_source.customer_id=#{customerId}
+            AND planned_source.source_order_id IN <foreach collection="orderIds" item="id" open="(" separator="," close=")">#{id}</foreach>
           </if>
-          WHERE i.customer_id=#{customerId}
-            AND b.status NOT IN ('CANCELLED','CANCELED','OUTBOUNDED')
-          GROUP BY i.source_order_id
+          WHERE i.customer_id=#{customerId} AND d.status='ACTIVE'
+            AND d.stage IN ('BEFORE_LOADING','LOADING','AFTER_LOADING')
+            AND i.warehouse_pallet_id IS NULL
+          GROUP BY line.order_id
+          UNION ALL
+          SELECT b.inbound_order_id AS order_id,SUM(p.available_packages+COALESCE(pk.packages,0)) AS packages
+          FROM ll_dispatch_order d
+          JOIN ll_dispatch_item i ON i.dispatch_order_id=d.id
+          JOIN ll_inventory_position p ON p.customer_id=i.customer_id AND p.pallet_id=i.warehouse_pallet_id
+            AND p.overseas_warehouse_id=i.overseas_warehouse_id
+          JOIN ll_inventory_balance b ON b.id=p.balance_id AND b.customer_id=i.customer_id
+          <if test="orderIds != null">
+          JOIN ll_order stock_source ON stock_source.id=b.inbound_order_id AND stock_source.customer_id=#{customerId}
+            AND stock_source.source_order_id IN <foreach collection="orderIds" item="id" open="(" separator="," close=")">#{id}</foreach>
+          </if>
+          LEFT JOIN (SELECT pick.dispatch_item_id,pick.inventory_position_id,SUM(pick.packages) AS packages
+            FROM ll_dispatch_pda_pick pick
+            <if test="orderIds != null">
+            JOIN ll_inventory_position scoped_position ON scoped_position.id=pick.inventory_position_id
+              AND scoped_position.customer_id=pick.customer_id
+            JOIN ll_inventory_balance scoped_balance ON scoped_balance.id=scoped_position.balance_id
+              AND scoped_balance.customer_id=pick.customer_id
+            JOIN ll_order scoped_order ON scoped_order.id=scoped_balance.inbound_order_id
+              AND scoped_order.customer_id=pick.customer_id
+              AND scoped_order.source_order_id IN <foreach collection="orderIds" item="id" open="(" separator="," close=")">#{id}</foreach>
+            </if>
+            WHERE pick.customer_id=#{customerId}
+            GROUP BY pick.dispatch_item_id,pick.inventory_position_id) pk
+            ON pk.dispatch_item_id=i.id AND pk.inventory_position_id=p.id
+          WHERE i.customer_id=#{customerId} AND d.status='ACTIVE'
+            AND d.stage IN ('BEFORE_LOADING','LOADING','AFTER_LOADING')
+            AND (i.plan_pallet_id IS NULL OR EXISTS (
+              SELECT 1 FROM ll_inbound_plan_pallet_allocation a
+              JOIN ll_inbound_plan_line line ON line.id=a.line_id AND line.customer_id=i.customer_id
+          <if test="orderIds != null">
+          JOIN ll_order planned_source ON planned_source.id=line.order_id AND planned_source.customer_id=#{customerId}
+            AND planned_source.source_order_id IN <foreach collection="orderIds" item="id" open="(" separator="," close=")">#{id}</foreach>
+          </if>
+              WHERE a.pallet_id=i.plan_pallet_id AND line.order_id=b.inbound_order_id))
+          GROUP BY b.inbound_order_id
         ), departed AS (
           SELECT a.order_id,SUM(a.packages) AS packages
           FROM ll_dispatch_pda_pick_order a

lastleg-service/src/main/java/com/baiyue/lastleg/trucking/mapper/UsTruckOrderMapper.java

@@ -8,9 +8,6 @@ import org.apache.ibatis.annotations.Select;
 
 @Mapper
 public interface UsTruckOrderMapper extends BaseMapper<UsTruckOrder> {
-    /** 原单被有效排车接管后，禁止独立改状态绕过运输事实。 */
-    @Select("SELECT COUNT(*) FROM ll_dispatch_truck_task WHERE customer_id=#{customer} AND order_no=#{number} AND active_order IS NOT NULL")
-    long activeDispatch(@Param("customer") String customer,@Param("number") String number);
     @Select("SELECT * FROM ll_us_truck_order WHERE customer_id=#{customerId} AND order_no=#{orderNo} LIMIT 1")
     UsTruckOrder findNo(@Param("customerId") String customerId, @Param("orderNo") String orderNo);
 

lastleg-service/src/main/java/com/baiyue/lastleg/trucking/repository/UsTruckOrderRepository.java

@@ -44,8 +44,6 @@ public class UsTruckOrderRepository {
     public UsTruckOrder findNo(String customerId, String orderNo) { return orders.findNo(customerId, orderNo); }
     /** 在当前事务中按客户和订单号加行锁。 */
     public UsTruckOrder lockNo(String customerId, String orderNo) { return orders.lockNo(customerId, orderNo); }
-    /** 有效运输任务持有原单的执行权。 */
-    public boolean hasActiveDispatch(String customer,String number) { return orders.activeDispatch(customer,number)>0; }
     /** 按客户和创建幂等键读取。 */
     public UsTruckOrder findKey(String customerId, String key) { return orders.findKey(customerId, key); }
     /** 保存新订单。 */

lastleg-service/src/main/java/com/baiyue/lastleg/trucking/service/UsTruckOrderService.java

@@ -396,7 +396,7 @@ public class UsTruckOrderService {
     }
 
     /** 按客户范围锁单并校验独立订单资格。 */
-    private UsTruckOrder lock(String customerId, String orderNo) { UsTruckOrder o = repository.lockNo(customerId, orderNo); if (o == null) throw notFound(); fleetPool.requireStandalone(customerId, "US_TRUCK", o.getId()); if(repository.hasActiveDispatch(customerId,orderNo))throw conflict("该单已接入排车，请在排车列表执行运输操作"); return o; }
+    private UsTruckOrder lock(String customerId, String orderNo) { UsTruckOrder o = repository.lockNo(customerId, orderNo); if (o == null) throw notFound(); fleetPool.requireStandalone(customerId, "US_TRUCK", o.getId()); return o; }
     /** 复核创建请求摘要并返回既有订单。 */
     private UsTruckOrderResponses.Detail replay(String customerId, UsTruckOrder order, String hash) { if (!hash.equals(order.getRequestHash())) throw conflict("Idempotency key was reused with different truck data"); return detail(customerId, order.getOrderNo()); }
     /** 读取订单资料与实际托盘和操作记录。 */

lastleg-service/src/main/resources/db/lastleg.sql

@@ -39,7 +39,7 @@ 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 COMMENT='排车单号每日独立原子流水';
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车单号每日独立原子流水';
 
 CREATE TABLE IF NOT EXISTS ll_order (
   id BIGINT NOT NULL COMMENT '雪花 ID',
@@ -1202,7 +1202,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 '客户送仓或人工安排提货回仓',
@@ -1217,7 +1216,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),
@@ -1894,7 +1892,6 @@ CREATE TABLE IF NOT EXISTS ll_inbound_stock_receipt (
 CREATE TABLE IF NOT EXISTS ll_dispatch_order (
   id BIGINT NOT NULL COMMENT '整车排车主单内部主键',
   dispatch_no VARCHAR(64) NOT NULL COMMENT '真实排车业务号',
-  task_type VARCHAR(32) NOT NULL DEFAULT 'DELIVERY' COMMENT '任务类型：仓库派送、到仓取货、本土卡车',
   trip_id BIGINT NOT NULL COMMENT '本趟唯一车辆资源记录ID',
   overseas_warehouse_id VARCHAR(128) NOT NULL COMMENT '真实起运海外仓ID',
   overseas_warehouse_code VARCHAR(128) NULL COMMENT '起运海外仓编码快照',
@@ -4544,7 +4541,6 @@ CREATE TABLE IF NOT EXISTS 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 (
   dispatch_id BIGINT NOT NULL COMMENT '原排车内部主键',
   resource_mode VARCHAR(16) NOT NULL COMMENT '原排车资源模式MASTER或EXTERNAL',
@@ -4624,31 +4620,6 @@ CREATE TABLE IF NOT EXISTS 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 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 PRIMARY KEY COMMENT '本次运输资源记录号',
-  request_hash CHAR(64) NOT NULL COMMENT '首次安排请求摘要'
-) 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='排车运输执行命令与凭证账本';
-
 -- 统一业务单号：前缀 + yyyyMMdd + 四位日流水。
 CREATE TABLE IF NOT EXISTS ll_document_sequence (
   sequence_key VARCHAR(32) NOT NULL COMMENT '业务前缀与北京时间日期组成的全局序列键',

lastleg-service/src/main/resources/openapi/dispatch-transport-tasks-v1.yaml

@@ -1,99 +0,0 @@
-openapi: 3.0.3
-info:
-  title: 现有排车运输任务
-  version: 1.0.0
-  description: >-
-    平台主体（tenantId=0）在现有排车列表内安排到仓取货、本土卡车，使用真实PC排车号。
-    请求经统一Gateway与Bearer认证；JSON响应HTTP200，业务code=200成功，A0400参数错误、A0403权限不足、A0404不存在、A0409版本或状态冲突。
-    list读取、create安排、edit分配/执行/释放、depart发车、cancel取消权限前缀均为platform:overseas-warehouse:dispatch:。
-    创建及执行使用稳定idempotencyKey；重试保留完整原载荷。取消仅限未发车；完成后分别释放司机、车辆。
-    到仓取货逐原单确认实提和送仓，送仓只开放仓库收货门禁；本土卡车同步原单运输状态，完成须本任务凭证。
-servers:
-  - url: /api/platform/v1/last-leg/dispatches/transport-tasks
-security:
-  - bearerAuth: []
-paths:
-  /pickup-candidates:
-    get:
-      summary: 同仓上门取货候选（list，page/size/keyword/warehouseId）
-      responses: &response
-        '200':
-          description: 业务响应信封；data为对应详情、候选或操作结果
-  /truck-candidates:
-    get:
-      summary: 待派车且未被运输或拼车占用的本土卡车候选（list）
-      responses: *response
-  /pickup:
-    post:
-      summary: 同一海外仓多客户取货安排（create）
-      description: sources为customerId/transferNo数组，plannedDepartureAt和expectedDriverEndAt为ISO时刻；idempotencyKey必填，remark可选。返回Detail。
-      responses: *response
-  /truck:
-    post:
-      summary: 本土卡车原单接入排车（create）
-      description: customerId、orderNo、warehouseId、plannedDepartureAt、expectedDriverEndAt、idempotencyKey必填；原单须PENDING_DISPATCH且未被占用。返回Detail。
-      responses: *response
-  /{number}:
-    parameters: &number
-      - { name: number, in: path, required: true, schema: { type: string }, description: 真实PC排车业务号 }
-    get:
-      summary: 排车运输详情（list）
-      description: data包含dispatchNo、taskType（PICKUP/LOCAL_TRUCK）、execution（现有资源与执行详情）、customerId、orderNo、pickups、completionEvidence（已确认凭证）。
-      responses: *response
-  /{number}/{action}:
-    parameters:
-      - { name: number, in: path, required: true, schema: { type: string } }
-      - { name: action, in: path, required: true, schema: { type: string, enum: [assign, cancel, resource-occupancy, release] } }
-    post:
-      summary: 分配、取消、资源可用性查询与实际任务释放
-      description: >-
-        assign(edit)：recordVersion、vehicleId、driverId、reason；cancel(cancel)：recordVersion、reason。
-        resource-occupancy(list)：kind=VEHICLE/DRIVER、resourceIds数组。
-        release(edit)：recordVersion、resourceKind、actualEndAt、endLocation、vehicleStatus（车辆必填）、idempotencyKey、reason。
-      responses: *response
-  /{number}/{kind}/{action}:
-    parameters:
-      - { name: number, in: path, required: true, schema: { type: string } }
-      - { name: kind, in: path, required: true, schema: { type: string, enum: [pickup, truck] } }
-      - { name: action, in: path, required: true, schema: { type: string, enum: [depart, complete] } }
-    post:
-      summary: 运输发车（depart）或完成（edit）
-      description: recordVersion、idempotencyKey、reason必填。本土卡车complete还须至少一份evidenceFileIds，文件归属本任务。取货complete要求所有原单已送仓。
-      responses: *response
-  /{number}/pickup/{customer}/{source}/{action}:
-    parameters:
-      - { name: number, in: path, required: true, schema: { type: string } }
-      - { name: customer, in: path, required: true, schema: { type: string } }
-      - { name: source, in: path, required: true, schema: { type: string }, description: 仓储转运单号 }
-      - { name: action, in: path, required: true, schema: { type: string, enum: [picked, arrive, files] } }
-    post:
-      summary: 按原单上传凭证、确认实提或送仓（edit）
-      description: files使用multipart字段file；picked使用recordVersion、idempotencyKey、actualPackages、evidenceFileIds、remark；arrive使用recordVersion、idempotencyKey、reason。凭证不能跨客户原单使用。
-      responses: *response
-  /{number}/truck/files:
-    parameters: *number
-    post:
-      summary: 本土卡车凭证上传（edit）
-      description: multipart字段file，非空且不超过10MB，只能在计划或运输中上传。上传不等于完成，须通过complete命令确认文件引用。
-      responses: *response
-  /{number}/truck/files/{fileId}:
-    parameters:
-      - { name: number, in: path, required: true, schema: { type: string } }
-      - { name: fileId, in: path, required: true, schema: { type: integer, format: int64 } }
-    get:
-      summary: 已确认本土卡车完成凭证鉴权下载（list）
-      responses:
-        '200': { description: application/octet-stream文件；失败返回业务响应信封 }
-  /{number}/pickup/{customer}/{source}/files/{fileId}:
-    parameters:
-      - { name: number, in: path, required: true, schema: { type: string } }
-      - { name: customer, in: path, required: true, schema: { type: string } }
-      - { name: source, in: path, required: true, schema: { type: string } }
-      - { name: fileId, in: path, required: true, schema: { type: integer, format: int64 } }
-    get:
-      summary: 当前排车原单已确认取货凭证鉴权下载（list）
-      responses:
-        '200': { description: application/octet-stream文件；当前排车及原单归属不符时拒绝 }
-components:
-  securitySchemes:
-    bearerAuth: { type: http, scheme: bearer, bearerFormat: JWT }

lastleg-service/src/main/resources/openapi/fleet-capacity-offers-v1.yaml

@@ -373,36 +373,6 @@ paths:
           application/json:
             schema:
               $ref: '#/components/schemas/OfferCommand'
-  /api/platform/v1/last-leg/fleet/capacity-offers/pending-looseboard-demands:
-    get:
-      summary: 分页读取客户已提交的待匹配散板原单
-      description: 权限：platform:fleet:capacity-offer:manage 或 (platform:fleet:capacity-offer:list 且 platform:fleet:capacity-offer:inquiry-create)。仅返回待接单、没有独立尾程来源且没有生效匹配的原单；取消未确认登记后恢复候选。下单及登记不占位，确认承运才占位。旧独立履约单不回填来源。
-      parameters:
-      - { name: page, in: query, schema: { type: integer, minimum: 1, default: 1 } }
-      - { name: size, in: query, schema: { type: integer, minimum: 1, maximum: 100, default: 20 } }
-      - { name: keyword, in: query, schema: { type: string, maxLength: 128 } }
-      responses:
-        '200':
-          description: 统一业务响应
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code: { type: string }
-                  message: { type: string }
-                  data:
-                    type: object
-                    properties:
-                      records:
-                        type: array
-                        items: { $ref: '#/components/schemas/LooseboardDemand' }
-                      page: { type: integer }
-                      size: { type: integer }
-                      total: { type: integer }
-                      pages: { type: integer }
-        '401': { description: 未登录 }
-        '403': { description: 无需求匹配权限 }
   /api/platform/v1/last-leg/fleet/capacity-offers/inquiries:
     get:
       summary: 分页查询本人或获准的全部意向
@@ -1340,24 +1310,6 @@ components:
             minimum: 0
           - type: string
             pattern: ^[0-9]+$
-    LooseboardDemand:
-      type: object
-      description: 原单待匹配投影；不含创建幂等键、请求哈希和操作人技术身份。
-      properties:
-        orderNo: { type: string }
-        customerId: { type: string }
-        version: { type: integer, format: int64 }
-        origin: { type: string }
-        destination: { type: string }
-        productName: { type: string, nullable: true }
-        estimatedPalletCount: { type: integer, nullable: true }
-        packageCount: { type: integer, nullable: true }
-        totalWeightKg: { type: number, nullable: true }
-        totalVolumeCbm: { type: number, nullable: true }
-        currency: { type: string }
-        originContactName: { type: string, nullable: true }
-        originContactPhone: { type: string, nullable: true }
-        remark: { type: string, nullable: true }
     InquiryWrite:
       type: object
       required:
@@ -1369,18 +1321,6 @@ components:
       - cargo
       - idempotencyKey
       properties:
-        sourceOrderNo:
-          type: string
-          maxLength: 64
-          nullable: true
-          description: 从待匹配散板选择原商业单；仅LOCAL_LOOSEBOARD支持。确认承运复用原单，不另开商业单。
-        sourceOrderVersion:
-          type: integer
-          format: int64
-          minimum: 0
-          nullable: true
-          description: 创建匹配时与原单号一起提交；已匹配登记不可替换来源。
-
         tripRecordVersion:
           oneOf:
           - type: integer

lastleg-service/src/main/resources/openapi/fleet-outsourced-business-v1.yaml

@@ -2,7 +2,7 @@ openapi: "3.0.3"
 info:
   title: "原排车外配车辆运营视图"
   version: "1.0.0"
-  description: "仅ACTIVE且装车后/派送中/已完成。按原装车归属DISPATCHED及MASTER/EXTERNAL资源快照读取；无快照不回填。复用四张附加表，不推进排车、不触发库存/财务。承运金额CNY/USD显式登记；单价除以实际物理托数并HALF_UP两位。无里程、油耗及油耗照片。响应遵循NON_NULL：可空属性可省略，省略与null均表示空值，0仍是明确登记值；请求必填项仍以required及DTO校验为准。"
+  description: "仅ACTIVE且装车后/派送中/已完成。按原装车归属DISPATCHED及MASTER/EXTERNAL资源快照读取；无快照不回填。复用四张附加表，不推进排车、不触发库存/财务。承运金额CNY/USD显式登记；单价除以实际物理托数并HALF_UP两位。无里程、油耗及油耗照片。"
 security:
   - bearerAuth: []
 paths:
@@ -152,7 +152,7 @@ components:
       type: object
       additionalProperties: false
       x-java-record: OutsourcedBusinessModels.Operations
-      required: [arrivals]
+      required: [money, arrivals]
       properties:
         money: { allOf: [ { "$ref": "fleet-owned-business-v1.yaml#/components/schemas/Money" } ], nullable: true }
         arrivals: { type: array, items: { "$ref": "fleet-owned-business-v1.yaml#/components/schemas/Arrival" }, description: "只接受原实际destinationKey，禁止重复或其他车辆目的地；省略目的地或null均不推定到达" }
@@ -178,7 +178,7 @@ components:
     Vehicle:
       type: object
       x-java-record: OutsourcedBusinessModels.Vehicle
-      required: [ownership]
+      required: [vehicleId, plate, ownership, carrierName]
       properties:
         vehicleId: { type: string, nullable: true, description: "原临时EXTERNAL车辆合法为空，档案MASTER核对原捕获ID" }
         plate: { type: string, nullable: true }
@@ -190,7 +190,7 @@ components:
     Photo:
       type: object
       x-java-record: OutsourcedBusinessModels.Photo
-      required: [slot, category, fileId, fileName, contentType, sizeBytes, uploadedAt]
+      required: [slot, category, fileId, fileName, contentType, sizeBytes, uploadedAt, savedAt]
       properties:
         slot: { "$ref": "#/components/schemas/PhotoSlot" }
         category: { type: string, enum: [LOADING] }
@@ -209,7 +209,7 @@ components:
     Row:
       type: object
       x-java-record: OutsourcedBusinessModels.Row
-      required: [dispatchNo, stage, plannedDepartureAt, loadingCompletedAt, origin, vehicle, driver, destinations, actualPalletCount, operations, recordVersion, dispatchRecordVersion, photoSummary, actions, sourceIssues]
+      required: [dispatchNo, stage, plannedDepartureAt, loadingCompletedAt, departedAt, deliveryCompletedAt, origin, vehicle, driver, destinations, actualPalletCount, operations, unitPrice, recordVersion, dispatchRecordVersion, photoSummary, actions, sourceIssues]
       properties:
         dispatchNo: { type: string }
         stage: { "$ref": "fleet-owned-business-v1.yaml#/components/schemas/Stage" }
@@ -251,7 +251,7 @@ components:
     History:
       type: object
       x-java-record: OutsourcedBusinessModels.History
-      required: [eventSource, action, occurredAt, photos]
+      required: [eventSource, recordVersion, dispatchRecordVersion, action, operatorName, occurredAt, reason, operations, photos]
       properties:
         eventSource: { type: string, enum: [DISPATCH, OPERATIONS] }
         recordVersion: { type: string, nullable: true }
@@ -274,8 +274,7 @@ components:
     Command:
       type: object
       x-java-record: OutsourcedBusinessModels.Command
-      description: "SAVE_OPERATIONS/BIND_PHOTO成功时recordVersion和result必须有值；UPLOAD_PHOTO成功时result必须含fileId，recordVersion可空。仅可空的未确定或拒绝结果字段允许省略，不放宽成功回执的关联要求。"
-      required: [dispatchNo, action, idempotencyKey, state, replayed, retryAllowed]
+      required: [dispatchNo, action, idempotencyKey, state, recordVersion, replayed, result, errorCode, retryAllowed]
       properties:
         dispatchNo: { type: string }
         action: { type: string, enum: [SAVE_OPERATIONS, UPLOAD_PHOTO, BIND_PHOTO] }

lastleg-service/src/main/resources/openapi/fleet-owned-business-v1.yaml

@@ -2,7 +2,7 @@ openapi: "3.0.3"
 info:
   title: "原排车自有车辆运营视图"
   version: "1.0.0"
-  description: "装车完成时冻结车辆OWNED/DISPATCHED；所有主单事实来自原dispatch。新增数据仅附加运营记录、命令、历史及归属证据。油耗L/100km手工登记，金额CNY/USD不默认、不换汇；零与未登记不同。响应遵循NON_NULL：可空属性可省略，省略与null均表示空值，0仍是明确登记值；请求必填项仍以required及DTO校验为准。"
+  description: "装车完成时冻结车辆OWNED/DISPATCHED；所有主单事实来自原dispatch。新增数据仅附加运营记录、命令、历史及归属证据。油耗L/100km手工登记，金额CNY/USD不默认、不换汇；零与未登记不同。"
 security:
   -
     bearerAuth: []
@@ -429,6 +429,7 @@ components:
       x-java-record: "OwnedBusinessModels.Arrival"
       required:
         - "destinationKey"
+        - "actualArrivedAt"
       properties:
         destinationKey:
           type: "string"
@@ -442,6 +443,9 @@ components:
       type: "object"
       x-java-record: "OwnedBusinessModels.Operations"
       required:
+        - "money"
+        - "actualDistanceMiles"
+        - "fuelConsumptionLitresPer100Km"
         - "arrivals"
       properties:
         money:
@@ -505,6 +509,7 @@ components:
       x-java-record: "OwnedBusinessModels.Gate"
       required:
         - "allowed"
+        - "blockReason"
       properties:
         allowed:
           type: "boolean"
@@ -555,6 +560,9 @@ components:
     Driver:
       type: "object"
       x-java-record: "OwnedBusinessModels.Driver"
+      required:
+        - "name"
+        - "phone"
       properties:
         name:
           type: "string"
@@ -567,6 +575,8 @@ components:
       x-java-record: "OwnedBusinessModels.Appointment"
       required:
         - "appointmentNo"
+        - "confirmationNo"
+        - "scheduledAt"
         - "allocatedPackages"
       properties:
         appointmentNo:
@@ -586,7 +596,11 @@ components:
       x-java-record: "OwnedBusinessModels.Destination"
       required:
         - "destinationKey"
+        - "warehouseCode"
+        - "warehouseName"
+        - "address"
         - "appointments"
+        - "actualArrivedAt"
       properties:
         destinationKey:
           type: "string"
@@ -618,6 +632,7 @@ components:
         - "contentType"
         - "sizeBytes"
         - "uploadedAt"
+        - "savedAt"
       properties:
         slot:
           "$ref": "#/components/schemas/PhotoSlot"
@@ -666,11 +681,15 @@ components:
         - "stage"
         - "plannedDepartureAt"
         - "loadingCompletedAt"
+        - "departedAt"
+        - "deliveryCompletedAt"
         - "origin"
         - "vehicle"
         - "driver"
         - "destinations"
+        - "actualPalletCount"
         - "operations"
+        - "unitPrice"
         - "recordVersion"
         - "dispatchRecordVersion"
         - "photoSummary"
@@ -782,6 +801,9 @@ components:
       required:
         - "sourceKey"
         - "customerId"
+        - "customerName"
+        - "orderNo"
+        - "inboundCode"
         - "palletNo"
         - "destinationKey"
         - "packages"
@@ -831,8 +853,13 @@ components:
       x-java-record: "OwnedBusinessModels.History"
       required:
         - "eventSource"
+        - "recordVersion"
+        - "dispatchRecordVersion"
         - "action"
+        - "operatorName"
         - "occurredAt"
+        - "reason"
+        - "operations"
         - "photos"
       properties:
         eventSource:
@@ -895,13 +922,15 @@ components:
     Command:
       type: "object"
       x-java-record: "OwnedBusinessModels.Command"
-      description: "SAVE_OPERATIONS/BIND_PHOTO成功时recordVersion和result必须有值；UPLOAD_PHOTO成功时result必须含fileId，recordVersion可空。仅可空的未确定或拒绝结果字段允许省略，不放宽成功回执的关联要求。"
       required:
         - "dispatchNo"
         - "action"
         - "idempotencyKey"
         - "state"
+        - "recordVersion"
         - "replayed"
+        - "result"
+        - "errorCode"
         - "retryAllowed"
       properties:
         dispatchNo:

lastleg-service/src/main/resources/openapi/fleet-trips-v1.yaml

@@ -359,7 +359,7 @@ components:
   schemas:
     TripCalendarEntry:
       type: object
-      required: [sourceType, dispatchNo, status, plannedDepartureAt, expectedDriverEndAt, stops, containerNumbers, incompleteReasons]
+      required: [sourceType, dispatchNo, status, plannedDepartureAt, expectedDriverEndAt, stops, incompleteReasons]
       properties:
         sourceType: {type: string, enum: [DISPATCH]}
         dispatchNo: {type: string, description: 真实整车主单排车号，用于排车详情路由}
@@ -375,11 +375,6 @@ components:
         departedAt: {type: string, format: date-time, nullable: true}
         completedAt: {type: string, format: date-time, nullable: true}
         stops: {type: array, items: {$ref: '#/components/schemas/Stop'}}
-        containerNumbers:
-          type: array
-          description: 本车全部货物正式来源快照中的真实柜号，去空去重；多客户、多柜保留完整数组，无柜号为空数组，不推测或补造。
-          items: {type: string}
-          uniqueItems: true
         incompleteReasons:
           type: array
           items: {type: string, enum: [ORIGIN_WAREHOUSE_UNKNOWN, ORIGIN_COUNTRY_UNKNOWN, ORIGIN_TIMEZONE_UNKNOWN, ROUTE_INCOMPLETE]}

lastleg-service/src/main/resources/openapi/lastleg-customer-order-progress-v1.yaml

@@ -8,10 +8,9 @@ paths:
       summary: Order按认证客户读取排车和实际派送进度
       description: >-
         只读内部接口，无公网路由。customerId由Order认证上下文提供，所有业务表在Lastleg自身Schema内按客户读取。
-        已排车scheduled按有效待出库单的不可变来源明细及箱数计算，与平台出库单节点一致；仅生成排车单号、审核中、审核通过但未生成出库单均不计入。
-        取消的出库单及已实际出库的单据不计入scheduled；排车审核、真实拣货核平、装车确认及安排派送仍按原流程执行。
-        派送必须排车单ACTIVE且处于DELIVERING阶段、具有实际发车时间、出库OUTBOUNDED且对应目的地派送单仍WAIT_DELIVERY/DELIVERING。
-        混托使用全部不可变出库及拣货来源，不使用代表orderId；数量覆盖不完整或异常时标记partial，不签发派送完成事实。
+        正式排车单PENDING_DEPARTURE/PICKING/READY_TO_DEPART按计划或库存来源计算，预排草稿和取消单不计入。
+        派送必须已实际DEPARTED、出库OUTBOUNDED且对应目的地派送单仍WAIT_DELIVERY/DELIVERING。
+        混托使用所有库存及不可变拣货来源，不使用代表orderId；数量覆盖不完整或异常时标记partial，不签发派送完成事实。
       security: [{internalServiceToken: []}]
       requestBody:
         required: true

lastleg-service/src/test/java/com/baiyue/lastleg/dispatch/service/DispatchAggregatePersistenceTest.java

@@ -442,23 +442,6 @@ public class DispatchAggregatePersistenceTest {
         assertThat(f.tx.execute(s->f.service.detail(f.actor,original.dispatchNo())).counts().packageCount()).isEqualTo(10);
     }
 
-    /** 到仓取货、本土卡车不制造货物明细，但仍须按原客户出现在现有整车排车列表。 */
-    @Test void customerFilterFindsPickupAndLocalTruckByTheirRealSourceLinks() throws Exception {
-        var f=new Fixture();
-        var pickup=f.tx.execute(s->f.service.create(f.actor,f.create("transport-pickup-list",List.of())));
-        var truck=f.tx.execute(s->f.service.create(f.actor,f.create("transport-truck-list",List.of())));
-        String pickupTrip=f.db.queryForObject("SELECT trip_no FROM ll_fleet_trip WHERE id=(SELECT trip_id FROM ll_dispatch_order WHERE dispatch_no=?)",String.class,pickup.dispatchNo());
-        String truckTrip=f.db.queryForObject("SELECT trip_no FROM ll_fleet_trip WHERE id=(SELECT trip_id FROM ll_dispatch_order WHERE dispatch_no=?)",String.class,truck.dispatchNo());
-        f.db.update("UPDATE ll_dispatch_order SET task_type='PICKUP' WHERE dispatch_no=?",pickup.dispatchNo());
-        f.db.update("UPDATE ll_dispatch_order SET task_type='LOCAL_TRUCK' WHERE dispatch_no=?",truck.dispatchNo());
-        f.db.update("INSERT INTO ll_fleet_pickup_task(customer_id,trip_no) VALUES('PICKUP-CUSTOMER',?)",pickupTrip);
-        f.db.update("INSERT INTO ll_dispatch_truck_task(dispatch_no,customer_id) VALUES(?,'TRUCK-CUSTOMER')",truck.dispatchNo());
-        var pickupPage=f.tx.execute(s->f.service.page(f.actor,new DispatchViews.Query(1,20,null,null,null,"PICKUP-CUSTOMER",null,StatusFilter.ACTIVE,Stage.BEFORE_LOADING,null,null)));
-        var truckPage=f.tx.execute(s->f.service.page(f.actor,new DispatchViews.Query(1,20,null,null,null,"TRUCK-CUSTOMER",null,StatusFilter.ACTIVE,Stage.BEFORE_LOADING,null,null)));
-        assertThat(pickupPage.total()).isOne();assertThat(pickupPage.records().get(0).dispatchNo()).isEqualTo(pickup.dispatchNo());assertThat(pickupPage.records().get(0).taskType()).isEqualTo("PICKUP");
-        assertThat(truckPage.total()).isOne();assertThat(truckPage.records().get(0).dispatchNo()).isEqualTo(truck.dispatchNo());assertThat(truckPage.records().get(0).taskType()).isEqualTo("LOCAL_TRUCK");
-    }
-
     /** 第N项已被另一车占用时，早先本车/来源/资源/账本全部回滚。 */
     @Test void laterCargoConflictRollsBackTruckResourcesEarlierLocksAndItems() throws Exception {
         var f=new Fixture(); var a=f.source(1,"101",501,"ONT8",3); var b=f.source(2,"202",502,"LAX9",5);
@@ -509,8 +492,6 @@ public class DispatchAggregatePersistenceTest {
             db.execute("ALTER TABLE ll_fleet_trip_dispatch ADD UNIQUE(trip_id)");
             db.execute("ALTER TABLE ll_dispatch_physical_pallet_lock ADD UNIQUE(active_warehouse_pallet_id)");
             db.execute("ALTER TABLE ll_dispatch_pallet_lock ADD UNIQUE(customer_id,active_key)");
-            db.execute("CREATE TABLE ll_dispatch_truck_task(dispatch_no VARCHAR(64),customer_id VARCHAR(128))");
-            db.execute("CREATE TABLE ll_fleet_pickup_task(customer_id VARCHAR(128),trip_no VARCHAR(64))");
             db.execute("CREATE TABLE ll_dispatch_command(id BIGINT PRIMARY KEY,dispatch_id BIGINT,dispatch_no VARCHAR(64),action VARCHAR(40),operator_id VARCHAR(128),idempotency_key VARCHAR(255) UNIQUE,record_version BIGINT,command_hash CHAR(64),result_json CLOB,created_at TIMESTAMP(3))");
             db.execute("CREATE TABLE ll_dispatch_history(id BIGINT PRIMARY KEY,dispatch_id BIGINT,record_version BIGINT,action VARCHAR(40),operator_id VARCHAR(128),reason VARCHAR(1000),snapshot_json CLOB,occurred_at TIMESTAMP(3))");
             db.execute("CREATE TABLE ll_dispatch_pda_pick(id BIGINT,customer_id VARCHAR(64),dispatch_item_id BIGINT,inventory_position_id BIGINT,packages BIGINT,product_quantity BIGINT)");

lastleg-service/src/test/java/com/baiyue/lastleg/dispatch/transport/TransportTaskProjectionTest.java

@@ -1,31 +0,0 @@
-package com.baiyue.lastleg.dispatch.transport;
-
-import com.baiyue.lastleg.dispatch.entity.DispatchAggregate;
-import com.baiyue.lastleg.dispatch.repository.DispatchAggregateRepository;
-import com.baiyue.lastleg.dispatch.service.DispatchNumberGenerator;
-import com.baiyue.lastleg.trucking.entity.UsTruckOrder;
-import com.baiyue.lastleg.trucking.repository.UsTruckOrderRepository;
-import com.baiyue.lastleg.fleet.trip.FleetTripEntity;
-import com.baiyue.lastleg.fleet.trip.TransportTripChanged;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.jupiter.api.Test;
-import java.time.LocalDateTime;
-import static org.mockito.Mockito.*;
-import static org.mockito.ArgumentMatchers.*;
-import static org.assertj.core.api.Assertions.*;
-
-class TransportTaskProjectionTest {
-    /** 旧取消入口产生的运输事实也必须撤销原单安排和资源投影。 */
-    @Test void legacyCancellationSynchronizesDispatchAndUnlocksSource(){
-        var roots=mock(DispatchAggregateRepository.class);var links=mock(TransportTaskRepository.class);var trucks=mock(UsTruckOrderRepository.class);
-        var projection=new TransportTaskProjection(roots,links,trucks,mock(DispatchNumberGenerator.class),new ObjectMapper().findAndRegisterModules());
-        var root=new DispatchAggregate();root.setId(2L);root.setDispatchNo("PC1");root.setRecordVersion(3L);root.setTaskType("LOCAL_TRUCK");
-        when(links.byTrip(1L)).thenReturn(root);when(roots.lock("PC1")).thenReturn(root);when(roots.saveState(root,3L)).thenReturn(1);
-        when(links.truck("PC1")).thenReturn(new TransportTaskModels.TruckLink("PC1","TR1","C1","U1"));
-        var order=new UsTruckOrder();order.setId(9L);order.setStatus("DISPATCHED");order.setVersion(5L);when(trucks.lockNo("C1","U1")).thenReturn(order);
-        var trip=new FleetTripEntity();trip.setId(1L);trip.setTripPurpose("LOCAL_TRUCK");trip.setStatus("CANCELLED");trip.setRecordVersion(4L);trip.setUpdatedAt(LocalDateTime.now());
-        projection.changed(new TransportTripChanged(trip,"CANCEL","取消运输","OP"));
-        assertThat(root.getStatus()).isEqualTo("CANCELLED");assertThat(root.getRecordVersion()).isEqualTo(4L);assertThat(order.getStatus()).isEqualTo("PENDING_DISPATCH");assertThat(order.getVersion()).isEqualTo(6L);
-        verify(links).cancel("PC1");verify(trucks).insertHistory(argThat(row->"DISPATCHED".equals(row.getFromStatus())&&"PENDING_DISPATCH".equals(row.getToStatus())&&"C1".equals(row.getCustomerId())));
-    }
-}

lastleg-service/src/test/java/com/baiyue/lastleg/dispatch/transport/TransportTaskServiceTest.java

@@ -1,63 +0,0 @@
-package com.baiyue.lastleg.dispatch.transport;
-
-import com.baiyue.lastleg.dispatch.entity.DispatchAggregate;
-import com.baiyue.lastleg.dispatch.repository.DispatchAggregateRepository;
-import com.baiyue.lastleg.fleet.pickup.*;
-import com.baiyue.lastleg.fleet.trip.*;
-import com.baiyue.lastleg.fleet.driver.DriverService;
-import com.baiyue.lastleg.fleet.reporting.TripOperationsEvidenceGateway;
-import com.baiyue.lastleg.fleet.business.FleetPoolOrderQueries;
-import com.baiyue.lastleg.trucking.entity.UsTruckOrder;
-import com.baiyue.lastleg.trucking.repository.UsTruckOrderRepository;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.jupiter.api.*;
-import java.time.*;
-import java.util.*;
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.*;
-import static org.mockito.ArgumentMatchers.*;
-
-/** 验证原单承运执行权、凭证隔离和成功请求重放，不能仅靠页面按钮门禁。 */
-class TransportTaskServiceTest {
-    DispatchAggregateRepository roots;TransportTaskRepository links;FleetTripRepository tripRepo;FleetTripService trips;
-    UsTruckOrderRepository trucks;TripOperationsEvidenceGateway files;TransportTaskService service;FleetTripEntity trip;UsTruckOrder order;
-    final Map<String,String> commands=new HashMap<>();
-    @BeforeEach void setup(){
-        roots=mock(DispatchAggregateRepository.class);links=mock(TransportTaskRepository.class);tripRepo=mock(FleetTripRepository.class);trips=mock(FleetTripService.class);
-        trucks=mock(UsTruckOrderRepository.class);files=mock(TripOperationsEvidenceGateway.class);
-        service=new TransportTaskService(roots,links,mock(TransportTaskProjection.class),tripRepo,trips,mock(FleetPickupService.class),mock(FleetPickupRepository.class),trucks,mock(FleetPoolOrderQueries.class),mock(DriverService.class),mock(FleetTransportVehicleGuard.class),files,new ObjectMapper().findAndRegisterModules());
-        var root=new DispatchAggregate();root.setDispatchNo("PC1");root.setTaskType("LOCAL_TRUCK");root.setTripId(1L);
-        when(roots.find("PC1")).thenReturn(root);when(links.byTrip(1L)).thenReturn(root);when(links.tripNo(1L)).thenReturn("TR1");
-        when(links.truck("PC1")).thenReturn(new TransportTaskModels.TruckLink("PC1","TR1","C1","U1"));when(links.evidence("PC1")).thenReturn(List.of());
-        trip=new FleetTripEntity();trip.setId(1L);trip.setTripNo("TR1");trip.setTripPurpose("LOCAL_TRUCK");trip.setStatus("IN_TRANSIT");trip.setRecordVersion(3L);
-        when(tripRepo.lockTrip("TR1")).thenReturn(trip);when(tripRepo.findTrip("TR1")).thenReturn(trip);
-        order=new UsTruckOrder();order.setStatus("IN_TRANSIT");when(trucks.lockNo("C1","U1")).thenReturn(order);
-        when(links.commandHash(eq("PC1"),anyString())).thenAnswer(call->commands.get(call.getArgument(1)));
-        doAnswer(call->{commands.put(call.getArgument(1),call.getArgument(2));return null;}).when(links).command(eq("PC1"),anyString(),anyString(),anyString());
-        doAnswer(call->{trip.setRecordVersion(trip.getRecordVersion()+1);return null;}).when(trips).recordExecution(any(),anyLong(),anyString(),anyString(),anyString());
-    }
-    /** 无凭证或跨任务文件均不能结束运输，也不能写成功账本。 */
-    @Test void completionRequiresOwnedEvidence(){
-        assertThatThrownBy(()->service.truckCommand("PC1","OP","complete",command("key-missing",List.of()))).hasMessageContaining("凭证");
-        when(files.metadata(1L,99L)).thenThrow(new IllegalArgumentException("跨任务凭证"));
-        assertThatThrownBy(()->service.truckCommand("PC1","OP","complete",command("key-foreign",List.of(99L)))).hasMessageContaining("跨任务");
-        verify(trips,never()).recordExecution(any(),anyLong(),anyString(),anyString(),anyString());verify(links,never()).command(anyString(),anyString(),anyString(),anyString());
-    }
-    /** 同请求在版本变化后仍恢复原成功结果，不重复推进原单。 */
-    @Test void replayUsesOriginalSuccessfulCommandBeforeCurrentVersion(){
-        var body=command("complete-key",List.of(77L));service.truckCommand("PC1","OP","complete",body);service.truckCommand("PC1","OP","complete",body);
-        assertThat(trip.getStatus()).isEqualTo("COMPLETED");verify(trips,times(1)).recordExecution(any(),eq(3L),eq("LOCAL_TRUCK_COMPLETE"),anyString(),eq("OP"));
-        assertThatThrownBy(()->service.truckCommand("PC1","OP","complete",command("complete-key",List.of(88L)))).hasMessageContaining("不同内容");
-    }
-    /** 旧版本和未发车原单均不能利用完成接口跳过真实执行。 */
-    @Test void staleVersionAndWrongOriginalStatusCannotComplete(){
-        assertThatThrownBy(()->service.truckCommand("PC1","OP","complete",new TransportTaskModels.Command(2L,"stale-key","结束运输",List.of(77L)))).hasMessageContaining("刷新");
-        order.setStatus("DISPATCHED");assertThatThrownBy(()->service.truckCommand("PC1","OP","complete",command("wrong-state",List.of(77L)))).hasMessageContaining("先确认发车");verifyNoInteractions(files);
-    }
-    /** 下载只允许已完成命令持久化的文件引用，不能凭共享文件 ID 访问。 */
-    @Test void evidenceDownloadRequiresPersistedConfirmation(){
-        assertThatThrownBy(()->service.evidence("PC1",77L)).hasMessageContaining("没有该完成凭证");verifyNoInteractions(files);
-    }
-    /** 构造固定版本的测试执行命令。 */
-    private TransportTaskModels.Command command(String key,List<Long> files){return new TransportTaskModels.Command(3L,key,"结束运输",files);}
-}

lastleg-service/src/test/java/com/baiyue/lastleg/fleet/business/FleetLooseboardDemandPersistenceTest.java

@@ -1,50 +0,0 @@
-package com.baiyue.lastleg.fleet.business;
-
-import com.baomidou.mybatisplus.core.MybatisConfiguration;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
-import org.junit.jupiter.api.Test;
-import org.mybatis.spring.SqlSessionTemplate;
-import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.datasource.DriverManagerDataSource;
-import java.util.List;
-import java.util.UUID;
-import static org.assertj.core.api.Assertions.assertThat;
-
-class FleetLooseboardDemandPersistenceTest {
-    /** 真实 SQL 验证同客户关联、唯一来源、取消恢复候选和跨客户隔离。 */
-    @Test void originalDemandLeavesPoolUntilDraftIsCancelled() throws Exception {
-        var ds=new DriverManagerDataSource("jdbc:h2:mem:"+UUID.randomUUID()+";MODE=MySQL;DB_CLOSE_DELAY=-1","sa","");
-        var jdbc=new JdbcTemplate(ds);
-        jdbc.execute("CREATE TABLE ll_local_looseboard_order(id BIGINT PRIMARY KEY,customer_id VARCHAR(128),order_no VARCHAR(64),status VARCHAR(32),lastleg_order_id BIGINT,origin VARCHAR(64),destination VARCHAR(64),created_at TIMESTAMP)");
-        jdbc.execute("CREATE TABLE ll_fleet_external_booking(id BIGINT PRIMARY KEY,customer_id VARCHAR(128),source_looseboard_order_id BIGINT,status VARCHAR(32))");
-        jdbc.execute("CREATE TABLE ll_fleet_pool_order_link(customer_id VARCHAR(128),business_type VARCHAR(32),business_order_id BIGINT)");
-        jdbc.update("INSERT INTO ll_local_looseboard_order VALUES(1,'C-1','LB-1','PENDING_ACCEPTANCE',NULL,'LA','Ontario',CURRENT_TIMESTAMP)");
-        jdbc.update("INSERT INTO ll_local_looseboard_order VALUES(2,'C-1','OLD','PENDING_ACCEPTANCE',99,'LA','Ontario',CURRENT_TIMESTAMP)");
-        jdbc.update("INSERT INTO ll_fleet_external_booking VALUES(10,'C-1',NULL,'DRAFT'),(11,'C-2',NULL,'DRAFT')");
-        var config=new MybatisConfiguration();config.setMapUnderscoreToCamelCase(true);
-        config.addMapper(FleetLooseboardDemandMapper.class);config.addMapper(FleetPoolOrderMapper.class);
-        var factory=new MybatisSqlSessionFactoryBean();factory.setDataSource(ds);factory.setConfiguration(config);
-        var session=new SqlSessionTemplate(factory.getObject());
-        var mapper=session.getMapper(FleetLooseboardDemandMapper.class);
-        var links=session.getMapper(FleetPoolOrderMapper.class);
-        assertThat(mapper.pending(Page.of(1,20),"Ontario").getRecords()).extracting("orderNo").containsExactly("LB-1");
-        assertThat(mapper.attach(10,"C-2",1)).isZero();
-        assertThat(mapper.attach(10,"C-1",1)).isEqualTo(1);
-        assertThat(mapper.attach(10,"C-1",2)).isZero();
-        assertThat(mapper.active("C-1",1)).isEqualTo(1);
-        assertThat(mapper.active("C-2",1)).isNull();
-        assertThat(links.linked("C-1","LOCAL_LOOSEBOARD",1)).isEqualTo(1);
-        assertThat(mapper.source(10,"C-2")).isNull();
-        assertThat(mapper.source(10,"C-1").getOrderNo()).isEqualTo("LB-1");
-        assertThat(mapper.pending(Page.of(1,20),null).getRecords()).isEmpty();
-        jdbc.update("UPDATE ll_fleet_external_booking SET status='CANCELLED' WHERE id=10");
-        assertThat(mapper.active("C-1",1)).isNull();
-        assertThat(links.linked("C-1","LOCAL_LOOSEBOARD",1)).isZero();
-        assertThat(mapper.pending(Page.of(1,20),null).getRecords()).extracting("orderNo").containsExactly("LB-1");
-        assertThat(mapper.sourceNumbers(List.of(10L,11L))).extracting(FleetPoolOrderLink::getBusinessOrderNo).containsExactly("LB-1");
-        jdbc.update("UPDATE ll_fleet_external_booking SET source_looseboard_order_id=1 WHERE id=11");
-        assertThat(mapper.source(11,"C-2")).isNull();
-        assertThat(mapper.sourceNumbers(List.of(11L))).isEmpty();
-    }
-}

lastleg-service/src/test/java/com/baiyue/lastleg/fleet/business/FleetLooseboardDemandServiceTest.java

@@ -1,39 +0,0 @@
-package com.baiyue.lastleg.fleet.business;
-
-import com.baiyue.lastleg.looseboard.entity.LocalLooseboardOrder;
-import org.junit.jupiter.api.Test;
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.*;
-
-class FleetLooseboardDemandServiceTest {
-    final FleetLooseboardDemandRepository repository=mock(FleetLooseboardDemandRepository.class);
-    final FleetLooseboardDemandService service=new FleetLooseboardDemandService(repository);
-    /** 校验客户隔离、版本、已有匹配与独立履约都阻止重复接单。 */
-    @Test void rejectsMissingStaleMatchedAndPhysicalSources() {
-        assertThatThrownBy(()->service.prepare("9","LOCAL_LOOSEBOARD","LB-1",0L)).hasMessageContaining("不存在");
-        var row=source();when(repository.lock("9","LB-1")).thenReturn(row);
-        assertThatThrownBy(()->service.prepare("9","LOCAL_LOOSEBOARD","LB-1",1L)).hasMessageContaining("变化");
-        assertThatThrownBy(()->service.prepare("9","US_TRUCK","LB-1",0L)).hasMessageContaining("散板");
-        when(repository.active("9",1)).thenReturn(true);
-        assertThatThrownBy(()->service.prepare("9","LOCAL_LOOSEBOARD","LB-1",0L)).hasMessageContaining("已有承运");
-        when(repository.active("9",1)).thenReturn(false);row.setLastlegOrderId(7L);
-        assertThatThrownBy(()->service.prepare("9","LOCAL_LOOSEBOARD","LB-1",0L)).hasMessageContaining("独立履约");
-        verify(repository,never()).attach(anyLong(),anyString(),anyLong());
-    }
-    /** 取消草稿使生效匹配清空，同张原单可重新选车且没有商业复制。 */
-    @Test void allowsRematchAfterDraftCancellationAndKeepsSourceImmutable() {
-        var row=source();when(repository.lock("9","LB-1")).thenReturn(row);
-        when(repository.active("9",1)).thenReturn(true,false);
-        assertThatThrownBy(()->service.prepare("9","LOCAL_LOOSEBOARD","LB-1",0L)).hasMessageContaining("已有承运");
-        assertThat(service.prepare("9","LOCAL_LOOSEBOARD","LB-1",0L)).isSameAs(row);
-        when(repository.attach(7,"9",1)).thenReturn(1);service.attach(7,row);
-        when(repository.source(7,"9")).thenReturn(row);
-        service.validateEdit(7,"9","LOCAL_LOOSEBOARD",null);
-        assertThatThrownBy(()->service.validateEdit(7,"9","US_TRUCK",null)).hasMessageContaining("不能替换");
-        assertThatThrownBy(()->service.validateEdit(7,"9","LOCAL_LOOSEBOARD","LB-2")).hasMessageContaining("不能替换");
-    }
-    /** 构造待匹配原单。 */
-    private LocalLooseboardOrder source() {
-        var row=new LocalLooseboardOrder();row.setId(1L);row.setCustomerId("9");row.setOrderNo("LB-1");row.setVersion(0L);row.setStatus("PENDING_ACCEPTANCE");return row;
-    }
-}

lastleg-service/src/test/java/com/baiyue/lastleg/fleet/business/FleetPoolOrderBridgeTest.java

@@ -25,13 +25,11 @@ class FleetPoolOrderBridgeTest {
     com.baiyue.lastleg.service.LastlegDocumentNumberGenerator numbers=mock(com.baiyue.lastleg.service.LastlegDocumentNumberGenerator.class);
     FleetPoolDeliveryEvidence evidence=mock(FleetPoolDeliveryEvidence.class);
     com.baiyue.lastleg.appointmentplanning.AppointmentSourceLinker appointmentSources=mock(com.baiyue.lastleg.appointmentplanning.AppointmentSourceLinker.class);
-    FleetLooseboardDemandRepository demands=mock(FleetLooseboardDemandRepository.class);
     FleetPoolOrderBridge service;
     FleetPoolOrderLink row; LocalLooseboardOrder looseOrder; UsTruckOrder truckOrder;
     @BeforeEach void setup(){
         service=new FleetPoolOrderBridge(new FleetPoolOrderRepository(links,loose,looseHistory,trucks,truckHistory),numbers,new ObjectMapper().findAndRegisterModules(),evidence,appointmentSources);
 
-        org.springframework.test.util.ReflectionTestUtils.setField(service,"demands",demands);
         when(numbers.next(anyString())).thenReturn("LOCAL-001");
         when(links.lockBooking(7L)).thenAnswer(a->row);when(links.lockBookingNo("FB-7")).thenAnswer(a->row);
         when(links.lockIncoming("9","WT-7")).thenAnswer(a->row);
@@ -47,23 +45,6 @@ class FleetPoolOrderBridgeTest {
         BigDecimal.TEN,BigDecimal.ONE,"USD","联系人","123456","本轮池订单");}
     void incoming(){service.bindIncoming("FB-7","9","WT-7",77,"92","FBA:ONT8","op");}
 
-    /** 原单匹配后全链复用客户商业单，实收到签收均不另建商业单。 */
-    @Test void matchedSourceRemainsTheSameCommercialOrderThroughDelivery() {
-        looseOrder=new LocalLooseboardOrder();looseOrder.setId(31L);looseOrder.setCustomerId("9");looseOrder.setOrderNo("LB-ORIGINAL");looseOrder.setVersion(4L);looseOrder.setStatus("PENDING_ACCEPTANCE");
-        looseOrder.setOrigin("客户原始提货地址");looseOrder.setDestinationContactName("原始收货人");
-        when(demands.source(7,"9")).thenReturn(looseOrder);when(loose.lockNo("9","LB-ORIGINAL")).thenAnswer(a->looseOrder);
-        var original=looseOrder;
-        var confirmed=service.confirm(input("LOCAL_LOOSEBOARD"),"op");
-        assertThat(confirmed.businessOrderNo()).isEqualTo("LB-ORIGINAL");assertThat(row.getBusinessOrderId()).isEqualTo(31L);
-        assertThat(service.confirm(input("LOCAL_LOOSEBOARD"),"op")).isEqualTo(confirmed);
-        incoming();service.receiving("9","WT-7","pda");service.acceptedReceipt(7,receipt(),3,"op");service.boundDispatch(7,"9","DISPATCH-7","op");
-        service.departed("9","DISPATCH-7",Map.of(77L,4),"op",LocalDateTime.now());
-        service.signed(delivery(4),Map.of(77L,4L),"op",LocalDateTime.now());
-        assertThat(looseOrder).isSameAs(original);assertThat(original.getStatus()).isEqualTo("COMPLETED");
-        assertThat(original.getLastlegOrderId()).isEqualTo(77L);assertThat(original.getDestinationContactName()).isEqualTo("原始收货人");
-        verify(loose,never()).insert(any(LocalLooseboardOrder.class));
-    }
-
     @Test void materializesTheOriginalAppointmentAfterActualIncomingAssociationAndNeverOnReplay() {
         service.confirm(input("LOCAL_LOOSEBOARD"),"op");
         incoming();

lastleg-service/src/test/java/com/baiyue/lastleg/fleet/trip/FleetTripApiContractTest.java

@@ -47,7 +47,7 @@ class FleetTripApiContractTest {
             count++;
         }
         }
-        assertThat(count).isEqualTo(47);
+        assertThat(count).isEqualTo(46);
         verifyRefs(document, document);
         verifyRefs(preparation, preparation);
         verifyRefs(pool, pool);

lastleg-service/src/test/java/com/baiyue/lastleg/fleet/trip/FleetTripAuthorizationTest.java

@@ -81,18 +81,6 @@ class FleetTripAuthorizationTest {
             assertThatThrownBy(()->pool.saveAndConfirm("FB-1",null)).isInstanceOf(AccessDeniedException.class);
         } finally {SecurityContextHolder.clearContext();}
     }
-    /** 需求含客户原单资料，仅列表权限不能读取待匹配需求。 */
-    @Test void pendingDemandRequiresManageOrListAndCreate() {
-        try(var context=new AnnotationConfigApplicationContext(Config.class)) {
-            var controller=context.getBean(PlatformFleetCapacityOfferController.class);
-            var service=context.getBean(FleetCapacityOfferService.class);
-            SecurityContextHolder.getContext().setAuthentication(new UsernamePasswordAuthenticationToken("sales","unused",List.of(new SimpleGrantedAuthority(FleetCapacityOfferService.LIST))));
-            assertThatThrownBy(()->controller.pendingDemands(null)).isInstanceOf(AccessDeniedException.class);
-            verifyNoInteractions(service);
-            SecurityContextHolder.getContext().setAuthentication(new UsernamePasswordAuthenticationToken("sales","unused",List.of(new SimpleGrantedAuthority(FleetCapacityOfferService.LIST),new SimpleGrantedAuthority("platform:fleet:capacity-offer:inquiry-create"))));
-            controller.pendingDemands(null);verify(service).pendingDemands(null);
-        } finally {SecurityContextHolder.clearContext();}
-    }
     @Test void externalArrangeRequiresCurrentCreateAndAllIndependentPermissions() {
         var required=List.of("platform:fleet:capacity-offer:manage","platform:fleet:trip:booking-edit","platform:fleet:trip:edit","platform:overseas-warehouse:dispatch:create");
         try(var context=new AnnotationConfigApplicationContext(Config.class)) {
@@ -116,10 +104,6 @@ class FleetTripAuthorizationTest {
         @Bean com.baiyue.lastleg.service.LastlegDocumentNumberGenerator documentNumbers() {
             return com.baiyue.lastleg.service.TestDocumentNumbers.documents();
         }
-        /** 原单需求依赖使用替身，权限测试不访问数据库。 */
-        @Bean com.baiyue.lastleg.fleet.business.FleetLooseboardDemandService looseboardDemands() { return mock(com.baiyue.lastleg.fleet.business.FleetLooseboardDemandService.class); }
-        /** 桥接器的原单查询使用仓储替身。 */
-        @Bean com.baiyue.lastleg.fleet.business.FleetLooseboardDemandRepository looseboardDemandRepository() { return mock(com.baiyue.lastleg.fleet.business.FleetLooseboardDemandRepository.class); }
         /** 既有取货能力依赖原仓储引用；权限测试使用只读替身，不连接数据库。 */
         @Bean com.baiyue.lastleg.fleet.pickup.FleetPickupRepository pickups() { return mock(com.baiyue.lastleg.fleet.pickup.FleetPickupRepository.class); }
         @Bean com.baiyue.lastleg.fleet.trip.work.AppointmentWorkTripChanges workTripChanges() { return mock(com.baiyue.lastleg.fleet.trip.work.AppointmentWorkTripChanges.class); }

lastleg-service/src/test/java/com/baiyue/lastleg/fleet/trip/FleetTripCalendarMapperTest.java

@@ -62,24 +62,4 @@ class FleetTripCalendarMapperTest {
         bindDispatches(jdbc);
         assertThat(mapper.calendar(from,to)).hasSize(2001);
     }
-    /** 实际Mapper批读同单跨客户多柜，排除其他主单与取消主单，不用货物行放大日历。 */
-    @Test void batchReadsEverySourceSnapshotOnlyForTheRequestedActiveDispatches() throws Exception {
-        var ds=new DriverManagerDataSource("jdbc:h2:mem:"+UUID.randomUUID()+";MODE=MySQL;DB_CLOSE_DELAY=-1","sa","");
-        var jdbc=new JdbcTemplate(ds);
-        jdbc.execute("CREATE TABLE ll_dispatch_order(id BIGINT PRIMARY KEY,dispatch_no VARCHAR(80) UNIQUE,status VARCHAR(32))");
-        jdbc.execute("CREATE TABLE ll_dispatch_item(id BIGINT PRIMARY KEY,dispatch_order_id BIGINT,customer_id VARCHAR(64),source_snapshot_json VARCHAR(2000))");
-        jdbc.update("INSERT INTO ll_dispatch_order VALUES(1,'PC-A','ACTIVE'),(2,'PC-B','ACTIVE'),(3,'PC-OTHER','ACTIVE'),(4,'PC-CANCELLED','CANCELLED')");
-        jdbc.update("INSERT INTO ll_dispatch_item VALUES(11,1,'101',?), (12,1,'102',?), (13,1,'101',?), (21,2,'103',?), (31,3,'101',?), (41,4,'101',?)",
-            "{\"containerNo\":\"TSTU1234567\"}","{\"containerNo\":\"TSTU1234567\"}","{\"containerNo\":\"TSTU7654321\"}",
-            "{\"planNo\":\"PLAN-B\"}","{\"containerNo\":\"OTHER-CARGO\"}","{\"containerNo\":\"CANCELLED-CARGO\"}");
-        var config=new MybatisConfiguration();config.setMapUnderscoreToCamelCase(true);config.addMapper(FleetTripMapper.class);
-        var factory=new MybatisSqlSessionFactoryBean();factory.setDataSource(ds);factory.setConfiguration(config);
-        var mapper=new SqlSessionTemplate(factory.getObject()).getMapper(FleetTripMapper.class);
-        var repository=new FleetTripCalendarRepository(mapper);
-        assertThat(repository.sourceSnapshots(List.of())).isEmpty();
-        var rows=repository.sourceSnapshots(List.of("PC-A","PC-B","PC-CANCELLED"));
-        assertThat(rows).extracting(FleetTripCalendarRepository.Source::dispatchNo).containsExactly("PC-A","PC-A","PC-A","PC-B");
-        assertThat(rows).extracting(FleetTripCalendarRepository.Source::sourceSnapshotJson).containsExactly(
-            "{\"containerNo\":\"TSTU1234567\"}","{\"containerNo\":\"TSTU1234567\"}","{\"containerNo\":\"TSTU7654321\"}","{\"planNo\":\"PLAN-B\"}");
-    }
 }

lastleg-service/src/test/java/com/baiyue/lastleg/fleet/trip/FleetTripCalendarServiceTest.java

@@ -11,7 +11,7 @@ import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
 class FleetTripCalendarServiceTest {
-    final FleetTripCalendarRepository trips=mock(FleetTripCalendarRepository.class);
+    final FleetTripMapper trips=mock(FleetTripMapper.class);
     final FleetWarehouseClient warehouses=mock(FleetWarehouseClient.class);
     final FleetTripCalendarService service=new FleetTripCalendarService(trips,warehouses,new ObjectMapper(),"internal-test");
     final Instant from=Instant.parse("2026-10-01T00:00:00Z"),to=from.plus(Duration.ofDays(44));
@@ -107,51 +107,4 @@ class FleetTripCalendarServiceTest {
         var platform=new com.baiyue.common.security.AuthenticatedUser(1L,0L,0L,1L,"platform","PLATFORM","WEB",Set.of("platform:overseas-warehouse:dispatch:list"));
         controller.calendar(platform,from,to);verify(calendar).calendar(from,to);
     }
-    /** 同车全部来源只批读一次，跨客户重复柜号去重，多柜完整保留。 */
-    @Test void readsAllContainerNumbersInOneBatchAndPreservesTheLocalDateFacts() {
-        var first=trip("PC-A",1L);first.setPlannedDepartureAt(LocalDateTime.of(2026,10,22,16,0));
-        when(trips.calendar(any(),any())).thenReturn(List.of(first,trip("PC-B",1L)));
-        when(trips.sourceSnapshots(List.of("PC-A","PC-B"))).thenReturn(List.of(
-            new FleetTripCalendarRepository.Source("PC-A","{\"containerNo\":\" TSTU1234567 \",\"planNo\":\"PLAN-A\"}"),
-            new FleetTripCalendarRepository.Source("PC-A","{\"containerNo\":\"TSTU1234567\"}"),
-            new FleetTripCalendarRepository.Source("PC-A","{\"containerNo\":\"TSTU7654321\"}"),
-            new FleetTripCalendarRepository.Source("PC-A","{\"containerNo\":null}"),
-            new FleetTripCalendarRepository.Source("PC-B","{}"),
-            new FleetTripCalendarRepository.Source("PC-B","{\"containerNo\":\"  \"}")));
-        metadata(List.of(warehouse(1,"US","America/Los_Angeles")),List.of());
-        var result=service.calendar(from,to);
-        assertThat(result.records()).hasSize(2);
-        assertThat(result.records().get(0).containerNumbers()).containsExactly("TSTU1234567","TSTU7654321");
-        assertThat(result.records().get(1).containerNumbers()).isEmpty();
-        assertThat(result.records().get(0).plannedDepartureAt()).isEqualTo(Instant.parse("2026-10-22T16:00:00Z"));
-        assertThat(result.records().get(0).originTimezone()).isEqualTo("America/Los_Angeles");
-        assertThat(result.unresolvedRecords()).isEmpty();
-        verify(trips).calendar(any(),any());verify(trips).sourceSnapshots(List.of("PC-A","PC-B"));verifyNoMoreInteractions(trips);
-        verify(warehouses).platformMetadata("internal-test",new FleetWarehouseClient.MetadataRequest(List.of(1L)));
-        verifyNoMoreInteractions(warehouses);
-    }
-    /** 缺时区的主单仍保留真实柜号，不将货物信息丢失误作起运地已核实。 */
-    @Test void keepsKnownContainersOnAnUnresolvedOrigin() {
-        when(trips.calendar(any(),any())).thenReturn(List.of(trip("PC-UNKNOWN",1L)));
-        when(trips.sourceSnapshots(List.of("PC-UNKNOWN"))).thenReturn(List.of(
-            new FleetTripCalendarRepository.Source("PC-UNKNOWN","{\"containerNo\":\"TSTU1234567\"}")));
-        metadata(List.of(warehouse(1,"US",null)),List.of());
-        var result=service.calendar(from,to);assertThat(result.records()).isEmpty();
-        assertThat(result.unresolvedRecords()).singleElement().satisfies(row->{
-            assertThat(row.containerNumbers()).containsExactly("TSTU1234567");
-            assertThat(row.incompleteReasons()).containsExactly("ORIGIN_TIMEZONE_UNKNOWN");
-        });
-    }
-    /** 损坏或非当前正式文本快照明确失败，不伪造空数组或静默隐藏整月。 */
-    @Test void rejectsMalformedOrForeignSourceSnapshotsExplicitly() {
-        when(trips.calendar(any(),any())).thenReturn(List.of(trip("PC-A",1L)));
-        for(var invalid:Arrays.asList(null,"","not-json","null","[]","{\"containerNo\":123}","{\"containerNo\":[\"TSTU1234567\"]}","{} {}")) {
-            when(trips.sourceSnapshots(List.of("PC-A"))).thenReturn(List.of(new FleetTripCalendarRepository.Source("PC-A",invalid)));
-            assertThatThrownBy(()->service.calendar(from,to)).isInstanceOf(ResponseStatusException.class)
-                .hasMessageContaining("柜号资料暂不可用");
-        }
-        when(trips.sourceSnapshots(List.of("PC-A"))).thenReturn(List.of(new FleetTripCalendarRepository.Source("OTHER-PC","{}")));
-        assertThatThrownBy(()->service.calendar(from,to)).isInstanceOf(ResponseStatusException.class).hasMessageContaining("柜号资料暂不可用");
-        verifyNoInteractions(warehouses);
-    }
 }

lastleg-service/src/test/java/com/baiyue/lastleg/looseboard/service/LocalLooseboardServiceTest.java

@@ -64,9 +64,6 @@ class LocalLooseboardServiceTest {
         ReflectionTestUtils.setField(repository, "lastlegHistories", lastlegHistories);
         ReflectionTestUtils.setField(service, "lastlegOrderNoGenerator", lastlegOrderNoGenerator);
         ReflectionTestUtils.setField(service, "objectMapper", new ObjectMapper().findAndRegisterModules());
-        // 旧独立履约用例保留真实关联尾程，新增需求不创建该来源。
-        var legacyTail = new LastlegOrder(); legacyTail.setId(99L); legacyTail.setCustomerId("100");
-        org.mockito.Mockito.lenient().when(lastlegOrders.selectById(99L)).thenReturn(legacyTail);
         org.mockito.Mockito.lenient().doReturn("LB202610200001").when(lastlegOrderNoGenerator).next(anyString());
         org.mockito.Mockito.lenient().when(operations.findKey(anyString(), any(), anyString()))
             .thenAnswer(call -> operationRows.get(call.getArgument(2)));
@@ -96,8 +93,12 @@ class LocalLooseboardServiceTest {
         assertEquals("家居用品", detail.summary().productName());
         assertEquals(3, detail.summary().estimatedPalletCount());
         assertEquals(LocalDateTime.of(2030, 1, 2, 9, 30), detail.summary().pickupAt());
-        org.junit.jupiter.api.Assertions.assertNull(saved.get().getLastlegOrderId());
-        verify(lastlegOrders, org.mockito.Mockito.never()).insert(org.mockito.ArgumentMatchers.<LastlegOrder>any());
+        verify(lastlegOrders).insert(org.mockito.ArgumentMatchers.<LastlegOrder>argThat(value ->
+            "LOCAL_LOOSEBOARD".equals(value.getOrderType())
+                && value.getSourceOrderNo().equals("LB-WH-20260901-000001")
+                && value.getInboundCode() == null
+                && value.getPalletCount() == 0
+                && "LOCAL_LOOSEBOARD:PENDING_ACCEPTANCE".equals(value.getSubOrderStatus())));
         verify(histories).insert(org.mockito.ArgumentMatchers.<LocalLooseboardHistory>argThat(value ->
             "CREATE".equals(value.getOperationType())));
     }
@@ -206,7 +207,7 @@ class LocalLooseboardServiceTest {
 
     private LocalLooseboardOrder order(String status, long version) {
         LocalLooseboardOrder order = new LocalLooseboardOrder();
-        order.setId(1L); order.setCustomerId("100"); order.setOrderNo("LB1"); order.setLastlegOrderId(99L);
+        order.setId(1L); order.setCustomerId("100"); order.setOrderNo("LB1");
         order.setPalletRequired("YES");
         order.setTransportType("WAREHOUSE_TO_WAREHOUSE"); order.setOrigin("Los Angeles");
         order.setDestination("Ontario"); order.setPackageCount(12); order.setCurrency("USD");

lastleg-service/src/test/java/com/baiyue/lastleg/mapper/CustomerOrderProgressMapperTest.java

@@ -13,19 +13,16 @@ import static org.assertj.core.api.Assertions.*;
 class CustomerOrderProgressMapperTest {
     private JdbcTemplate jdbc;
     private CustomerOrderProgressMapper mapper;
-    /** 两客户共用一单一任务，出库和在途均按各自真实明细归属统计。 */
+    /** 两客户共用一单一任务，计划和在途均按各自真实明细归属统计。 */
     @Test void sharedDispatchAndTaskKeepBothCustomerProgressSeparate() {
         jdbc.update("INSERT INTO ll_dispatch_item(id,dispatch_order_id,customer_id,plan_pallet_id,overseas_warehouse_id,destination_warehouse_code) VALUES(101,10,'22',501,'W1','FBA2')");
         jdbc.update("INSERT INTO ll_inbound_plan_pallet_allocation VALUES(501,1002,30)");
-        pendingOutbound(10000,"11",1,10);
-        pendingOutbound(10000,"11",2,20);
-        pendingOutbound(10002,"22",3,30);
         assertThat(mapper.sources("11",null)).extracting(s->s.scheduledPackages()).containsExactly(10L,20L);
         assertThat(mapper.sources("22",null)).singleElement().satisfies(s->assertThat(s.scheduledPackages()).isEqualTo(30));
         jdbc.update("INSERT INTO ll_dispatch_pda_task VALUES(700,10)");
         jdbc.update("INSERT INTO ll_dispatch_pda_pick VALUES(600,'11',100,400,4,700),(601,'22',101,401,7,700)");
         jdbc.update("INSERT INTO ll_dispatch_pda_pick_order VALUES(900,600,'11',1,4),(901,601,'22',3,7)");
-        jdbc.update("UPDATE ll_outbound_order SET status='OUTBOUNDED'");
+        jdbc.update("INSERT INTO ll_outbound_order VALUES(10000,'11','OUTBOUNDED'),(10002,'22','OUTBOUNDED')");
         jdbc.update("INSERT INTO ll_delivery_order VALUES(10001,'11',10,10000,'DELIVERING','CODE:FBA1'),(10003,'22',10,10002,'DELIVERING','CODE:FBA2')");
         jdbc.update("UPDATE ll_dispatch_order SET stage='DELIVERING',departed_at=CURRENT_TIMESTAMP");
         assertThat(mapper.sources("11",null)).extracting(s->s.deliveringPackages()).containsExactly(4L,0L);
@@ -48,7 +45,6 @@ class CustomerOrderProgressMapperTest {
         jdbc.execute("CREATE TABLE ll_dispatch_pda_task(id BIGINT,dispatch_order_id BIGINT UNIQUE)");
         jdbc.execute("CREATE TABLE ll_delivery_order(id BIGINT,customer_id VARCHAR,dispatch_order_id BIGINT,outbound_order_id BIGINT,status VARCHAR,delivery_group_key VARCHAR)");
         jdbc.execute("CREATE TABLE ll_outbound_order(id BIGINT,customer_id VARCHAR,status VARCHAR)");
-        jdbc.execute("CREATE TABLE ll_outbound_pallet_item(outbound_order_id BIGINT,customer_id VARCHAR,source_order_id BIGINT,package_count INT)");
         jdbc.update("INSERT INTO ll_order VALUES(1,'11','101','201','FIRSTLEG','FBA',10),(2,'11','102','202','FIRSTLEG','FBA',20),(3,'22','103','203','FIRSTLEG','FBA',30)");
         jdbc.update("INSERT INTO ll_dispatch_order VALUES(10,'ACTIVE','BEFORE_LOADING',NULL)");
         jdbc.update("INSERT INTO ll_dispatch_item(id,dispatch_order_id,customer_id,plan_pallet_id,overseas_warehouse_id,destination_warehouse_code) VALUES(100,10,'11',500,'W1','FBA1')");
@@ -58,40 +54,24 @@ class CustomerOrderProgressMapperTest {
         var factory=new MybatisSqlSessionFactoryBean();factory.setDataSource(ds);factory.setConfiguration(config);
         mapper=new SqlSessionTemplate(factory.getObject()).getMapper(CustomerOrderProgressMapper.class);
     }
-    /** 排车号及审核阶段不代表有效出库，生成出库后才计入，取消后自动移出。 */
-    @Test void onlyEffectiveOutboundSourcesCountAsScheduled() {
-        jdbc.execute("ALTER TABLE ll_dispatch_order ADD review_state VARCHAR");
-        for (String review : java.util.List.of("DRAFT","DISPATCH_PENDING","DISPATCH_REJECTED","LOADING_PENDING","LOADING_REJECTED","APPROVED")) {
-            jdbc.update("UPDATE ll_dispatch_order SET review_state=?",review);
-            assertThat(mapper.sources("11", null)).allMatch(s->s.scheduledPackages()==0);
-            assertThat(new com.baiyue.lastleg.service.CustomerOrderProgressService(mapper).read(11,null).progress()).isEmpty();
-        }
-        jdbc.update("UPDATE ll_dispatch_order SET stage='AFTER_LOADING'");
-        assertThat(mapper.sources("11", null)).allMatch(s->s.scheduledPackages()==0);
-        pendingOutbound(10000,"11",1,10);
-        pendingOutbound(10000,"11",2,20);
+    /** 计划托盘上的所有本客户来源均计入，取消后不再计入。 */
+    @Test void plannedSharedPalletIncludesEveryOwnSourceAndExcludesCancellation() {
         var sources=mapper.sources("11", null);assertThat(sources).hasSize(2);
         assertThat(sources.get(0).scheduledPackages()).isEqualTo(10);
         assertThat(sources.get(1).scheduledPackages()).isEqualTo(20);
         assertThat(mapper.sources("11",java.util.List.of("101"))).containsExactly(sources.get(0));
         assertThat(sources).allMatch(s->s.deliveringPackages()==0);
-        for (String status : java.util.List.of("CANCELLED","CANCELED","OUTBOUNDED")) {
-            jdbc.update("UPDATE ll_outbound_order SET status=?",status);
-            assertThat(mapper.sources("11", null)).allMatch(s->s.scheduledPackages()==0);
-        }
+        jdbc.update("UPDATE ll_dispatch_order SET status='CANCELLED'");
+        assertThat(mapper.sources("11", null)).allMatch(s->s.scheduledPackages()==0);
         assertThat(mapper.sources("22", null)).hasSize(1).allMatch(s->s.scheduledPackages()==0);
     }
-    /** 已收货和扫码不能提前推进，出库来源快照不随剩余库存变化。 */
-    @Test void scheduledUsesOutboundSnapshotInsteadOfPlannedOrRemainingInventory() {
+    /** 已收货使用实际库存和扫码，不与计划量重复累计。 */
+    @Test void receivedPalletUsesInventoryAndActualPicksWithoutCountingBothPlanAndStock() {
         jdbc.update("UPDATE ll_dispatch_item SET warehouse_pallet_id=800");
         jdbc.update("INSERT INTO ll_inventory_balance VALUES(300,'11',1),(301,'11',2)");
         jdbc.update("INSERT INTO ll_inventory_position VALUES(400,'11',800,'W1',300,6),(401,'11',800,'W1',301,20)");
         jdbc.update("INSERT INTO ll_dispatch_pda_pick VALUES(600,'11',100,400,4,700)");
-        assertThat(mapper.sources("11", null)).allMatch(s->s.scheduledPackages()==0);
-        pendingOutbound(10000,"11",1,4);
-        pendingOutbound(10000,"11",2,20);
-        jdbc.update("UPDATE ll_inventory_position SET available_packages=0");
-        var sources=mapper.sources("11", null);assertThat(sources.get(0).scheduledPackages()).isEqualTo(4);
+        var sources=mapper.sources("11", null);assertThat(sources.get(0).scheduledPackages()).isEqualTo(10);
         assertThat(sources.get(1).scheduledPackages()).isEqualTo(20);
         assertThat(mapper.sources("11",java.util.List.of("101"))).containsExactly(sources.get(0));
     }
@@ -115,10 +95,8 @@ class CustomerOrderProgressMapperTest {
         assertThat(mapper.sources("11", null)).allMatch(s->s.deliveringPackages()==0);
     }
 
-    /** 同源多入仓片段完整返回，过滤不得扩大到其他订单或客户。 */
     @Test void exactSourceOrderScopePreservesAllOwnInboundFragmentsAndExcludesForeignOrders() {
         jdbc.update("INSERT INTO ll_order VALUES(4,'11','101','204','FIRSTLEG','FBA',5)");
-        pendingOutbound(10000,"11",1,10);
         var own=mapper.sources("11",java.util.List.of("101","103"));
         assertThat(own).extracting(s->s.orderId()).containsExactly("101","101");
         assertThat(own).extracting(s->s.scheduledPackages()).containsExactly(10L,0L);
@@ -126,30 +104,4 @@ class CustomerOrderProgressMapperTest {
         assertThat(mapper.sources("11",java.util.List.of("999"))).isEmpty();
     }
 
-    /** 多张出库只汇总本客户的有效来源数量，不借用其他来源或客户单据。 */
-    @Test void splitOutboundQuantitiesExcludeCancelledAndForeignDocuments() {
-        pendingOutbound(10000,"11",1,4);
-        pendingOutbound(10001,"11",1,6);
-        pendingOutbound(10002,"11",2,20);
-        jdbc.update("UPDATE ll_outbound_order SET status='CANCELLED' WHERE id=10001");
-        jdbc.update("INSERT INTO ll_outbound_order VALUES(10003,'22','WAIT_OUTBOUND')");
-        jdbc.update("INSERT INTO ll_outbound_pallet_item VALUES(10003,'11',1,100),(10000,'22',3,100),(10003,'22',1,100)");
-        assertThat(mapper.sources("11", null)).extracting(s->s.scheduledPackages()).containsExactly(4L,20L);
-        assertThat(new com.baiyue.lastleg.service.CustomerOrderProgressService(mapper).read(11,java.util.List.of(101L)).progress())
-            .singleElement().satisfies(p->{assertThat(p.stage()).isEqualTo("scheduled");assertThat(p.partial()).isTrue();});
-        assertThat(mapper.sources("22", null)).allMatch(s->s.scheduledPackages()==0);
-        jdbc.update("UPDATE ll_outbound_order SET status='WAIT_OUTBOUND' WHERE id=10001");
-        assertThat(mapper.sources("11", null)).extracting(s->s.scheduledPackages()).containsExactly(10L,20L);
-        assertThat(new com.baiyue.lastleg.service.CustomerOrderProgressService(mapper).read(11,java.util.List.of(101L)).progress())
-            .singleElement().satisfies(p->{assertThat(p.stage()).isEqualTo("scheduled");assertThat(p.partial()).isFalse();});
-    }
-
-    /** 创建同客户的待出库单及精确来源明细，允许一单包含多个来源。 */
-    private void pendingOutbound(long outboundId,String customerId,long sourceOrderId,int packages) {
-        if (jdbc.queryForObject("SELECT COUNT(*) FROM ll_outbound_order WHERE id=?",Integer.class,outboundId)==0) {
-            jdbc.update("INSERT INTO ll_outbound_order VALUES(?,?,'WAIT_OUTBOUND')",outboundId,customerId);
-        }
-        jdbc.update("INSERT INTO ll_outbound_pallet_item VALUES(?,?,?,?)",outboundId,customerId,sourceOrderId,packages);
-    }
-
 }

lastleg-service/src/test/resources/architecture/lastleg-slice-dependencies.json

@@ -59,22 +59,7 @@
     {
       "source": "com.baiyue.lastleg.fleet.outsourcedbusiness.model.OutsourcedBusinessModels",
       "target": "com.baiyue.lastleg.dispatch.port.DispatchViews",
-      "reason": "外配业务只组合原排车公开只读详情；精确边对应既有反向合同，不开放派送持久化或具体业务服务。"
-    },
-    {
-      "source": "com.baiyue.lastleg.dispatch.transport.TransportTaskService",
-      "target": "com.baiyue.lastleg.trucking.repository.UsTruckOrderRepository",
-      "reason": "本土卡车接入现有排车的本地事务编排：创建和执行先锁原单，防止普通原单命令并发推进；仅允许此编排器通过Repository访问，不批准Mapper或跨服务SQL。"
-    },
-    {
-      "source": "com.baiyue.lastleg.dispatch.transport.TransportTaskService",
-      "target": "com.baiyue.lastleg.trucking.entity.UsTruckOrder",
-      "reason": "同一锁单事务核对本土卡车真实起终点、实收托数和申报载重容积，不能用浏览器载荷替代原单；不构造库存或向API暴露原单写模型。"
-    },
-    {
-      "source": "com.baiyue.lastleg.dispatch.transport.TransportTaskProjection",
-      "target": "com.baiyue.lastleg.trucking.repository.UsTruckOrderRepository",
-      "reason": "同步运输事件与本土卡车状态必须同事务提交和回滚，旧内部执行入口也要同步原单并追加原单历史；取消释放有效原单关联，不合并客户和仓库归属。"
+      "reason": "外配装车后视图组合原排车公开只读详情，复用同一履约事实，不读取实体或写主单。"
     },
     {
       "source": "com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessModels",
@@ -375,26 +360,6 @@
       "source": "com.baiyue.lastleg.inboundplan.work.FbaAppointmentTransportAdapter",
       "target": "com.baiyue.lastleg.dispatch.port.DispatchTypes",
       "reason": "既有预约整车接线按已确认的排车统一作业契约调用JDK内部变更端口及公共命令/事实/枚举；仅批准此Adapter到此公共类型，不开放主流程实现、持久化或新增预约权威。"
-    },
-    {
-      "source": "com.baiyue.lastleg.fleet.business.FleetLooseboardDemandMapper",
-      "target": "com.baiyue.lastleg.looseboard.entity.LocalLooseboardOrder",
-      "reason": "客户原始散板需求匹配已有车次，确认承运复用原单；不跨服务读库、不创建第二商业单"
-    },
-    {
-      "source": "com.baiyue.lastleg.fleet.business.FleetLooseboardDemandRepository",
-      "target": "com.baiyue.lastleg.looseboard.entity.LocalLooseboardOrder",
-      "reason": "客户原始散板需求匹配已有车次，确认承运复用原单；不跨服务读库、不创建第二商业单"
-    },
-    {
-      "source": "com.baiyue.lastleg.fleet.business.FleetLooseboardDemandRepository",
-      "target": "com.baiyue.lastleg.looseboard.mapper.LocalLooseboardOrderMapper",
-      "reason": "客户原始散板需求匹配已有车次，确认承运复用原单；不跨服务读库、不创建第二商业单"
-    },
-    {
-      "source": "com.baiyue.lastleg.fleet.business.FleetLooseboardDemandService",
-      "target": "com.baiyue.lastleg.looseboard.entity.LocalLooseboardOrder",
-      "reason": "客户原始散板需求匹配已有车次，确认承运复用原单；不跨服务读库、不创建第二商业单"
     }
   ],
   "applicationDependencyRule": {

order/src/main/java/com/baiyue/order/service/UnifiedOrderQueryService.java

@@ -716,22 +716,13 @@ public class UnifiedOrderQueryService {
             || StringUtils.hasText(query.measurementReviewStatus());
     }
 
-    /** 保留内部调用的原始异常，便于按请求链路定位连接和协议故障。 */
     private <T> ApiResponse<T> call(java.util.concurrent.Callable<ApiResponse<T>> invocation) {
         try { return invocation.call(); }
-        catch (FeignException exception) {
-            throw (BizException) new BizException(ResultCode.SERVICE_UNAVAILABLE, "头程服务暂时不可用").initCause(exception);
-        }
-        catch (Exception exception) {
-            throw (BizException) new BizException(ResultCode.SERVICE_UNAVAILABLE, "头程服务查询失败").initCause(exception);
-        }
+        catch (FeignException exception) { throw new BizException(ResultCode.SERVICE_UNAVAILABLE, "头程服务暂时不可用"); }
+        catch (Exception exception) { throw new BizException(ResultCode.SERVICE_UNAVAILABLE, "头程服务查询失败"); }
     }
-    /** 失败关闭时保留下游错误码与链路标识，不记录业务载荷或服务令牌。 */
     private <T> T require(ApiResponse<T> response, String message) {
         if (response == null || !response.successful() || response.data() == null) {
-            LOGGER.warn("头程查询响应无效 operation={} downstreamCode={} downstreamMessage={} downstreamRequestId={} downstreamTraceId={}",
-                message, response == null ? null : response.code(), response == null ? null : response.message(),
-                response == null ? null : response.requestId(), response == null ? null : response.traceId());
             throw new BizException(ResultCode.SERVICE_UNAVAILABLE, message);
         }
         return response.data();

order/src/main/resources/openapi/order-v1.yaml

@@ -1743,7 +1743,7 @@ components:
       name: mainStatus
       in: query
       required: false
-      description: 统一订单主状态及业务页签筛选；WAIT_PALLETIZE、WAIT_SPLIT 与存量兼容状态 INBOUNDED 独立查询。WAIT_CUSTOMS_DOCS 为实际装柜后待上传客户报关资料；EXPORT_CUSTOMS 为本票报关资料已上传且实际装柜完成、尚未报关完成或实际开船的汇总，买单票无需客户退税资料，不以点击开始报关为前提；SAILING_CLEARANCE 在整柜报关完成后进入，也接受实际离港事实；清关资料保存成功后才进入 WAIT_UNLOAD/WAIT_DISPATCH。WAIT_UNLOAD 持续到实际卸柜或生成有效出库单；生成出库单后进入 OUTBOUND_DOCUMENT，实际出库后进入 DELIVERING，派送完成进入 SIGNED。
+      description: 统一订单主状态及业务页签筛选；WAIT_PALLETIZE、WAIT_SPLIT 与存量兼容状态 INBOUNDED 独立查询。WAIT_CUSTOMS_DOCS 为实际装柜后待上传客户报关资料；EXPORT_CUSTOMS 为本票报关资料已上传且实际装柜完成、尚未实际开船的汇总，买单票无需客户退税资料，不以点击开始报关为前提；SAILING_CLEARANCE 为实际开船后待上传清关资料；清关资料上传后进入 WAIT_UNLOAD，持续到实际卸柜完成。实际开船统一读取手动或拉取的实际离港节点。
       schema:
         type: string
         enum: [PENDING_REVIEW, WAIT_MEASURE, WAIT_PALLETIZE, INBOUNDED, WAIT_SPLIT, LOADING, LOADED, DELIVERED, COMPLETED, WAIT_WEIGHT_CONFIRM, WEIGHT_CONFIRMED, WAIT_CUSTOMS_DOCS, EXPORT_CUSTOMS, SAILING_CLEARANCE, WAIT_UNLOAD, WAIT_DISPATCH, OUTBOUND_DOCUMENT, DELIVERING, SIGNED, MEASUREMENT_REVIEW]

scripts/README.md

@@ -1,7 +1,5 @@
 # 后端脚本管理与全量 HTTP 验收索引
 
-`local-dispatch-transport-acceptance.mjs`：仅本机 LOCAL 的现有排车运输任务 HTTP 验收。显式 `node --env-file=<本机凭据文件>` 注入 `ADMIN_TEST_GATEWAY`、`ADMIN_TEST_USERNAME/PASSWORD`、`LOCAL_TRANSFER_PDA_PASSWORD`；拒绝远端网关。创建3张 TEST 仓储转运单、1张本土卡车原单、5张排车（完成/取消/重新安排），以及本轮专用调度/PDA账号、角色、车辆司机；缺失的正式排车权限仅补资源并授予专用角色，不修改既有角色。经正式网关验证原单审核、跨客户取货、资源冲突、凭证隔离、取消重排、发车完成回写、独立仓库清点和车辆司机释放。合成 PNG 只验文件链路，不代表实际运输或有效证照。默认报告 `reports/local-dispatch-transport.json`，可用 `TRANSPORT_ACCEPTANCE_OUTPUT` 指定；每步保留请求键、脱敏意图、错误码和关联标识，失败停止且保留数据。确认已知失败结果后显式 `TRANSPORT_ACCEPTANCE_RESUME=true` 复用同一报告继续；网络结果未知必须先核对，不自动清理或删除，不使用业务 SQL。已成功批次禁止重复运行；不能替代远端部署或人工截图验收。
-
 `local-check.ps1`：Windows / PowerShell 7 本机重型检查统一入口，适用于前后端测试、类型检查、构建、安装依赖及 Maven。示例：`& ./scripts/local-check.ps1 -WorkingDirectory ../apps/admin-web -Label 'Admin typecheck' -Command @('pnpm', 'typecheck')`；`-Status` 查看占用。当前用户所有工作目录共用一个文件句柄锁，默认排队900秒、执行1200秒；超时分别退出75/124，其余透传命令退出码。Vitest workers=2，Node堆2048MB，Java堆1536MB/处理器2；直接 Maven 自动单线程/单fork，直接 Node 内置测试自动并发2。Windows Job Object 仅回收本次后代，不接管旧进程；嵌套调用拒绝，批次内部执行原始命令。无凭据、不主动联网或写业务数据；被包装命令的环境授权不变。状态和最近结果仅写 `%LOCALAPPDATA%/Chongchong/LocalChecks/`，不存命令参数或输出；不自动缓存成功结果。失败保留最近摘要，确认输入后重新排队；锁文件无需手工删除，状态不是验收报告。完整规则见 `../../docs/AI工程执行与协作约束.md` 的“本机重型检查与多对话限流”；离线行为测试为 `local-check.test.mjs`。
 
 `local-transfer-pickup-acceptance.mjs`：仅本机 LOCAL 仓储转运取货造数与 HTTP 验收，拒绝非 localhost/127.0.0.1 Gateway。通过 `node --env-file=<本轮明确的本地配置> scripts/local-transfer-pickup-acceptance.mjs` 注入 `ADMIN_TEST_GATEWAY`、`ADMIN_TEST_USERNAME`、`ADMIN_TEST_PASSWORD`、`LOCAL_TRANSFER_PDA_PASSWORD`，不猜测或读取其他环境文件。创建16张明确 TEST 标记的业务单、专用PDA账号、司机车辆和多状态取货车次，含客户下单、跨客户共车、取消改派、资源占用、凭证隔离、送仓门禁与完整PDA测量。所有业务均走正式 Gateway HTTP，不用业务 SQL；文件是合成测试 PNG，不代表实际拍照或有效证照。报告默认 `reports/PICKUP-<新批次>.json`，可用 `PICKUP_ACCEPTANCE_OUTPUT` 指定；写入前保存脱敏意图与幂等键，逐阶段落盘。失败立即停止并保留已成功数据及报告，未知结果先核对原请求，不自动重发；重新执行会创建新批次，不自动续跑或清理旧记录。人工核实原请求结果后，可显式用 `PICKUP_ACCEPTANCE_RESUME=<本轮报告>` 沿已知单号继续验收；已成功批次禁止重复执行。脚本记录每次执行范围与结果，旧失败不删除；本机缺失的正式车次取消/结案/释放权限仅补权限资源并授权新建专用验收角色，不修改现有角色授权。账号和单据保留供本地页面验收，不能作为远端 TEST/生产或视觉验收结论。