fix: align customs warehouse arrival with appointment calendar

AGENTS.md

@@ -133,9 +133,9 @@
 - 后端同样遵守根指引中的“开发数据和上传文件可丢弃”边界：不得为现有开发库孤儿文件、旧文件归属或历史部分失败新增删除补偿接口、兼容复用、回填或清理链路；只修复当前正式上传与持久化路径，既有开发文件由人工重新上传。
 - 通用配置在 `config/nacos/test/`；服务日志、上传文件、`target/`、`reports/` 不属于源码。
 - 后端本地验证默认使用 `scripts/backend-check.ps1`，必须显式指定 `-Modules`，不传模块直接拒绝；命令及参数见 `scripts/README.md` 的“后端分层检查”。入口自动经 `local-check.ps1` 限流，`-DryRun` 只检查选择范围，不代表测试通过。
-- 局部逻辑使用 `-Mode Focused -Tests <精确测试类名>`，覆盖修改行为及必要边界即可交付，不因收尾再跑 `Module`。Java 签名变化须覆盖生产与测试源码编译；定向测试已编译时不重复跑 `-Mode Compile`。只有影响扩及服务内多个行为且定向覆盖不足才选 `Module`，先说明原因。跨服务 DTO、接口或事件变化显式列入生产者和实际消费者；`-am` 仅补上游构建依赖，不自动包含下游或 HTTP/事件消费者。
+- 开发迭代使用 `-Mode Focused -Tests <精确测试类名>`，覆盖修改行为及直接调用点；Java 签名变化至少使用 `-Mode Compile` 编译生产与测试源码（等价于 `mvn -pl <modules> -am test-compile`）。单服务行为变更收尾使用默认 `Module` 模式执行该服务及上游依赖测试；跨服务 DTO、接口或事件变化必须显式列入生产者和受影响消费者。`-am` 只补上游构建依赖，不自动包含下游服务或 HTTP/事件消费者；不能以单类测试代替模块收尾。
 - 仅注释/文档调整不触发 Java 回归；脚本调整执行受影响脚本测试和登记合同。API、Mapper、AGENTS 等静态合同仍按各自触发条件执行。纯重构也应覆盖受影响行为，不能只用编译宣称回归通过。`-Dmaven.test.skip=true` 跳过测试编译，不得作为签名变更交付验证。
-- 全仓回归仅用于已确认影响广泛且定向覆盖不足的公共依赖/聚合拓扑/认证/序列化/基础模型变化，或用户要求的全量/跨域集成验收；先说明具体影响，不能因未查清范围而全跑。根 POM、依赖或测试配置改动先按实际影响选编译或测试，不一律全仓。入口为 `scripts/backend-full-regression.ps1`，CI 全量保留。普通提交、单服务任务或对话收尾不触发；有效结果复用，输入变化只补跑受影响范围。
+- 全仓回归只在以下情况触发：根 POM/统一依赖版本/聚合拓扑/测试基础配置变化；公共认证、序列化、基础模型等影响广泛且不能可靠限定消费者；跨多域批次集成验收；用户明确要求全量回归。使用 `scripts/backend-full-regression.ps1`，保留当前 CI 全量验证。普通单服务任务、单次提交或对话收尾不自动触发全仓；已明确消费者的公共或跨服务变更按受影响模块验证。同批同一相关输入只跑一次，输入变化后补跑受影响范围，触及上述全量条件再重跑全量。
 - 不以缩短耗时为由删除金额、库存、权限隔离、状态流转、幂等和并发测试；冗余测试须根据重复场景及维护成本单独评估。不要在本地启动 Java/Nacos/数据库，除非用户明确要求。
 - 同一批 `AGENTS.md` 索引修改完成后从后端根统一运行一次 `./scripts/agents-index-contract.ps1`；脚本只读源码目录和指定指引，不访问 HTTP、数据库或部署环境。
 - Mapper 注册静态合同为 `scripts/mapper-scan-contract.mjs`、`mapper-scan-contract.test.mjs`：自动发现聚合模块、生产 `*Mapper` 接口、服务启动类和分散扫描配置，不启动 Spring、不连接数据库；遗漏注解、扫描根漂移或重新引入子域扫描时直接失败并输出类与文件路径。

Jenkinsfile

@@ -161,8 +161,7 @@ pipeline {
         choice(name: 'ENVIRONMENT', choices: environmentChoicesForJob(env.JOB_BASE_NAME), description: '部署环境')
         booleanParam(name: 'DEPLOY', defaultValue: false, description: '各服务构建成功后是否独立部署')
         booleanParam(name: 'SKIP_TESTS', defaultValue: false, description: '是否跳过测试执行（仍编译测试源码）')
-        // 地址由当前 Job 配置提供；参数声明刷新时保留已配置值，不将环境地址写入源码。
-        string(name: 'IMAGE_REPOSITORY', defaultValue: params.IMAGE_REPOSITORY ?: '', description: '沿用当前 Job 已配置的镜像仓库地址；首次配置或更换仓库时填写 host[:port]/owner/image')
+        string(name: 'IMAGE_REPOSITORY', defaultValue: '', description: '必须填写已核实的共享镜像仓库地址 host[:port]/owner/image')
         string(name: 'DOCKER_BASE_IMAGE', defaultValue: 'eclipse-temurin:17-jre-alpine', description: 'Java 17 基础镜像')
         choice(name: 'DOWNSTREAM_JOB_PREFIX', choices: downstreamJobPrefixChoicesForJob(env.JOB_BASE_NAME), description: '由当前总控 Job 固定的单服务 Job 前缀')
     }

Jenkinsfile.service

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

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

@@ -429,7 +429,6 @@ CREATE TABLE ll_dispatch_order (
   review_state VARCHAR(32) NOT NULL DEFAULT 'DRAFT' COMMENT '审核子流程当前状态',
   review_round BIGINT NOT NULL DEFAULT 0 COMMENT '当前审核轮次',
   review_basis_hash CHAR(64) NULL COMMENT '本审核轮次核对的货物和资源依据摘要',
-  exceptions_json JSON NULL COMMENT '派送异常登记记录及图片引用，不改变派送及库存状态',
   dispatch_review_json JSON NULL COMMENT '当前调度审核事实快照',
   loading_review_json JSON NULL COMMENT '当前理货审核事实快照',
   resources_json JSON NULL COMMENT '本趟主档或临时车辆司机的真实资源快照',

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

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

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

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

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

@@ -30,7 +30,6 @@ import static org.mockito.Mockito.*;
 
 class DispatchEvidenceFileTest {
     private static final String VEHICLE = "OVERSEAS_DISPATCH_VEHICLE_EVIDENCE";
-    private static final String EXCEPTION = "OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE";
     private static final String PHOTO = "OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE";
     private static final String DRIVER = "OVERSEAS_DISPATCH_DRIVER_EVIDENCE";
     private static final int MAX_BYTES = 10 * 1024 * 1024;
@@ -44,7 +43,7 @@ class DispatchEvidenceFileTest {
 
     /** 三类证据只接受平台与有效排车内部 ID，非法输入不得访问数据库或磁盘。 */
     @ParameterizedTest
-    @ValueSource(strings = {VEHICLE, DRIVER, PHOTO, EXCEPTION})
+    @ValueSource(strings = {VEHICLE, DRIVER, PHOTO})
     void requiresPlatformAndPositiveDispatchIdBeforeAccess(String type) {
         var files = mock(FileObjectMapper.class);
         var storage = mock(BusinessFileStorage.class);
@@ -66,10 +65,9 @@ class DispatchEvidenceFileTest {
         verifyNoInteractions(files, storage);
     }
 
-    /** 司机照片与异常图片使用独立平台类别，拒绝PDF和伪造图片。 */
-    @ParameterizedTest @ValueSource(strings = {PHOTO, EXCEPTION})
-    void photoAcceptsOnlyRealImages(String type) throws Exception {
-        var storage=storage();var category=BusinessFileCategory.require(type);
+    /** 司机本人照片使用独立平台类别，只保存真实图片，拒绝PDF和伪造图片。 */
+    @org.junit.jupiter.api.Test void driverPhotoAcceptsOnlyRealImages() throws Exception {
+        var storage=storage();var category=BusinessFileCategory.require(PHOTO);
         for(var format:new String[]{"jpeg","png"}) {
             var upload=new MockMultipartFile("file","driver."+format,"image/"+format,image(format));
             var saved=storage.store(0,"71",upload,category);
@@ -164,7 +162,7 @@ class DispatchEvidenceFileTest {
 
     /** 元数据和下载均逐列带全复合键；错车、错类别、错文件不得读取存储内容。 */
     @ParameterizedTest
-    @ValueSource(strings = {VEHICLE, DRIVER, PHOTO, EXCEPTION})
+    @ValueSource(strings = {VEHICLE, DRIVER, PHOTO})
     void metadataAndDownloadEnforceEveryScopeKeyBeforeReading(String type) throws Exception {
         var files = mock(FileObjectMapper.class);
         var storage = mock(BusinessFileStorage.class);

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/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/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 {

lastleg-service/AGENTS.md

@@ -77,7 +77,7 @@
 | 整车调度与理货审核 | `dispatch/controller/DispatchAggregateController.java` → `dispatch/service/DispatchAggregateService.java` 的提交及两级审核；同一排车先调度审核、再理货审核，通过后才允许真实扫码。资源、货物或路线关键变更使原依据失效；零扫码显式退回后重新审核，不复用旧客户子单审核状态 |
 | 外接询价、确认占位及取消 | `fleet/trip/PlatformFleetBookingController.java`、`FleetBookingService.java`、`FleetBookingReservations.java`；客户从`fleet/customer/`读取IAM有效主档与资格，询价不占位，确认后与自有货计划共同校验逐段容量。约定金额不代表应收/实收，`FleetBookingIncomingGateway`由`transfer/fleet/FleetIncomingAdapter`实现来货登记/实收确认，排车关联通过`FleetDispatchGateway.sourceCargo`核对实收来源 |
 | 拣货前计划容量与逐段余位 | `FleetTripExecutionService.capacityPlan/confirmCapacityPlan`、`/fleet/trips/{tripNo}/capacity-plan`；保存自有货的计划值，不检查拣货完成、不推进审核或扣库存；`planValid`校验当前货物hash，不把计划值当实测值，资源/计划/关联变更后须重新核对 |
-| 实物装载、逐段容量与双端整车发车 | 两端`dispatches/{dispatchNo}/loading-complete`统一调用`dispatch/service/DispatchLoadingDepartureService.java`，实载确认成功进入`AFTER_LOADING`；请求携带唯一`recordVersion`，原键恢复原装车后结果。`dispatch/service/DispatchLoadingDocumentService.java`复用整车附加照片与账本，平台/PDA均经`loading-documents`保存；五框齐全的最后一次绑定与派送准备、发车同事务，成功`DELIVERING`。公开手工安排派送、`/depart`入口仍不开放。真实PDA拣货须核平，不重复库存SHIP，Fleet容量和资源资格仍复核；未知费用不补零、不阻塞发运，真实已明确外接报价沿原费用来源防重 |
+| 实物装载、逐段容量与双端整车发车 | 两端`dispatches/{dispatchNo}/loading-complete`统一调用`dispatch/service/DispatchLoadingDepartureService.java`，同一事务复用实载确认、派送单准备及发车，成功直接`DELIVERING`；请求携带唯一`recordVersion`，原键恢复最终结果。公开手工安排派送、`/depart`入口已移除；内部`AFTER_LOADING`和步骤命令只用于事务编排。真实PDA拣货须核平，不重复库存SHIP，Fleet容量和资源资格仍复核；未知费用不补零、不阻塞发运，真实已明确外接报价沿原费用来源防重 |
 | 车次货物结案、车辆和司机分别释放 | `fleet/trip/FleetTripCompletionService.java`、`FleetCompletionModels.java`；平台 `/fleet/trips/{tripNo}/completion`、`/complete`、`/resources/release`，独立complete/release权限。结案核对所有派送终态与实发数量；实际任务结束时间/地点及车辆结束状态单独记录，不以结案或收款自动释放资源 |
 | 跨服务 HTTP 客户端装配 | `config/LastlegRestClientFactory.java` |
 | 数据库基线、表索引与中文注释契约 | `src/main/resources/db/lastleg.sql` |

lastleg-service/docs/lastleg-internal-modularization-baseline.md

@@ -28,10 +28,6 @@
 
 `fleet.ownedbusiness`只为原排车装车后的自有车辆组合运营资料。五条精确引用限`OwnedBusinessModels→DispatchViews`、`OwnedBusinessProjection→DispatchContracts`、`OwnedBusinessQueryService→DispatchContracts/DispatchTypes/DispatchDetailReader`，均为`dispatch.port`公开事实或只读应用端口；不增加`fleet→dispatch-delivery`通用许可，不共享原排车实体、Mapper或具体Service。原详情适配器在dispatch内部委托唯一提供者。`DispatchAggregateService→OwnedBusinessOwnershipCapture`仅在原装车事务捕获归属，不能反向调用运营查询；捕获失败随原确认回滚。反向合同拒绝具体持久化/Service引用、其他消费者借用端口许可及任何包循环。
 
-### 装车资料触发派送边界（2026-10-21）
-
-`DispatchLoadingDocumentService`、`DispatchLoadingDepartureService`及平台/PDA两个装车资料Controller只引用`fleet.ownedbusiness.port.DispatchLoadingPhotoPort`的公开照片、版本、绑定请求和结果。`DispatchLoadingPhotoAdapter`在车队内部复用原附加表、上传账本和文件校验，不反向调用排车服务。排车服务持整车父锁，在装车确认或资料保存后核对两项条件，同一事务推进派送并记录原结果。结构门禁仅开放上述四类到此端口的精确引用，不开放车队Service、Repository或Mapper，也不新增包循环。
-
 ### 外配业务原排车详情读取边界（2026-10-21）
 
 `OutsourcedBusinessModels → DispatchViews` 仅组合既有 `dispatch.port` 公开详情。依赖登记与已有外配反向合同同步，不开放 `fleet→dispatch-delivery` 通用许可；原排车实体、Mapper、具体 Service 及其他消费者仍由门禁拒绝。

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

@@ -72,11 +72,6 @@ test('fleet stays a business slice and its policies have no infrastructure depen
       && 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'
-    || ['com.baiyue.lastleg.dispatch.service.DispatchLoadingDocumentService',
-      'com.baiyue.lastleg.dispatch.service.DispatchLoadingDepartureService',
-      'com.baiyue.lastleg.dispatch.controller.DispatchLoadingDocumentController',
-      'com.baiyue.lastleg.dispatch.pda.controller.PdaDispatchLoadingDocumentController'].includes(edge.source)
-      && edge.target === 'com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort'
     || [
       'TransportTaskModels->pickup.FleetPickupModels', 'TransportTaskModels->trip.FleetTripModels',
       'TransportTaskProjection->trip.FleetTripEntity', 'TransportTaskProjection->trip.TransportTripChanged',

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/controller/DispatchAggregateController.java

@@ -77,12 +77,6 @@ public class DispatchAggregateController {
     public ApiResponse<CommandResult> loadingComplete(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@RequestBody DispatchCommands.LoadingComplete request) {
         return ApiResponse.success(loadingDeparture.complete(DispatchActorFactory.platform(user),dispatchNo,request));
     }
-    /** 派送异常登记不触发签收或退货入库。 */
-    @PostMapping("/{dispatchNo}/exceptions")
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<CommandResult> markException(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@RequestBody DispatchCommands.MarkException request) {
-        return ApiResponse.success(service.markException(DispatchActorFactory.platform(user),dispatchNo,request));
-    }
     /** 本车证据先上传；维护和当前待审权限分别由服务端核验，引用随对应命令保存。 */
     @PostMapping(value="/{dispatchNo}/evidence/{kind}",consumes=org.springframework.http.MediaType.MULTIPART_FORM_DATA_VALUE)
     @PreAuthorize("hasAnyAuthority('platform:overseas-warehouse:dispatch:edit','platform:fleet:trip:dispatch-review','platform:fleet:trip:loading-review')")

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/controller/DispatchLoadingDocumentController.java

@@ -1,60 +0,0 @@
-package com.baiyue.lastleg.dispatch.controller;
-
-import com.baiyue.common.core.api.ApiResponse;
-import com.baiyue.common.security.AuthenticatedUser;
-import com.baiyue.lastleg.dispatch.controller.DispatchActorFactory;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort.*;
-import com.baiyue.lastleg.dispatch.service.DispatchLoadingDocumentService;
-import jakarta.validation.Valid;
-import jakarta.validation.constraints.*;
-import org.springframework.http.*;
-import org.springframework.security.access.prepost.PreAuthorize;
-import org.springframework.security.core.annotation.AuthenticationPrincipal;
-import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.*;
-import org.springframework.web.multipart.MultipartFile;
-
-/** 平台排车装车资料入口，与另一端共用五框和自动派送门禁。 */
-@RestController
-@Validated
-@RequestMapping("/api/platform/v1/last-leg/dispatches/{dispatchNo}/loading-documents")
-public class DispatchLoadingDocumentController {
-    private final DispatchLoadingDocumentService service;
-    /** Controller只负责会话与输入映射，所有资料和状态规则归服务。 */
-    public DispatchLoadingDocumentController(DispatchLoadingDocumentService service){this.service=service;}
-    /** 读取本车已保存照片，不以设备缓存作为上传事实。 */
-    @GetMapping
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:list')")
-    public ApiResponse<Documents> get(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo) {
-        return ApiResponse.success(service.get(DispatchActorFactory.platform(user),dispatchNo));
-    }
-    /** 上传先记录原请求，成功回执后再保存本车槽位引用。 */
-    @PostMapping(value="/{slot}/uploads",consumes=MediaType.MULTIPART_FORM_DATA_VALUE)
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<Photo> upload(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable Slot slot,
-        @RequestParam @Size(min=8,max=128) String idempotencyKey,@RequestPart("file") MultipartFile file) {
-        return ApiResponse.success(service.upload(DispatchActorFactory.platform(user),dispatchNo,slot,idempotencyKey,file));
-    }
-    /** 最后一框保存成功时自动进入派送中，不新增人工发车按钮。 */
-    @PutMapping("/{slot}")
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<Documents> bind(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,
-        @PathVariable Slot slot,@Valid @RequestBody BindPhoto request) {
-        return ApiResponse.success(service.bind(DispatchActorFactory.platform(user),dispatchNo,slot,request));
-    }
-    /** 原上传仅允许当前有权限的原操作者恢复。 */
-    @GetMapping("/uploads/{idempotencyKey}")
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<Photo> recover(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable String idempotencyKey) {
-        return ApiResponse.success(service.recover(DispatchActorFactory.platform(user),dispatchNo,idempotencyKey));
-    }
-    /** 每次预览核对本车当前绑定，文件不得跨车跨仓读取。 */
-    @GetMapping("/{slot}/files/{fileId}/content")
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:list')")
-    public ResponseEntity<byte[]> content(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable Slot slot,@PathVariable @Positive long fileId) {
-        var value=service.content(DispatchActorFactory.platform(user),dispatchNo,slot,fileId);
-        return ResponseEntity.ok().cacheControl(CacheControl.noStore()).contentType(MediaType.parseMediaType(value.photo().contentType()))
-            .header("X-Content-Type-Options","nosniff").body(value.content());
-    }
-}
-

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/controller/SmartDispatchController.java

@@ -26,7 +26,7 @@ public class SmartDispatchController {
     /** 读取实际候选，不在草稿域复制来源筛选逻辑。 */
     @GetMapping("/candidates")
     @PreAuthorize("hasAuthority('"+OverseasPermissions.DISPATCH_LIST+"')")
-    public ApiResponse<CandidateList> candidates(@AuthenticationPrincipal AuthenticatedUser user,@RequestParam(required=false) String warehouseId,
+    public ApiResponse<CandidateList> candidates(@AuthenticationPrincipal AuthenticatedUser user,@RequestParam String warehouseId,
         @RequestParam(required=false)List<Long> planIds,@RequestParam(required=false)String orderNo,
         @RequestParam(required=false)String destinationWarehouseCode,@RequestParam(required=false)String sourceStage,@RequestParam(required=false)String draftToken,
         @RequestParam(defaultValue="1")int page,@RequestParam(defaultValue="20")int size,@RequestParam(defaultValue="ALL")String warehouseTab) {

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

@@ -24,7 +24,6 @@ public class DispatchAggregate {
     private String dispatchReviewJson;
     private String loadingReviewJson;
     private String resourcesJson;
-    private String exceptionsJson;
     private String vehiclePlate;
     private String route;
     private LocalDateTime plannedDepartureAt;

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/gateway/DispatchEvidenceGateway.java

@@ -4,7 +4,7 @@ import org.springframework.web.multipart.MultipartFile;
 
 /** 车辆、司机及审核补充证据属于本张整车，不能借司机主档或客户文件授权。 */
 public interface DispatchEvidenceGateway {
-    enum Kind { VEHICLE, DRIVER, DRIVER_PHOTO, EXCEPTION }
+    enum Kind { VEHICLE, DRIVER, DRIVER_PHOTO }
     record File(Long fileId,String fileName,String contentType,long sizeBytes) { }
     /** 上传只写本车、本类证据。 */
     File upload(long dispatchId,Kind kind,String operator,MultipartFile file);

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/gateway/HttpDispatchEvidenceGateway.java

@@ -83,9 +83,9 @@ public class HttpDispatchEvidenceGateway implements DispatchEvidenceGateway {
             || !supportedType(kind,value.contentType()) || value.sizeBytes()==null || value.sizeBytes()<=0 || value.sizeBytes()>MAX)throw invalid();
         return new File(value.fileId(),value.fileName(),value.contentType(),value.sizeBytes());
     }
-    /** 司机本人照片与异常证据只接受图片；车辆和驾驶证沿现有PDF/图片证据规则。 */
+    /** 司机本人照片只接受图片；车辆和驾驶证沿现有PDF/图片证据规则。 */
     private static boolean supportedType(Kind kind,String contentType) {
-        return TYPES.contains(Objects.toString(contentType,"")) && ((kind!=Kind.DRIVER_PHOTO && kind!=Kind.EXCEPTION) || !"application/pdf".equals(contentType));
+        return TYPES.contains(Objects.toString(contentType,"")) && (kind!=Kind.DRIVER_PHOTO || !"application/pdf".equals(contentType));
     }
     /** 无效证据不能作为已核实资料。 */
     private static ResponseStatusException invalid(){return new ResponseStatusException(HttpStatus.BAD_REQUEST,"证据须为本车有效PDF、JPG或PNG，最大10MiB");}

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

@@ -94,11 +94,11 @@ public interface DispatchAggregateMapper {
         UPDATE ll_dispatch_order SET status=#{r.status},stage=#{r.stage},record_version=#{r.recordVersion},
           review_state=#{r.reviewState},review_round=#{r.reviewRound},review_basis_hash=#{r.reviewBasisHash},
           dispatch_review_json=#{r.dispatchReviewJson},loading_review_json=#{r.loadingReviewJson},
-          exceptions_json=#{r.exceptionsJson},cargo_hash=#{r.cargoHash},cargo_revision=#{r.cargoRevision},resources_json=#{r.resourcesJson},vehicle_plate=#{r.vehiclePlate},planned_departure_at=#{r.plannedDepartureAt},
+          cargo_hash=#{r.cargoHash},cargo_revision=#{r.cargoRevision},resources_json=#{r.resourcesJson},vehicle_plate=#{r.vehiclePlate},planned_departure_at=#{r.plannedDepartureAt},
           estimated_arrival_at=#{r.estimatedArrivalAt},remark=#{r.remark},loading_completed_at=#{r.loadingCompletedAt},
           loading_completion_hash=#{r.loadingCompletionHash},loading_confirmation_json=#{r.loadingConfirmationJson},arrangement_key=#{r.arrangementKey},
           arrangement_business_hash=#{r.arrangementBusinessHash},departed_at=#{r.departedAt},
-          delivery_completed_at=#{r.deliveryCompletedAt},package_count=#{r.packageCount},pallet_count=#{r.palletCount},picked_package_count=#{r.pickedPackageCount},
+          delivery_completed_at=#{r.deliveryCompletedAt},picked_package_count=#{r.pickedPackageCount},
           shipped_package_count=#{r.shippedPackageCount},updated_at=#{r.updatedAt}
         WHERE id=#{r.id} AND record_version=#{version}
         """)

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

@@ -50,8 +50,7 @@ public interface DispatchCandidatePageMapper {
         }
         /** 仓库页签也是服务端筛选，分页后不能再用本地筛选伪装完整结果。 */
         private static String filtered(boolean count) {
-            return " FROM ("+rows(count)+") candidates WHERE 1=1"
-                +"<if test='query.warehouseId != null'> AND overseasWarehouseId=#{query.warehouseId}</if>"
+            return " FROM ("+rows(count)+") candidates WHERE overseasWarehouseId=#{query.warehouseId}"
                 +"<if test='query.destinationWarehouseCode != null'> AND fbaWarehouseCode=#{query.destinationWarehouseCode}</if>"
                 +"<if test=\"query.warehouseTab == 'LAX'\"> AND LOWER(CONCAT(COALESCE(overseasWarehouseCode,''),' ',COALESCE(overseasWarehouseName,''))) REGEXP 'lax|洛杉矶|los angeles'</if>"
                 +"<if test=\"query.warehouseTab == 'NYC'\"> AND LOWER(CONCAT(COALESCE(overseasWarehouseCode,''),' ',COALESCE(overseasWarehouseName,''))) REGEXP 'nyc|jfk|(^|[^a-z])ny([^a-z]|$)|纽约|new[ -]?york'</if>";

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

@@ -93,11 +93,6 @@ public interface DispatchSourceMapper {
     @Select("SELECT p.id FROM ll_inbound_plan_pallet p JOIN ll_inbound_plan ip ON ip.id=p.plan_id WHERE p.id=#{id} AND ip.customer_id=#{customer} FOR UPDATE")
     Long lockPlanPallet(@Param("customer") String customer, @Param("id") Long id);
 
-    /** 原计划完成实收后才能把预排估算替换为实际整托数量，避免收货中提前锁定半托。 */
-    @Select("SELECT COUNT(*) FROM ll_inbound_plan_pallet p JOIN ll_inbound_plan ip ON ip.id=p.plan_id AND ip.customer_id=p.customer_id "
-        + "WHERE p.id=#{id} AND p.customer_id=#{customer} AND ip.status IN ('COMPLETED','PENDING_RECONCILIATION')")
-    int receivedPlanCompleted(@Param("customer") String customer,@Param("id") Long id);
-
     /** 退回来源仍使用本票实际实收，不借普通入仓别名。 */
     @Select("SELECT id FROM ll_return_stock_receipt WHERE id=#{id} AND customer_id=#{customer} FOR UPDATE")
     Long lockReturn(@Param("customer") String customer, @Param("id") Long id);

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/pda/controller/DispatchPdaController.java

@@ -57,7 +57,7 @@ public class DispatchPdaController {
         return ApiResponse.success(workflow.loading(DispatchActorFactory.pda(user),dispatchNo));
     }
 
-    /** 真实扫码核平后确认装车进入装车后，两端共用同一命令并等待五张装车照片。 */
+    /** 真实扫码核平后确认装车即发车，两端使用同一事务命令。 */
     @PostMapping("/{dispatchNo}/loading-complete")
     public ApiResponse<DispatchContracts.CommandResult> loadingComplete(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@RequestBody DispatchCommands.LoadingComplete request) {
         return ApiResponse.success(loadingDeparture.complete(DispatchActorFactory.pda(user),dispatchNo,request));

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/pda/controller/PdaDispatchLoadingDocumentController.java

@@ -1,60 +0,0 @@
-package com.baiyue.lastleg.dispatch.pda.controller;
-
-import com.baiyue.common.core.api.ApiResponse;
-import com.baiyue.common.security.AuthenticatedUser;
-import com.baiyue.lastleg.dispatch.controller.DispatchActorFactory;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort.*;
-import com.baiyue.lastleg.dispatch.service.DispatchLoadingDocumentService;
-import jakarta.validation.Valid;
-import jakarta.validation.constraints.*;
-import org.springframework.http.*;
-import org.springframework.security.access.prepost.PreAuthorize;
-import org.springframework.security.core.annotation.AuthenticationPrincipal;
-import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.*;
-import org.springframework.web.multipart.MultipartFile;
-
-/** 绑定仓PDA装车资料入口，与另一端共用五框和自动派送门禁。 */
-@RestController
-@Validated
-@RequestMapping("/api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-documents")
-public class PdaDispatchLoadingDocumentController {
-    private final DispatchLoadingDocumentService service;
-    /** Controller只负责会话与输入映射，所有资料和状态规则归服务。 */
-    public PdaDispatchLoadingDocumentController(DispatchLoadingDocumentService service){this.service=service;}
-    /** 读取本车已保存照片，不以设备缓存作为上传事实。 */
-    @GetMapping
-    @PreAuthorize("hasAuthority('lastleg:pda:operate') and hasAuthority('ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR')")
-    public ApiResponse<Documents> get(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo) {
-        return ApiResponse.success(service.get(DispatchActorFactory.pda(user),dispatchNo));
-    }
-    /** 上传先记录原请求，成功回执后再保存本车槽位引用。 */
-    @PostMapping(value="/{slot}/uploads",consumes=MediaType.MULTIPART_FORM_DATA_VALUE)
-    @PreAuthorize("hasAuthority('lastleg:pda:operate') and hasAuthority('ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR')")
-    public ApiResponse<Photo> upload(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable Slot slot,
-        @RequestParam @Size(min=8,max=128) String idempotencyKey,@RequestPart("file") MultipartFile file) {
-        return ApiResponse.success(service.upload(DispatchActorFactory.pda(user),dispatchNo,slot,idempotencyKey,file));
-    }
-    /** 最后一框保存成功时自动进入派送中，不新增人工发车按钮。 */
-    @PutMapping("/{slot}")
-    @PreAuthorize("hasAuthority('lastleg:pda:operate') and hasAuthority('ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR')")
-    public ApiResponse<Documents> bind(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,
-        @PathVariable Slot slot,@Valid @RequestBody BindPhoto request) {
-        return ApiResponse.success(service.bind(DispatchActorFactory.pda(user),dispatchNo,slot,request));
-    }
-    /** 原上传仅允许当前有权限的原操作者恢复。 */
-    @GetMapping("/uploads/{idempotencyKey}")
-    @PreAuthorize("hasAuthority('lastleg:pda:operate') and hasAuthority('ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR')")
-    public ApiResponse<Photo> recover(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable String idempotencyKey) {
-        return ApiResponse.success(service.recover(DispatchActorFactory.pda(user),dispatchNo,idempotencyKey));
-    }
-    /** 每次预览核对本车当前绑定，文件不得跨车跨仓读取。 */
-    @GetMapping("/{slot}/files/{fileId}/content")
-    @PreAuthorize("hasAuthority('lastleg:pda:operate') and hasAuthority('ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR')")
-    public ResponseEntity<byte[]> content(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable Slot slot,@PathVariable @Positive long fileId) {
-        var value=service.content(DispatchActorFactory.pda(user),dispatchNo,slot,fileId);
-        return ResponseEntity.ok().cacheControl(CacheControl.noStore()).contentType(MediaType.parseMediaType(value.photo().contentType()))
-            .header("X-Content-Type-Options","nosniff").body(value.content());
-    }
-}
-

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

@@ -73,13 +73,6 @@ public final class DispatchCommands {
         public LoadingComplete { recordVersion = requireVersion(recordVersion); }
     }
 
-    /** 派送异常仅登记事实，不改变派送、签收或库存。 */
-    public record MarkException(Long recordVersion, String idempotencyKey, ExceptionType exceptionType,
-                                ReturnDirection returnDirection, String description, List<Long> imageFileIds) {
-        /** 必填版本用于阻止过期页面覆盖当前排车。 */
-        public MarkException { recordVersion = requireVersion(recordVersion); }
-    }
-
     public record Depart(Long recordVersion, String idempotencyKey, String remark) {
         /** 实际发车不得接受缺省版本。 */
         public Depart { recordVersion = requireVersion(recordVersion); }

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

@@ -25,10 +25,7 @@ public final class DispatchContracts {
 
     /** 临时资源证据只归本趟，不能据此自动建车辆或司机主档。 */
     public record DriverEvidence(String licenseNo, LocalDate licenseExpiresOn,
-                                 List<Long> fileIds, Instant expectedTaskEndAt, List<Long> photoFileIds) {
-        /** 司机照片独立于驾驶证，缺省为空且引用须有界、有效、不重复。 */
-        public DriverEvidence { photoFileIds = ReviewAttachments.checked(photoFileIds); }
-    }
+                                 List<Long> fileIds, Instant expectedTaskEndAt) { }
 
     public record VehicleSnapshot(ResourceMode mode, Long vehicleId, String plate,
                                   String carrierName, String vehicleStatus, Capacity capacity,

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

@@ -9,8 +9,6 @@ public final class DispatchTypes {
     public enum Stage { BEFORE_LOADING, LOADING, AFTER_LOADING, DELIVERING, DELIVERED }
     public enum ReviewState { DRAFT, DISPATCH_PENDING, DISPATCH_REJECTED, LOADING_PENDING, LOADING_REJECTED, APPROVED }
     public enum ReviewStatus { NOT_SUBMITTED, PENDING, APPROVED, REJECTED }
-    public enum ExceptionType { REFUSED, PARTIAL_RECEIPT, VEHICLE_EXCEPTION }
-    public enum ReturnDirection { OVERSEAS_WAREHOUSE, OTHER }
     public enum Decision { APPROVED, REJECTED }
     public enum ResourceMode { MASTER, EXTERNAL }
     public enum ActorMode { PLATFORM, PDA }
@@ -20,6 +18,6 @@ public final class DispatchTypes {
     public enum Effect { APPLIED, EXISTING }
     public enum Action {
         CREATE, EDIT, ADD_CARGO, REMOVE_CARGO, CANCEL, SUBMIT_REVIEW, DISPATCH_REVIEW,
-        LOADING_REVIEW, RETURN_TO_REVIEW, PICK, LOADING_COMPLETE, ARRANGE_DELIVERY, DEPART, MARK_EXCEPTION
+        LOADING_REVIEW, RETURN_TO_REVIEW, PICK, LOADING_COMPLETE, ARRANGE_DELIVERY, DEPART
     }
 }

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

@@ -44,11 +44,7 @@ public final class DispatchViews {
 
     public record DispatchInfo(String route, Instant plannedDepartureAt, Instant departedAt,
                                  Instant estimatedArrivalAt, List<FbaAppointment> fbaAppointments,
-                                 List<BatchReference> appointmentBatches, List<ExceptionRecord> exceptions) { }
-
-    /** 排车级异常记录；退货去向只描述安排，不产生退货入库事实。 */
-    public record ExceptionRecord(ExceptionType exceptionType, ReturnDirection returnDirection,
-                                  String description, List<Long> imageFileIds, Instant occurredAt) { }
+                                 List<BatchReference> appointmentBatches) { }
 
     public record Documents(String dispatchNo, List<DispatchDeliveryModels.OutboundReference> outbounds,
                               List<DispatchDeliveryModels.DeliveryReference> deliveries,

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/repository/DispatchSourceRepository.java

@@ -74,8 +74,6 @@ public class DispatchSourceRepository {
     public Long lockOrder(String customer, Long id) { return source.lockOrder(customer,id); }
     /** 锁定真实计划托盘根。 */
     public Long lockPlan(String customer, Long id) { return source.lockPlanPallet(customer,id); }
-    /** 只读核对原计划已经结束实际收货。 */
-    public boolean receivedPlanCompleted(String customer,Long id){return source.receivedPlanCompleted(customer,id)==1;}
     /** 锁定实际退回收据根。 */
     public Long lockReturn(String customer, Long id) { return source.lockReturn(customer,id); }
     /** 真实库存数量及版本。 */

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

@@ -51,7 +51,6 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
     @jakarta.annotation.Resource private com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway evidence;
     @jakarta.annotation.Resource private com.baiyue.lastleg.dispatch.repository.DispatchExecutionRepository executionReads;
     @jakarta.annotation.Resource private OwnedBusinessOwnershipCapture ownedBusinessOwnership;
-    @jakarta.annotation.Resource private com.baiyue.lastleg.dispatch.transport.TransportTaskService transportTasks;
 
     /** 领域编排只访问Repository和提供者应用入口。 */
     public DispatchAggregateService(DispatchAggregateRepository repository, DispatchSourceRepository sources,
@@ -147,8 +146,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
     @Transactional(readOnly=true,isolation=Isolation.REPEATABLE_READ)
     public DispatchPlanningModels.CandidateList candidates(Actor actor,DispatchPlanningModels.CandidateQuery query) {
         requirePlatform(actor);
-        // 未指定起运仓时按区域浏览；写入草稿仍由来源确定唯一真实起运仓。
-        if(query==null || query.warehouseId()!=null && !query.warehouseId().matches("[1-9][0-9]*")) throw bad("起运仓筛选无效");
+        if(query==null || query.warehouseId()==null || !query.warehouseId().matches("[1-9][0-9]*")) throw bad("请选择真实海外起运仓");
         if(query.planIds()!=null && (query.planIds().size()>500 || query.planIds().stream().anyMatch(id->id==null || id<=0))) throw bad("计划筛选不合法");
         if(query.page()<1 || query.size()<1 || query.size()>50 || !Set.of("ALL","LAX","NYC").contains(Objects.toString(query.warehouseTab(),"")))throw bad("候选分页或仓库页签不合法");
         var normalized=new DispatchPlanningModels.CandidateQuery(query.warehouseId(),query.planIds(),trim(query.orderNo()),
@@ -240,12 +238,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
     /** 上传只返回本车证据；待审按当前审核权限授权，客服阶段按维护权限授权。 */
     public com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.File uploadEvidence(Actor actor,String number,
         com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind kind,org.springframework.web.multipart.MultipartFile file) {
-        requirePlatform(actor);var row=required(actor,number,false);
-        if(kind==com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.EXCEPTION) {
-            requireExceptionAllowed(actor,row,row.getRecordVersion());
-            return evidence.upload(row.getId(),kind,actor.operatorId(),file);
-        }
-        requireEditing(row,row.getRecordVersion());
+        requirePlatform(actor);var row=required(actor,number,false);requireEditing(row,row.getRecordVersion());
         Action permission = ReviewState.DISPATCH_PENDING.name().equals(row.getReviewState()) ? Action.DISPATCH_REVIEW
             : ReviewState.LOADING_PENDING.name().equals(row.getReviewState()) ? Action.LOADING_REVIEW : Action.EDIT;
         if(!hasPermission(actor,permission))throw new BizException(ResultCode.FORBIDDEN,"无当前阶段附件上传权限");
@@ -305,9 +298,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         row.setStatus(Status.ACTIVE.name()); row.setStage(Stage.BEFORE_LOADING.name()); row.setRecordVersion(0L);
         row.setCargoRevision(0L); row.setCargoHash(hashes.source(List.of())); row.setReviewState(ReviewState.DRAFT.name()); row.setReviewRound(0L);
         row.setDispatchReviewJson(write(pending(0))); row.setLoadingReviewJson(write(pending(0)));
-        var photos=request.driver()==null || request.driver().evidence()==null?List.<Long>of():request.driver().evidence().photoFileIds();
-        if(!photos.isEmpty())verifyEvidence(id,com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER_PHOTO,photos);
-        Resources resources=resources(shell,photos); row.setResourcesJson(write(resources));
+        Resources resources=resources(shell); row.setResourcesJson(write(resources));
         row.setVehiclePlate(resources.vehicle()==null ? null : resources.vehicle().plate());
         row.setPlannedDepartureAt(utc(request.plannedDepartureAt())); row.setEstimatedArrivalAt(utc(request.estimatedArrivalAt()));
         row.setItemCount(0); row.setPalletCount(0); row.setPackageCount(0); row.setPickedPackageCount(0); row.setShippedPackageCount(0);
@@ -385,11 +376,8 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         var original=commands.replay(actor,number,identity);if(original.isPresent())return original.get();
         requireEditing(row,request.recordVersion());
         String before=basis(row);
-        // 本趟司机照片随资源维护保存，逐个核对本车及照片类别。
-        var photos=request.driver()==null || request.driver().evidence()==null?List.<Long>of():request.driver().evidence().photoFileIds();
-        if(!photos.isEmpty())verifyEvidence(row.getId(),com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER_PHOTO,photos);
         var actual=fleet.dispatchResources(number,fleetVehicle(request.vehicle()),fleetDriver(request.driver()));
-        row.setResourcesJson(write(resources(actual,photos)));row.setVehiclePlate(actual.vehicle()==null?null:actual.vehicle().plate());
+        row.setResourcesJson(write(resources(actual)));row.setVehiclePlate(actual.vehicle()==null?null:actual.vehicle().plate());
         row.setPlannedDepartureAt(utc(request.plannedDepartureAt()));row.setEstimatedArrivalAt(utc(request.estimatedArrivalAt()));row.setRemark(request.remark());
         if(!Objects.equals(before,basis(row)))invalidate(row,"车辆、司机或计划信息已修改");
         fleet.saveDispatchResources(number,actor.operatorId(),actual,request.plannedDepartureAt(),request.remark());
@@ -404,7 +392,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         requireEditing(row,request.recordVersion());
         if(!canSubmitReview(row.getReviewState()))throw conflict("当前审核已提交，请刷新核对");
         verifyReviewResources(row);
-        if(n(row.getPackageCount())<=0 || (!"PICKUP".equals(row.getTaskType()) && repository.cargo(row.getId()).isEmpty()))throw bad("空排车不能提交审核");
+        if(n(row.getPackageCount())<=0 || repository.cargo(row.getId()).isEmpty())throw bad("空排车不能提交审核");
         long round=row.getReviewRound()+1;String basis=basis(row);
         row.setReviewRound(round);row.setReviewBasisHash(basis);row.setReviewState(ReviewState.DISPATCH_PENDING.name());
         row.setDispatchReviewJson(write(new Review(ReviewStatus.PENDING,null,null,null,round,basis,null,null)));
@@ -421,7 +409,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         if(actor!=null && actor.mode()==ActorMode.PDA) {
             if(!loading || actor.boundWarehouseId()==null || !hasPermission(actor,action))
                 throw new BizException(ResultCode.FORBIDDEN,"仅当前绑定仓理货员可执行理货审核");
-            lockReviewRoot(actor,number);row=required(actor,number,true);
+            required(actor,number,false);fleet.lockDispatchShell(number);row=required(actor,number,true);
         } else row=lockPlatform(actor,number);
         var identity=identity(actor,number,action,request.recordVersion(),request.idempotencyKey(),request);
         var original=commands.replay(actor,number,identity);if(original.isPresent())return original.get();
@@ -546,7 +534,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
             List.copyOf(pallets),row.getLoadingConfirmationJson()==null?null:read(row.getLoadingConfirmationJson(),ConfirmedLoad.class),gate,List.copyOf(missing));
     }
 
-    /** 实载确认：扫码核平后保存装载证据并进入装车后，五张装车资料齐全再推进派送。 */
+    /** 内部实载步骤：扫码核平后保存装载证据，中间装车后状态由外层同事务继续推进发车。 */
     @Transactional(isolation=Isolation.READ_COMMITTED)
     public CommandResult loadingComplete(Actor actor,String number,DispatchCommands.LoadingComplete request) {
         required(actor,number,false);fleet.lockDispatchShell(number);var row=required(actor,number,true);
@@ -616,12 +604,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
     }
 
     /** 共同根锁顺序固定，当前阶段资格留给原命令恢复之后。 */
-    private DispatchAggregate lockPlatform(Actor actor,String number) { requirePlatform(actor);lockReviewRoot(actor,number);return required(actor,number,true); }
-    /** 运输取货锁原车次，仓库派送锁其整车资源；统一先父后主单。 */
-    private void lockReviewRoot(Actor actor,String number) {
-        var row=required(actor,number,false);
-        if("PICKUP".equals(row.getTaskType()))transportTasks.transport(number,true);else fleet.lockDispatchShell(number);
-    }
+    private DispatchAggregate lockPlatform(Actor actor,String number) { requirePlatform(actor);fleet.lockDispatchShell(number);return required(actor,number,true); }
     /** 严格请求身份不接收前端摘要或操作者。 */
     private CommandIdentity identity(Actor actor,String no,Action action,long version,String key,Object request) {return new CommandIdentity(action,key,version,hashes.command(actor,action,no,version,request));}
     /** 每次状态变更、历史及不可变命令结果同事务保存。 */
@@ -638,10 +621,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
     /** 只包含可影响两级审核的事实，不因备注修改伪造新依据。 */
     private String basis(DispatchAggregate row) {
         var facts=new TreeMap<String,Object>();facts.put("cargoHash",row.getCargoHash());facts.put("resources",read(row.getResourcesJson(),Resources.class));
-        facts.put("plannedDepartureAt",row.getPlannedDepartureAt());facts.put("estimatedArrivalAt",row.getEstimatedArrivalAt());
-        if("PICKUP".equals(row.getTaskType()))facts.put("route",transportTasks.transport(row.getDispatchNo(),false).getStopsJson());
-        else {facts.put("batches",repository.batches(row.getId()));facts.put("route",fleet.dispatchStops(row.getDispatchNo()));}
-        return hashes.source(facts);
+        facts.put("plannedDepartureAt",row.getPlannedDepartureAt());facts.put("estimatedArrivalAt",row.getEstimatedArrivalAt());facts.put("batches",repository.batches(row.getId()));facts.put("route",fleet.dispatchStops(row.getDispatchNo()));return hashes.source(facts);
     }
     /** 作废原因进入两级显式记录，旧审核证据仍保留在不可变历史中。 */
     private void invalidate(DispatchAggregate row,String reason) {
@@ -666,7 +646,6 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
 
     /** 临时取证、有效期和实际主档资格必须在提交及通过时再次核验。 */
     void verifyReviewResources(DispatchAggregate row) {
-        if("PICKUP".equals(row.getTaskType())) {transportTasks.verifyPickupReview(row.getDispatchNo());return;}
         var r=read(row.getResourcesJson(),Resources.class);var v=r.vehicle();var d=r.driver();
         if(v==null || d==null || trim(v.plate())==null || trim(d.name())==null || trim(d.phone())==null)throw bad("请补齐车辆、司机和联系电话");
         var capacity=v.capacity();if(capacity==null || capacity.palletSpaces()==null || capacity.palletSpaces()<=0 || capacity.maxLoadKg()==null || capacity.maxLoadKg().signum()<=0 || capacity.maxVolumeCbm()==null || capacity.maxVolumeCbm().signum()<=0)throw bad("请补齐车辆真实托位、载重及容积");
@@ -674,10 +653,9 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         if(trim(e.licenseNo())==null || e.licenseExpiresOn()==null || e.licenseExpiresOn().isBefore(e.expectedTaskEndAt().atZone(ZoneOffset.UTC).toLocalDate()))throw bad("司机证照须覆盖预计任务结束日期");
         if(v.mode()==ResourceMode.EXTERNAL)verifyEvidence(row.getId(),com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.VEHICLE,v.evidenceFileIds());
         if(d.mode()==ResourceMode.EXTERNAL)verifyEvidence(row.getId(),com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER,e.fileIds());
-        if(!e.photoFileIds().isEmpty())verifyEvidence(row.getId(),com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER_PHOTO,e.photoFileIds());
         var actual=fleet.dispatchResources(row.getDispatchNo(),new FleetExecutionModels.DispatchVehicle(v.mode().name(),v.vehicleId(),v.plate(),v.carrierName(),capacity.palletSpaces(),capacity.maxLoadKg(),capacity.maxVolumeCbm(),v.evidenceFileIds()),
             new FleetExecutionModels.DispatchDriver(d.mode().name(),d.driverId(),d.name(),d.phone(),e.licenseNo(),e.licenseExpiresOn(),e.fileIds(),e.expectedTaskEndAt()));
-        if(!Objects.equals(hashes.source(r),hashes.source(resources(actual,e.photoFileIds()))))throw conflict("车辆或司机主档已变化，请重新保存并提交审核");
+        if(!Objects.equals(hashes.source(r),hashes.source(resources(actual))))throw conflict("车辆或司机主档已变化，请重新保存并提交审核");
     }
     /** 同类证据有界且必须属于当前整车，跨车文件不能用于审核。 */
     private void verifyEvidence(long dispatch,com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind kind,List<Long> ids) {
@@ -685,40 +663,6 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         for(var id:ids)evidence.metadata(dispatch,kind,id);
     }
 
-    /** 仅派送中登记异常；原键重试先恢复，避免追加重复记录。 */
-    @Transactional(isolation=Isolation.READ_COMMITTED)
-    public CommandResult markException(Actor actor,String number,DispatchCommands.MarkException request) {
-        var row=lockPlatform(actor,number);
-        if(!hasPermission(actor,Action.MARK_EXCEPTION))throw new BizException(ResultCode.FORBIDDEN,"无标记异常权限");
-        var identity=identity(actor,number,Action.MARK_EXCEPTION,request.recordVersion(),request.idempotencyKey(),request);
-        var replay=commands.replay(actor,number,identity);if(replay.isPresent())return replay.get();
-        requireExceptionAllowed(actor,row,request.recordVersion());
-        if(request.exceptionType()==null)throw bad("请选择异常类型");
-        var description=trim(request.description());
-        if(description!=null && description.length()>1000)throw bad("异常说明不能超过1000字");
-        var ids=request.imageFileIds()==null?List.<Long>of():request.imageFileIds();
-        if(ids.size()>20 || ids.stream().anyMatch(id->id==null || id<=0) || ids.stream().distinct().count()!=ids.size())throw bad("异常图片引用无效或超过20张");
-        // 文件须属于本车异常类别，不能借用其他车辆或审核附件。
-        for(var id:ids)evidence.metadata(row.getId(),com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.EXCEPTION,id);
-        var records=new ArrayList<>(exceptionRecords(row));
-        records.add(new DispatchViews.ExceptionRecord(request.exceptionType(),request.returnDirection(),description,List.copyOf(ids),Instant.now()));
-        row.setExceptionsJson(write(records));
-        return saveCommand(row,actor,identity,description);
-    }
-
-    /** 异常登记复用排车维护权限；版本、任务类型与阶段由服务端再次核验。 */
-    private void requireExceptionAllowed(Actor actor,DispatchAggregate row,long version) {
-        if(!hasPermission(actor,Action.MARK_EXCEPTION))throw new BizException(ResultCode.FORBIDDEN,"无标记异常权限");
-        if(row.getRecordVersion()!=version)throw conflict("排车版本已变化，请刷新后再标记异常");
-        if(!actions(actor,row).get(Action.MARK_EXCEPTION).allowed())throw conflict("仅派送中的仓库派送排车可以标记异常");
-    }
-
-    /** 尚未登记时为空集合，已登记记录按保存顺序完整回看。 */
-    private List<DispatchViews.ExceptionRecord> exceptionRecords(DispatchAggregate row) {
-        if(row.getExceptionsJson()==null)return List.of();
-        return Arrays.asList(read(row.getExceptionsJson(),DispatchViews.ExceptionRecord[].class));
-    }
-
     /** 同一只读快照返回分页、总数和基集分布，不能在前端过滤当前页。 */
     @Transactional(readOnly=true,isolation=Isolation.REPEATABLE_READ)
     public DispatchViews.Page page(Actor actor, DispatchViews.Query query) {
@@ -755,7 +699,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         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()),
             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,exceptionRecords(row)),
+            new DispatchViews.DispatchInfo(row.getRoute(),instant(row.getPlannedDepartureAt()),instant(row.getDepartedAt()),instant(row.getEstimatedArrivalAt()),appointments,batchRefs),
             documents,orderDetails(cargo));
     }
 
@@ -864,18 +808,8 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         // 到仓取货和本土卡车沿运输任务执行，不能进入仓内拣货、扣库存和转派送链。
         if (row.getTaskType()!=null && !"DELIVERY".equals(row.getTaskType())) {
             var blocked=new EnumMap<Action,Gate>(Action.class);
-            boolean pickup="PICKUP".equals(row.getTaskType()) && "ACTIVE".equals(row.getStatus());
-            for(var action:Action.values())if(action!=Action.ARRANGE_DELIVERY && action!=Action.DEPART) {
-                boolean state=pickup && switch(action) {
-                    case EDIT,CANCEL -> Set.of("BEFORE_LOADING","LOADING").contains(row.getStage());
-                    case SUBMIT_REVIEW -> "BEFORE_LOADING".equals(row.getStage()) && canSubmitReview(row.getReviewState());
-                    case DISPATCH_REVIEW -> "DISPATCH_PENDING".equals(row.getReviewState());
-                    case LOADING_REVIEW -> "LOADING_PENDING".equals(row.getReviewState());
-                    default -> false;
-                };
-                boolean allowed=state && hasPermission(actor,action);
-                blocked.put(action,new Gate(allowed,allowed?null:"TRANSPORT_TASK",allowed?null:"请按取货运输审核流程操作"));
-            }
+            for(var action:Action.values())if(action!=Action.ARRANGE_DELIVERY && action!=Action.DEPART)
+                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());
@@ -883,7 +817,6 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         for(var action:Action.values()) {
             if(action==Action.ARRANGE_DELIVERY || action==Action.DEPART)continue;
             boolean state=switch(action) {
-                case MARK_EXCEPTION -> active && stage==Stage.DELIVERING;
                 case CREATE -> actor.mode()==ActorMode.PLATFORM;
                 case EDIT,ADD_CARGO,REMOVE_CARGO,CANCEL -> active && stage==Stage.BEFORE_LOADING && n(row.getPickedPackageCount())==0;
                 case SUBMIT_REVIEW -> active && stage==Stage.BEFORE_LOADING && n(row.getPickedPackageCount())==0 && canSubmitReview(row.getReviewState());
@@ -966,12 +899,12 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         return List.copyOf(result);
     }
 
-    /** 合并Fleet权威资源与本趟司机照片，照片不写入司机主档。 */
-    private static Resources resources(FleetExecutionModels.DispatchShell shell,List<Long> photos) {
+    /** 把Fleet权威主档或真实临时输入转换成整车审阅快照。 */
+    private static Resources resources(FleetExecutionModels.DispatchShell shell) {
         var v=shell.vehicle(); var d=shell.driver();
         return new Resources(v==null?null:new VehicleSnapshot(ResourceMode.valueOf(v.mode()),v.vehicleId(),v.plate(),v.carrierName(),shell.vehicleStatus(),
             new Capacity(v.palletSpaces(),v.maxLoadKg(),v.maxVolumeCbm()),v.evidenceFileIds()),d==null?null:new DriverSnapshot(ResourceMode.valueOf(d.mode()),d.driverId(),d.name(),d.phone(),
-            new DriverEvidence(d.licenseNo(),d.licenseExpiresOn(),d.evidenceFileIds(),d.expectedTaskEndAt(),photos)));
+            new DriverEvidence(d.licenseNo(),d.licenseExpiresOn(),d.evidenceFileIds(),d.expectedTaskEndAt())));
     }
 
     /** 主档选择不接受请求覆盖其车牌和容量。 */

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

@@ -73,7 +73,7 @@ public final class DispatchCommandCodec {
             case DEPART -> DispatchResults.Departed.class;
             case ARRANGE_DELIVERY -> DispatchDeliveryModels.ArrangementResult.class;
             case CREATE, EDIT, ADD_CARGO, REMOVE_CARGO, CANCEL, SUBMIT_REVIEW,
-                 DISPATCH_REVIEW, LOADING_REVIEW, RETURN_TO_REVIEW, MARK_EXCEPTION -> DispatchResults.Saved.class;
+                 DISPATCH_REVIEW, LOADING_REVIEW, RETURN_TO_REVIEW -> DispatchResults.Saved.class;
         };
     }
 

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

@@ -19,7 +19,7 @@ import java.util.TreeMap;
 @Component
 public final class DispatchCommandHasher {
     private static final Set<String> UNORDERED = Set.of("cargo", "groups", "fees", "feeCoverage", "services",
-        "batchAllocations", "measurements", "paymentVoucherFileIds", "evidenceFileIds", "fileIds", "photoFileIds");
+        "batchAllocations", "measurements", "paymentVoucherFileIds", "evidenceFileIds", "fileIds");
     private final ObjectMapper json;
 
     /** 复用已注册的时间、数值和公开字段序列化配置。 */
@@ -60,12 +60,7 @@ public final class DispatchCommandHasher {
         if (node == null || node.isNull()) return "null";
         if (node.isObject()) {
             var values = new TreeMap<String, String>();
-            node.fields().forEachRemaining(entry -> {
-                // 新增可选照片为空时沿用旧摘要，保留历史命令重放与已通过审核的依据。
-                if (entry.getKey().equals("photoFileIds") && (entry.getValue().isNull()
-                    || entry.getValue().isArray() && entry.getValue().isEmpty())) return;
-                values.put(entry.getKey(), canonical(entry.getValue(), entry.getKey()));
-            });
+            node.fields().forEachRemaining(entry -> values.put(entry.getKey(), canonical(entry.getValue(), entry.getKey())));
             var result = new ArrayList<String>();
             values.forEach((key, value) -> result.add(quoted(key) + ":" + value));
             return "{" + String.join(",", result) + "}";

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

@@ -3,14 +3,13 @@ package com.baiyue.lastleg.dispatch.service;
 import com.baiyue.common.core.api.ResultCode;
 import com.baiyue.common.core.exception.BizException;
 import com.baiyue.lastleg.dispatch.port.*;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.*;
 import java.util.List;
 import static com.baiyue.lastleg.dispatch.port.DispatchContracts.*;
 import static com.baiyue.lastleg.dispatch.port.DispatchTypes.*;
 
-/** 装车与资料可并行完成，两项齐全时在当前事务自动推进派送。 */
+/** 两端装车完成即发车：所有中间状态只存在于同一事务，原请求只恢复最终结果。 */
 @Service
 public class DispatchLoadingDepartureService {
     private final DispatchAggregateService workflow;
@@ -18,52 +17,38 @@ public class DispatchLoadingDepartureService {
     private final DispatchDepartureService departure;
     private final DispatchCommandLedger commands;
     private final DispatchCommandHasher hashes;
-    private final DispatchLoadingPhotoPort documents;
 
     /** 复用装车、派送和发车的真实规则，不另建库存或运输状态实现。 */
     public DispatchLoadingDepartureService(DispatchAggregateService workflow,DispatchDeliveryPort delivery,
-        DispatchDepartureService departure,DispatchCommandLedger commands,DispatchCommandHasher hashes,
-        DispatchLoadingPhotoPort documents) {
+        DispatchDepartureService departure,DispatchCommandLedger commands,DispatchCommandHasher hashes) {
         this.workflow=workflow;this.delivery=delivery;this.departure=departure;this.commands=commands;this.hashes=hashes;
-        this.documents=documents;
     }
 
-    /** 原请求记录最终阶段；重放不重复装车、创建派送或发车。 */
+    /** 原键恢复先于阶段校验；任一步失败均回滚装载、子单、费用、发车与全部账本。 */
     @Transactional(isolation=Isolation.READ_COMMITTED)
     public CommandResult complete(Actor actor,String number,DispatchCommands.LoadingComplete request) {
         workflow.requireLoadingPermission(actor);
         var context=workflow.lockForArrangement(actor,number);
         var identity=new CommandIdentity(Action.LOADING_COMPLETE,request.idempotencyKey(),request.recordVersion(),
             hashes.command(actor,Action.LOADING_COMPLETE,number,request.recordVersion(),request));
-        var original=workflow.replay(context,actor,identity);if(original.isPresent())return original.get();
-        var loaded=workflow.loadingComplete(actor,number,new DispatchCommands.LoadingComplete(request.recordVersion(),
-            stepKey(number,request.idempotencyKey(),"LOAD"),request.manifestHash(),request.measurements(),request.remark()));
-        var ready=DispatchLoadingDocumentService.complete(documents.read(context.dispatchId()).photos());
-        var finalState=ready?departAfterDocuments(actor,number,request.idempotencyKey()):loaded;
-        var result=new CommandResult(number,Action.LOADING_COMPLETE,request.idempotencyKey(),finalState.recordVersion(),
-            finalState.status(),finalState.stage(),finalState.occurredAt(),finalState.effect(),finalState.counts(),loaded.result(),false,false);
-        commands.append(context.dispatchId(),actor,identity,result);
-        return result;
-    }
-
-    /** 仅供装车资料齐全的保存事务调用；派送准备和发车失败回滚最后一张绑定。 */
-    @Transactional(propagation=Propagation.MANDATORY,isolation=Isolation.READ_COMMITTED)
-    public CommandResult departAfterDocuments(Actor actor,String number,String key) {
-        var context=workflow.lockForArrangement(actor,number);
-        if(context.stage()!=Stage.AFTER_LOADING || context.status()!=Status.ACTIVE)
-            throw new BizException(ResultCode.CONFLICT,"当前阶段不能按装车资料推进派送");
+        var replay=commands.replay(actor,number,identity);if(replay.isPresent())return replay.get();
         // 先取得本车单据锁再申请真实来源锁，后续所有步骤保持同一个整车父锁。
         delivery.departureFacts(context,true);
-        String arrangementKey=stepKey(number,key,"ARRANGE");
+        var loaded=workflow.loadingComplete(actor,number,new DispatchCommands.LoadingComplete(request.recordVersion(),
+            stepKey(number,request.idempotencyKey(),"LOAD"),request.manifestHash(),request.measurements(),request.remark()));
+        context=workflow.preview(actor,number);
+        String arrangementKey=stepKey(number,request.idempotencyKey(),"ARRANGE");
         var fact=delivery.prepareForDeparture(context,actor,arrangementKey);
         var arrangementIdentity=new CommandIdentity(Action.ARRANGE_DELIVERY,arrangementKey,context.recordVersion(),
             hashes.source(List.of(number,actor.operatorId(),context.recordVersion(),fact.arrangementBusinessHash())));
         var arranged=workflow.recordArrangement(context,actor,arrangementIdentity,fact,false);
         var departed=departure.depart(actor,number,new DispatchCommands.Depart(arranged.recordVersion(),
-            stepKey(number,key,"DEPART"),"五张装车照片已齐全，自动进入派送中"));
-        if(departed.stage()!=Stage.DELIVERING)
+            stepKey(number,request.idempotencyKey(),"DEPART"),request.remark()));
+        if(departed.stage()!=Stage.DELIVERING || !(loaded.result() instanceof DispatchResults.Loaded))
             throw new BizException(ResultCode.CONFLICT,"装车发运结果未核平");
-        return departed;
+        var result=new CommandResult(number,Action.LOADING_COMPLETE,request.idempotencyKey(),departed.recordVersion(),
+            departed.status(),departed.stage(),departed.occurredAt(),Effect.APPLIED,departed.counts(),loaded.result(),false,false);
+        commands.append(context.dispatchId(),actor,identity,result);return result;
     }
 
     /** 固定长度内部键绑定原请求和步骤，不向客户端暴露中间命令作为恢复入口。 */

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

@@ -1,85 +0,0 @@
-package com.baiyue.lastleg.dispatch.service;
-
-import com.baiyue.common.core.api.ResultCode;
-import com.baiyue.common.core.exception.BizException;
-import com.baiyue.lastleg.dispatch.port.DispatchContracts.Actor;
-import com.baiyue.lastleg.dispatch.port.DispatchContracts.Context;
-import com.baiyue.lastleg.dispatch.port.DispatchTypes.*;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort.*;
-import org.springframework.security.core.context.SecurityContextHolder;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.*;
-import org.springframework.web.multipart.MultipartFile;
-import java.util.*;
-
-/** Admin/PDA按整车共用装车资料；通过车队公开端口保存照片，不读取其持久化。 */
-@Service
-public class DispatchLoadingDocumentService {
-    public static final List<Slot> SLOTS=List.of(Slot.values());
-    private final DispatchAggregateService workflow;
-    private final DispatchLoadingDepartureService departure;
-    private final DispatchLoadingPhotoPort photos;
-    /** 装车资料与履约原子编排留在排车域，车队只提供照片事实。 */
-    public DispatchLoadingDocumentService(DispatchAggregateService workflow,DispatchLoadingDepartureService departure,DispatchLoadingPhotoPort photos) {
-        this.workflow=workflow;this.departure=departure;this.photos=photos;
-    }
-    /** GET只读，PDA每次按可信主体重验冻结仓。 */
-    @Transactional(readOnly=true,isolation=Isolation.REPEATABLE_READ)
-    public Documents get(Actor actor,String number) {
-        require(actor,false);var context=context(actor,number,false);return documents(context,photos.read(context.dispatchId()),allowed(actor,true));
-    }
-    /** 上传先记原请求意图，不提前绑定或推进派送。 */
-    public Photo upload(Actor actor,String number,Slot slot,String key,MultipartFile file) {
-        require(actor,true);var context=context(actor,number,false);return photos.upload(context.dispatchId(),actor.operatorId(),slot,key,file);
-    }
-    /** 原操作者仍须有权限且满足本车绑定仓范围，不能跨账号恢复。 */
-    public Photo recover(Actor actor,String number,String key) {
-        require(actor,true);var context=context(actor,number,false);return photos.recover(context.dispatchId(),actor.operatorId(),key);
-    }
-    /** 锁顺序为车次、排车、附加行；第五张绑定与派送发车共同提交或回滚。 */
-    @Transactional(isolation=Isolation.READ_COMMITTED)
-    public Documents bind(Actor actor,String number,Slot slot,BindPhoto request) {
-        require(actor,true);var context=context(actor,number,true);
-        var replay=photos.replayBind(context.dispatchId(),actor.operatorId(),slot,request);if(replay!=null)return replay;
-        var state=photos.bind(context.dispatchId(),actor.operatorId(),slot,request);
-        if(context.stage()==Stage.AFTER_LOADING && complete(state.photos())) {
-            departure.departAfterDocuments(actor,number,request.idempotencyKey());context=workflow.preview(actor,number);
-        }
-        var result=documents(context,state,true);
-        photos.recordBind(context.dispatchId(),actor.operatorId(),slot,request,result);return result;
-    }
-    /** 当前引用由照片提供者再次核验，拒绝未绑定或其他车文件。 */
-    @Transactional(readOnly=true)
-    public Download content(Actor actor,String number,Slot slot,long fileId) {
-        require(actor,false);var context=context(actor,number,false);return photos.content(context.dispatchId(),slot,fileId);
-    }
-    /** 装车中可同步上传；后续阶段仍须有真实装载证据，仓隔离沿用主流程。 */
-    private Context context(Actor actor,String number,boolean lock) {
-        var value=lock?workflow.lockForArrangement(actor,number):workflow.preview(actor,number);
-        if(value.status()!=Status.ACTIVE || !Set.of(Stage.LOADING,Stage.AFTER_LOADING,Stage.DELIVERING,Stage.DELIVERED).contains(value.stage())
-            || value.stage()!=Stage.LOADING && (value.loadingCompletedAt()==null || value.loadingCompletionHash()==null))
-            throw new BizException(ResultCode.CONFLICT,"进入装车中后才能管理装车资料");
-        return value;
-    }
-    /** 对外同时返回资料版本与当前排车阶段，二者不互相替代。 */
-    private Documents documents(Context context,State state,boolean editable) {
-        return new Documents(context.dispatchNo(),state.recordVersion(),Long.toString(context.recordVersion()),context.stage().name(),editable,complete(state.photos()),state.photos());
-    }
-    /** 按五个固定框核齐，不能用总数或重复槽位代替。 */
-    static boolean complete(List<Photo> photos) {
-        return SLOTS.stream().allMatch(slot->photos.stream().anyMatch(p->p.slot()==slot && p.fileId()!=null && !p.fileId().isBlank()));
-    }
-    /** 平台list与edit分离，PDA使用既有作业角色和绑定仓。 */
-    private void require(Actor actor,boolean write) {
-        if(actor==null || actor.operatorId()==null || !allowed(actor,write))throw new BizException(ResultCode.FORBIDDEN,"无装车资料操作权限");
-    }
-    /** 权限取当前会话，不为PDA补造平台权限。 */
-    private boolean allowed(Actor actor,boolean write) {
-        var auth=SecurityContextHolder.getContext().getAuthentication();if(auth==null || actor==null)return false;
-        var authorities=auth.getAuthorities().stream().map(a->a.getAuthority()).toList();
-        return actor.mode()==ActorMode.PDA?actor.boundWarehouseId()!=null && authorities.contains("lastleg:pda:operate")
-            && authorities.contains("ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR")
-            :authorities.contains("platform:overseas-warehouse:dispatch:"+(write?"edit":"list"));
-    }
-}

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

@@ -87,7 +87,7 @@ public class DispatchPdaQueryService {
             if(!sourceValid)actions.put(Action.PICK,new Gate(false,"SOURCE_COMPOSITION_CHANGED","换标来源实际位置或累计剩余额度已变化，请回平台核对"));
             if(!complete)actions.put(Action.LOADING_COMPLETE,new Gate(false,"PICKING_INCOMPLETE","逐项真实拣货来源尚未核平"));
             else actions.put(Action.PICK,new Gate(false,"PICKING_RECONCILED","本车全部来源已核平，请显式确认装车"));
-            var counts=new Counts(n(root.getItemCount()),n(root.getPalletCount()),detail.stream().mapToLong(DispatchViews.PdaItem::scheduledPackages).sum(),n(root.getPickedPackageCount()),n(root.getShippedPackageCount()));
+            var counts=new Counts(n(root.getItemCount()),n(root.getPalletCount()),n(root.getPackageCount()),n(root.getPickedPackageCount()),n(root.getShippedPackageCount()));
             // 整车作业直接以排车业务号识别；真实客户子taskId只在服务端审计保存。
             result.add(new DispatchViews.PdaTask(root.getDispatchNo(),root.getDispatchNo(),root.getOverseasWarehouseId(),Status.valueOf(root.getStatus()),Stage.valueOf(root.getStage()),root.getRecordVersion(),workflow.reviews(root),workflow.resources(root),counts,complete,List.copyOf(detail),Collections.unmodifiableMap(actions)));
         }
@@ -95,11 +95,36 @@ public class DispatchPdaQueryService {
     }
     /** 预排首次扫码前只解析原计划实收仓位，不在GET补写实托；真正绑定仍由pick锁内重验。 */
     private List<DispatchViews.Position> receivedPlanPositions(Actor actor,DispatchItem item,List<DispatchItem> items) {
-        var received=DispatchReceivedPlan.resolve(actor.boundWarehouseId(),item,items,sources,sourceRules);
-        if(received.isEmpty())return List.of();
-        // 只修改本次投影对象，不在GET更新排车、版本或库存。
-        item.setPackageCount(received.get().source().packageCount());
-        return received.get().positions();
+        if(!Objects.equals(actor.boundWarehouseId(),item.getOverseasWarehouseId()))return List.of();
+        var rows=sources.selectedPlan(item.getCustomerId(),item.getPlanPalletId());
+        if(rows.size()!=1)return List.of();
+        var actual=rows.get(0);
+        if(!"RECEIVED".equals(actual.sourceStage()) || actual.warehousePalletId()==null
+            || !Objects.equals(actual.planPalletId(),item.getPlanPalletId())
+            || !Objects.equals(actual.customerId(),item.getCustomerId())
+            || !Objects.equals(actual.overseasWarehouseId(),item.getOverseasWarehouseId())
+            || !Objects.equals(actual.packageCount(),item.getPackageCount())
+            || !Objects.equals(actual.destinationType(),item.getDestinationType())
+            || !Objects.equals(actual.fbaWarehouseCode(),item.getFbaWarehouseCode())
+            || !Objects.equals(actual.deliveryAddress(),item.getDeliveryAddress()))return List.of();
+        var originalOrders=sources.sourceOrders(item.getCustomerId(),null,item.getPlanPalletId());
+        if(originalOrders.isEmpty() || !new HashSet<>(originalOrders).containsAll(
+            sources.sourceOrders(item.getCustomerId(),actual.warehousePalletId(),item.getPlanPalletId())))return List.of();
+        // 同托跨客户、换标及整申请来源必须全部已在原车；不能把新合托货物暴露为原计划可拣库存。
+        var group=sourceRules.selectionGroup(actor.boundWarehouseId(),new DispatchCommands.CargoSelection(
+            SourceType.INBOUND_PLAN,item.getPlanPalletId(),null,null,actual.warehousePalletId(),null));
+        if(!group.complete() || group.sources().stream().noneMatch(s->Objects.equals(s.sourceKey(),item.getSourceKey())))return List.of();
+        for(var member:group.sources()) {
+            var selected=items.stream().filter(i->Objects.equals(i.getSourceKey(),member.sourceKey())).findFirst().orElse(null);
+            if(selected==null || !Objects.equals(selected.getCustomerId(),member.customerId())
+                || n(selected.getPackageCount())!=member.packages())return List.of();
+        }
+        var stock=sources.stock(item.getCustomerId(),actual.warehousePalletId(),false);
+        if(stock.stream().anyMatch(p->!Objects.equals(p.warehouseId(),actor.boundWarehouseId())
+            || !Objects.equals(p.palletId(),actual.warehousePalletId()))
+            || stock.stream().mapToLong(p->p.availablePackages()).sum()!=n(item.getPackageCount()))return List.of();
+        return stock.stream().filter(p->p.availablePackages()>0)
+            .map(p->new DispatchViews.Position(p.id(),p.balanceId(),p.availablePackages(),p.allocatedPackages(),p.pickedPackages())).toList();
     }
     /** 仓和操作者均来自受信身份，不接收请求自报。 */
     private static void require(Actor actor){if(actor==null || actor.mode()!=ActorMode.PDA || actor.operatorId()==null || actor.boundWarehouseId()==null)throw new BizException(ResultCode.FORBIDDEN,"仅绑定仓作业人员可读取PDA作业");}

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

@@ -27,7 +27,6 @@ public class DispatchPickingService {
     @jakarta.annotation.Resource private DispatchPhysicalClaimService physicalClaims;
     @jakarta.annotation.Resource private DispatchItemSourceService relabelSources;
     @jakarta.annotation.Resource private DispatchService sourceRules;
-    @jakarta.annotation.Resource private com.baiyue.lastleg.fleet.trip.FleetTripExecutionService fleet;
     private final DispatchAggregateService workflow;private final DispatchAggregateRepository repository;private final DispatchSourceRepository sources;
     private final DispatchPickingRepository picking;private final DispatchPickOrderAttributionService attribution;
     private final InventoryCommandService inventory;private final ReturnRelabelDispatchStock returns;
@@ -102,44 +101,33 @@ public class DispatchPickingService {
             new Counts(row.getItemCount(),row.getPalletCount(),row.getPackageCount(),row.getPickedPackageCount(),row.getShippedPackageCount()),new DispatchResults.Picked(itemId,request.positionId(),returnCartonId,request.packages(),before+request.packages(),complete),false,false);
         commands.append(row.getId(),actor,identity,result);return result;
     }
-    /** 首拣将本车已实收原计划按真实整托数量绑定，保持原审核身份并与扣货同事务回滚。 */
+    /** 原计划自然收货只补齐同一来源实托，数量/客户/目的地变化必须回到平台核对。 */
     private void materialize(com.baiyue.lastleg.dispatch.entity.DispatchAggregate row,DispatchItem item,Actor actor,List<DispatchItem> items) {
         long dispatch=row.getId();
         if(item.getWarehousePalletId()!=null) {
             relabelSources.validateFrozen(row,items,sourceRules.lockExecutionSources(row.getOverseasWarehouseId(),items));return;
         }
-        var received=new LinkedHashMap<DispatchItem,DispatchReceivedPlan.Fact>();
-        for(var candidate:items)DispatchReceivedPlan.resolve(actor.boundWarehouseId(),candidate,items,sources,sourceRules)
-            .ifPresent(fact->received.put(candidate,fact));
-        if(!received.containsKey(item))throw conflict("该托盘尚未完成可拣实收，或原来源、目的地、库存占用已变化，请刷新核对");
-        // 同车同实托的多个原计划一次绑定，避免首拣把其他已审核成员误判为新增货物。
-        for(var entry:received.entrySet()) {
-            entry.getKey().setWarehousePalletId(entry.getValue().source().warehousePalletId());
-            entry.getKey().setPackageCount(entry.getValue().source().packageCount());
-        }
+        if(item.getPlanPalletId()==null)throw conflict("本来源尚未关联真实实托");
+        var orders=sources.sourceOrders(item.getCustomerId(),null,item.getPlanPalletId());
+        if(orders.isEmpty())throw conflict("原计划缺少真实订单组成");
+        var rows=sources.selectedPlan(item.getCustomerId(),item.getPlanPalletId());
+        if(rows.size()!=1)throw conflict("请先完成本来源实际入仓收货");var actual=rows.get(0);
+        if(actual.warehousePalletId()==null || !Objects.equals(actual.customerId(),item.getCustomerId()) || !Objects.equals(actual.overseasWarehouseId(),item.getOverseasWarehouseId())
+            || !Objects.equals(actual.packageCount(),item.getPackageCount()) || !Objects.equals(actual.destinationType(),item.getDestinationType())
+            || !Objects.equals(actual.fbaWarehouseCode(),item.getFbaWarehouseCode()) || !Objects.equals(actual.deliveryAddress(),item.getDeliveryAddress()))throw conflict("原计划实收数量、仓或目的地已变化，请先回平台核对");
+        if(!new HashSet<>(orders).containsAll(sources.sourceOrders(item.getCustomerId(),actual.warehousePalletId(),item.getPlanPalletId())))throw conflict("实托新增了未审核的来源订单");
+        item.setWarehousePalletId(actual.warehousePalletId());
         relabelSources.validateFrozen(row,items,sourceRules.lockExecutionSources(row.getOverseasWarehouseId(),items));
-        for(var candidate:received.keySet().stream().sorted(Comparator.comparing(DispatchItem::getPlanPalletId)).toList()) {
-            if(sources.lockPlan(candidate.getCustomerId(),candidate.getPlanPalletId())==null)throw conflict("原计划来源已变化");
-            var fresh=sources.selectedPlan(candidate.getCustomerId(),candidate.getPlanPalletId());
-            if(fresh.size()!=1 || !DispatchReceivedPlan.sameIdentity(candidate,fresh.get(0))
-                || !Objects.equals(candidate.getWarehousePalletId(),fresh.get(0).warehousePalletId())
-                || !Objects.equals(candidate.getPackageCount(),fresh.get(0).packageCount()))throw conflict("实收托盘已变化，请刷新后重新扫码");
-        }
-        var at=LocalDateTime.ofInstant(Instant.now(),ZoneOffset.UTC);
-        var pallets=items.stream().map(DispatchItem::getWarehousePalletId).filter(Objects::nonNull).distinct().sorted().toList();
-        var physical=physicalClaims.reserve(new DispatchPhysicalClaimService.Owner(row.getOverseasWarehouseId(),dispatch,null,null,actor.operatorId(),null),pallets,at);
-        for(var entry:received.entrySet()) {
-            var candidate=entry.getKey();var actual=entry.getValue().source();
-            try{if(sources.materialize(dispatch,candidate.getCustomerId(),candidate.getPlanPalletId(),actual.warehousePalletId(),physical.get(actual.warehousePalletId()),at)!=1)throw conflict("原计划来源占用已变化");}
-            catch(DuplicateKeyException occupied){throw conflict("实托已经被其他排车占用");}
-            candidate.setPalletNo(actual.palletNo());candidate.setSourceStage("RECEIVED");
-            if(picking.materialize(candidate)!=1)throw conflict("本来源实际实托未保存");
-        }
-        row.setPackageCount(Math.toIntExact(items.stream().mapToLong(DispatchItem::getPackageCount).sum()));
-        var stops=items.stream().map(i->new com.baiyue.lastleg.fleet.trip.FleetExecutionModels.DispatchStop(
-            i.getDestinationWarehouseName(),i.getDeliveryAddress(),workflow.destination(i).key()))
-            .collect(java.util.stream.Collectors.toMap(com.baiyue.lastleg.fleet.trip.FleetExecutionModels.DispatchStop::destinationKey,s->s,(a,b)->a,TreeMap::new)).values().stream().toList();
-        fleet.updateDispatchCargo(row.getDispatchNo(),row.getPackageCount(),stops);
+        if(sources.lockPlan(item.getCustomerId(),item.getPlanPalletId())==null)throw conflict("原计划来源已变化");
+        var fresh=sources.selectedPlan(item.getCustomerId(),item.getPlanPalletId());
+        if(fresh.size()!=1 || !Objects.equals(actual.warehousePalletId(),fresh.get(0).warehousePalletId()) || !Objects.equals(actual.packageCount(),fresh.get(0).packageCount()))throw conflict("原计划实托组成已变化，请回平台核对");
+        var at=LocalDateTime.ofInstant(Instant.now(),ZoneOffset.UTC);sources.stock(item.getCustomerId(),actual.warehousePalletId(),true);
+        var pallets=new ArrayList<Long>();repository.cargo(dispatch).stream().map(DispatchItem::getWarehousePalletId).filter(Objects::nonNull).forEach(pallets::add);pallets.add(actual.warehousePalletId());
+        var physical=physicalClaims.reserve(new DispatchPhysicalClaimService.Owner(row.getOverseasWarehouseId(),dispatch,null,null,actor.operatorId(),null),pallets,at).get(actual.warehousePalletId());
+        try{if(sources.materialize(dispatch,item.getCustomerId(),item.getPlanPalletId(),actual.warehousePalletId(),physical,at)!=1)throw conflict("原计划来源占用已变化");}
+        catch(DuplicateKeyException occupied){throw conflict("实托已经被其他来源安排占用");}
+        item.setPalletNo(actual.palletNo());item.setSourceStage("RECEIVED");
+        if(picking.materialize(item)!=1)throw conflict("本来源实际实托未保存");
     }
     /** 库存幂等键分别标识一次实际动作，业务单号始终使用本车号。 */
     private static InventoryCommandRequests.Move move(DispatchCommands.Pick request,String dispatch,String reference,String key){return new InventoryCommandRequests.Move(request.positionId(),request.packages(),reference,dispatch,null,key,request.remark());}

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

@@ -1,56 +0,0 @@
-package com.baiyue.lastleg.dispatch.service;
-
-import com.baiyue.lastleg.dispatch.entity.DispatchItem;
-import com.baiyue.lastleg.dispatch.model.DispatchPalletCandidate;
-import com.baiyue.lastleg.dispatch.port.*;
-import com.baiyue.lastleg.dispatch.repository.DispatchSourceRepository;
-import java.util.*;
-import static com.baiyue.lastleg.dispatch.port.DispatchTypes.SourceType;
-
-/** 预排来源只冻结货物身份；自然实收的逐托箱数由真实库存提供，查询和首拣共用此规则。 */
-final class DispatchReceivedPlan {
-    record Fact(DispatchPalletCandidate source, List<DispatchViews.Position> positions) { }
-
-    /** 仅解析原车完整来源，禁止把新客户、新订单或冻结货物混入实收数量。 */
-    static Optional<Fact> resolve(String warehouse, DispatchItem item, List<DispatchItem> items,
-                                  DispatchSourceRepository sources, DispatchService rules) {
-        if(item.getWarehousePalletId()!=null || item.getPlanPalletId()==null
-            || !Objects.equals(warehouse,item.getOverseasWarehouseId()))return Optional.empty();
-        if(!sources.receivedPlanCompleted(item.getCustomerId(),item.getPlanPalletId()))return Optional.empty();
-        var rows=sources.selectedPlan(item.getCustomerId(),item.getPlanPalletId());
-        if(rows.size()!=1)return Optional.empty();
-        var actual=rows.get(0);
-        if(!sameIdentity(item,actual) || actual.packageCount()==null || actual.packageCount()<=0)return Optional.empty();
-        var original=sources.sourceOrders(item.getCustomerId(),null,item.getPlanPalletId());
-        if(original.isEmpty() || !new HashSet<>(original).containsAll(
-            sources.sourceOrders(item.getCustomerId(),actual.warehousePalletId(),item.getPlanPalletId())))return Optional.empty();
-        var group=rules.selectionGroup(warehouse,new DispatchCommands.CargoSelection(
-            SourceType.INBOUND_PLAN,item.getPlanPalletId(),null,null,actual.warehousePalletId(),null));
-        if(!group.complete() || group.sources().stream().noneMatch(s->Objects.equals(s.sourceKey(),item.getSourceKey())))return Optional.empty();
-        for(var member:group.sources()) {
-            var selected=items.stream().filter(i->Objects.equals(i.getSourceKey(),member.sourceKey())).findFirst().orElse(null);
-            if(selected==null || !Objects.equals(selected.getCustomerId(),member.customerId()))return Optional.empty();
-            // 原计划的估算箱数不限制实收；已经绑定或换标的冻结贡献仍严格核对。
-            if((selected.getWarehousePalletId()!=null || selected.getPlanPalletId()==null)
-                && (selected.getPackageCount()==null || selected.getPackageCount().longValue()!=member.packages()))return Optional.empty();
-        }
-        var stock=sources.stock(item.getCustomerId(),actual.warehousePalletId(),false);
-        if(stock.stream().anyMatch(p->!Objects.equals(p.warehouseId(),warehouse)
-            || !Objects.equals(p.palletId(),actual.warehousePalletId()) || p.holdPackages()!=0
-            || p.allocatedPackages()!=0 || p.pickedPackages()!=0)
-            || stock.stream().mapToLong(p->p.availablePackages()).sum()!=actual.packageCount())return Optional.empty();
-        return Optional.of(new Fact(actual,stock.stream().filter(p->p.availablePackages()>0)
-            .map(p->new DispatchViews.Position(p.id(),p.balanceId(),p.availablePackages(),p.allocatedPackages(),p.pickedPackages())).toList()));
-    }
-
-    /** 箱数允许随自然实收变化，客户、原计划、起运仓和目的地必须保持原身份。 */
-    static boolean sameIdentity(DispatchItem item,DispatchPalletCandidate actual) {
-        return "RECEIVED".equals(actual.sourceStage()) && actual.warehousePalletId()!=null
-            && Objects.equals(actual.planPalletId(),item.getPlanPalletId())
-            && Objects.equals(actual.customerId(),item.getCustomerId())
-            && Objects.equals(actual.overseasWarehouseId(),item.getOverseasWarehouseId())
-            && Objects.equals(actual.destinationType(),item.getDestinationType())
-            && Objects.equals(actual.fbaWarehouseCode(),item.getFbaWarehouseCode())
-            && Objects.equals(actual.deliveryAddress(),item.getDeliveryAddress());
-    }
-}

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

@@ -18,13 +18,12 @@ import static com.baiyue.lastleg.dispatch.port.DispatchTypes.*;
 
 /** 现有排车主单与运输事实同步，旧执行入口也不能留下不同步的单据。 */
 @Service
-public class TransportTaskProjection implements com.baiyue.lastleg.fleet.pickup.PickupDepartureReview {
+public class TransportTaskProjection {
     private final DispatchAggregateRepository roots;
     private final TransportTaskRepository links;
     private final UsTruckOrderRepository trucks;
     private final DispatchNumberGenerator numbers;
     private final ObjectMapper json;
-    @jakarta.annotation.Resource private com.baiyue.lastleg.fleet.pickup.FleetPickupRepository pickupFacts;
     /** 注入本地聚合与原单持久化能力，无跨服务数据库访问。 */
     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;
@@ -51,22 +50,11 @@ public class TransportTaskProjection implements com.baiyue.lastleg.fleet.pickup.
         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(version+1);row.setUpdatedAt(trip.getUpdatedAt());
+        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";case "PLANNED"->row.getStage();default->"BEFORE_LOADING";});
-        // 旧发车入口只记录出发事实，取货照片尚未齐全时仍在装货中。
-        if("PICKUP".equals(row.getTaskType()) && "IN_TRANSIT".equals(trip.getStatus())
-            && pickupFacts.tasks(trip.getTripNo()).stream().anyMatch(task->"ASSIGNED".equals(task.getStatus())))row.setStage("LOADING");
+        row.setStage(switch(trip.getStatus()){case "IN_TRANSIT"->"DELIVERING";case "COMPLETED"->"DELIVERED";default->"BEFORE_LOADING";});
         row.setDepartedAt(trip.getDepartedAt());row.setDeliveryCompletedAt(trip.getCompletedAt());
-        String oldResources=row.getResourcesJson();var oldDeparture=row.getPlannedDepartureAt();var oldArrival=row.getEstimatedArrivalAt();
         row.setPlannedDepartureAt(trip.getPlannedDepartureAt());row.setEstimatedArrivalAt(trip.getExpectedDriverEndAt());row.setRemark(trip.getRemark());resources(row,trip);
-        // 资源或计划改变后作废本轮审核，保留审核驳回原因供修改时核对。
-        if("PICKUP".equals(row.getTaskType()) && "PLANNED".equals(trip.getStatus())
-            && (!Objects.equals(oldResources,row.getResourcesJson()) || !Objects.equals(oldDeparture,row.getPlannedDepartureAt()) || !Objects.equals(oldArrival,row.getEstimatedArrivalAt()))) {
-            row.setReviewState("DRAFT");row.setReviewBasisHash(null);row.setStage("BEFORE_LOADING");
-            row.setDispatchReviewJson(invalidated(row.getDispatchReviewJson(),row.getReviewRound()));
-            row.setLoadingReviewJson(invalidated(row.getLoadingReviewJson(),row.getReviewRound()));
-        }
         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;
@@ -74,30 +62,6 @@ public class TransportTaskProjection implements com.baiyue.lastleg.fleet.pickup.
         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());
     }
-    /** 旧取货发车入口也必须锁定并核验同轮两级批准，不允许无主单发车。 */
-    @Override
-    public void requireApproved(long tripId) {
-        var found=links.byTrip(tripId);
-        if(found==null)throw new IllegalStateException("取货排车缺失，请先接入排车审核");
-        var row=roots.lock(found.getDispatchNo());
-        if(!"PICKUP".equals(row.getTaskType()) || !"ACTIVE".equals(row.getStatus()) || !"APPROVED".equals(row.getReviewState()) || row.getReviewBasisHash()==null)
-            throw new org.springframework.web.server.ResponseStatusException(org.springframework.http.HttpStatus.CONFLICT,"请先完成调度审核和理货员审核");
-        for(String value:List.of(row.getDispatchReviewJson(),row.getLoadingReviewJson())) {
-            try {
-                var review=json.readValue(value,Review.class);
-                if(review.status()!=ReviewStatus.APPROVED || review.reviewRound()!=row.getReviewRound() || !Objects.equals(review.basisHash(),row.getReviewBasisHash()))
-                    throw new IllegalStateException("取货审核依据已失效，请重新提交审核");
-            } catch(com.fasterxml.jackson.core.JsonProcessingException e){throw new IllegalStateException("取货审核记录读取失败",e);}
-        }
-    }
-    /** 保留驳回事实，同时明确此前批准已因资源变更失效。 */
-    private String invalidated(String value,long round) {
-        try {
-            var old=json.readValue(value,Review.class);
-            return write(new Review(old.status()==ReviewStatus.REJECTED?ReviewStatus.REJECTED:ReviewStatus.NOT_SUBMITTED,
-                old.reason(),old.reviewerId(),old.reviewedAt(),round,null,"车辆、司机或计划已变更，请重新提交两级审核",old.attachments()));
-        } catch(com.fasterxml.jackson.core.JsonProcessingException e){throw new IllegalStateException("取货审核记录读取失败",e);}
-    }
     /** 本土卡车只回写真实运输状态并追加原业务不可变历史。 */
     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("关联本土卡车单不存在");

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

@@ -51,22 +51,6 @@ public class TransportTaskService {
         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 void ensureApprovedPickup(String customer,String number,String operator) {
-        var source=pickupFacts.source(customer,number,true);
-        if(source==null)throw missing("转运单不存在");
-        if(!"WAREHOUSE_PICKUP".equals(source.getDeliveryMethod()) || !number.equals(source.getInboundCode())
-            || !"WAIT_PDA_RECEIVING".equals(source.getStatus()))return;
-        var task=pickupFacts.lockTask(source.getId());
-        // 已安排、执行或主动取消的取货任务均不因审核重放重新建单。
-        if(task!=null)return;
-        var departure=Instant.now().truncatedTo(java.time.temporal.ChronoUnit.SECONDS);
-        createPickup(operator,new FleetPickupModels.Create(List.of(new FleetPickupModels.Source(customer,number)),
-            departure,departure.plus(Duration.ofHours(24)),
-            "审核自动生成到仓取货排车；时间为暂定计划，调度确认后分配车辆司机",
-            "transfer-approval:"+source.getId()));
-    }
     /** 原单锁和有效关联唯一约束共同阻止同单重复排车。 */
     @Transactional
     public TransportTaskModels.Detail createTruck(String operator,TransportTaskModels.TruckCreate request) {
@@ -113,15 +97,6 @@ public class TransportTaskService {
         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);
     }
-    /** 取货提交与两级通过时复验真实占用、有效证照和车辆容量。 */
-    public void verifyPickupReview(String number) {
-        var trip=transport(number,true);
-        if(!"PICKUP".equals(trip.getTripPurpose()) || !"PLANNED".equals(trip.getStatus()) || pickups.tasks(trip.getTripNo()).isEmpty())throw conflict("仅有真实取货任务的未发车排车可以审核");
-        if(trip.getPlannedDepartureAt()==null || trip.getExpectedDriverEndAt()==null || !trip.getExpectedDriverEndAt().isAfter(trip.getPlannedDepartureAt()) || !trip.getExpectedDriverEndAt().isAfter(now()))throw conflict("请维护有效的计划发车与任务结束时间");
-        var pallets=trip.getMaxPalletSpaces();var weight=trip.getMaxLoadKg();var volume=trip.getMaxVolumeCbm();
-        requireResources(trip);
-        if(!Objects.equals(pallets,trip.getMaxPalletSpaces()) || !Objects.equals(weight,trip.getMaxLoadKg()) || !Objects.equals(volume,trip.getMaxVolumeCbm()))throw conflict("车辆主档已变化，请重新维护车辆信息");
-    }
     /** 取消运输并保留原单、排车及资源审计。 */
     @Transactional
     public TransportTaskModels.Detail cancel(String number,String operator,FleetTripModels.Cancel request) {

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/outsourcedbusiness/service/OutsourcedBusinessService.java

@@ -37,7 +37,7 @@ public class OutsourcedBusinessService {
     public HistoryPage history(OwnedBusinessModels.Actor actor,String number,Integer page,Integer size) {
         var result=queries.history(actor,number,page,size,SCOPE);
         return new HistoryPage(result.records().stream().map(h->new History(h.eventSource(),h.recordVersion(),h.dispatchRecordVersion(),h.action(),h.operatorName(),
-            h.occurredAt(),h.reason(),h.operations()==null?null:operations(h.operations()),h.photos().stream().filter(p->"LOADING".equals(p.category())).map(this::photo).toList())).toList(),result.page(),result.size(),result.total());
+            h.occurredAt(),h.reason(),h.operations()==null?null:operations(h.operations()),h.photos().stream().map(this::photo).toList())).toList(),result.page(),result.size(),result.total());
     }
     /** 外配只生成金额和到达的规范内部请求，不接收归属或隐藏油耗写入。 */
     public Detail save(OwnedBusinessModels.Actor actor,String number,SaveOperations request) {
@@ -71,11 +71,11 @@ public class OutsourcedBusinessService {
     }
     /** 回执公开形状不带内部里程、油耗或油耗照片摘要。 */
     private Detail detail(OwnedBusinessModels.Detail detail) {
-        return new Detail(row(detail.row(),projection.carrierName(detail)),detail.dispatch(),detail.cargo(),detail.photos().stream().filter(p->"LOADING".equals(p.category())).map(this::photo).toList());
+        return new Detail(row(detail.row(),projection.carrierName(detail)),detail.dispatch(),detail.cargo(),detail.photos().stream().map(this::photo).toList());
     }
     /** 临时车辆合法保留空vehicleId；承运商缺失保留null供页面显示破折号。 */
     private Row row(OwnedBusinessModels.Row r,String carrierName) {
-        if(!java.util.Set.of("OWNED","DISPATCHED").contains(r.vehicle().ownership()))throw conflict("外配运营快照的车辆归属或照片不合法");
+        if(!java.util.Set.of("OWNED","DISPATCHED").contains(r.vehicle().ownership()) || r.photoSummary().fuelCount()!=0)throw conflict("外配运营快照的车辆归属或照片不合法");
         return new Row(r.dispatchNo(),r.stage(),r.plannedDepartureAt(),r.loadingCompletedAt(),r.departedAt(),r.deliveryCompletedAt(),r.origin(),
             new Vehicle(r.vehicle().vehicleId(),r.vehicle().plate(),r.vehicle().ownership(),carrierName==null || carrierName.isBlank()?null:carrierName),r.driver(),r.destinations(),
             r.actualPalletCount(),operations(r.operations()),r.unitPrice(),r.recordVersion(),r.dispatchRecordVersion(),new PhotoSummary(r.photoSummary().loadingCount()),r.actions(),r.sourceIssues());
@@ -85,7 +85,7 @@ public class OutsourcedBusinessService {
         if(ops.actualDistanceMiles()!=null || ops.fuelConsumptionLitresPer100Km()!=null)throw conflict("外配业务不能包含里程或油耗登记");
         return new Operations(ops.money(),ops.arrivals());
     }
-    /** 外配照片枚举只有五框，排车油耗图片保留在共用记录中但不在外配入口输出。 */
+    /** 外配照片枚举只有五框，异常油耗历史不能借复用向外输出。 */
     private Photo photo(OwnedBusinessModels.Photo p) {
         SCOPE.requireSlot(p.slot());return new Photo(PhotoSlot.valueOf(p.slot().name()),p.category(),p.fileId(),p.fileName(),p.contentType(),p.sizeBytes(),p.uploadedAt(),p.savedAt());
     }

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/ownedbusiness/controller/DispatchVehicleDocumentController.java

@@ -1,76 +0,0 @@
-package com.baiyue.lastleg.fleet.ownedbusiness.controller;
-
-import com.baiyue.common.core.api.ApiResponse;
-import com.baiyue.common.security.AuthenticatedUser;
-import com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessModels.*;
-import com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessScope;
-import com.baiyue.lastleg.fleet.ownedbusiness.service.*;
-import jakarta.validation.Valid;
-import jakarta.validation.constraints.*;
-import org.springframework.http.*;
-import org.springframework.security.access.prepost.PreAuthorize;
-import org.springframework.security.core.annotation.AuthenticationPrincipal;
-import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.*;
-import org.springframework.web.multipart.MultipartFile;
-import java.util.List;
-
-/** 排车资料入口复用车队原照片记录；签收及BOL仍由派送单管理。 */
-@RestController
-@Validated
-@RequestMapping("/api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents")
-public class DispatchVehicleDocumentController {
-    private static final OwnedBusinessScope SCOPE=OwnedBusinessScope.DISPATCH;
-    private final OwnedBusinessQueryService queries;
-    private final OwnedBusinessPhotoService photos;
-    private final OwnedBusinessSupport access;
-    /** 沿已有服务复用来源校验、文件归属、版本和命令账本。 */
-    public DispatchVehicleDocumentController(OwnedBusinessQueryService queries,OwnedBusinessPhotoService photos,OwnedBusinessSupport access) {
-        this.queries=queries;this.photos=photos;this.access=access;
-    }
-    public record Documents(String dispatchNo,String recordVersion,boolean editable,List<Photo> photos) {}
-    /** 只输出油耗资料，避免把车队签收照片当作派送签收文件。 */
-    private Documents documents(Detail value) {
-        return new Documents(value.row().dispatchNo(),value.row().recordVersion(),value.row().actions().upload().allowed(),
-            value.photos().stream().filter(p->"FUEL".equals(p.category())).toList());
-    }
-    /** 排车列表权限包含车辆资料只读，不扩大派送单客户访问权限。 */
-    @GetMapping
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:list')")
-    public ApiResponse<Documents> get(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo) {
-        return ApiResponse.success(documents(queries.detail(access.actor(user,SCOPE),dispatchNo,SCOPE)));
-    }
-    /** 上传和引用保存分开，沿原请求键防止重传。 */
-    @PostMapping(value="/{slot}/uploads",consumes=MediaType.MULTIPART_FORM_DATA_VALUE)
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<Photo> upload(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable PhotoSlot slot,
-        @RequestParam @Size(min=8,max=128) String idempotencyKey,@RequestPart("file") MultipartFile file) {
-        return ApiResponse.success(photos.upload(access.actor(user,SCOPE),dispatchNo,slot,idempotencyKey,file,SCOPE));
-    }
-    /** 只更新既有附加资料版本，不修改排车阶段或签收状态。 */
-    @PutMapping("/{slot}")
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<Documents> bind(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable PhotoSlot slot,@Valid @RequestBody BindPhoto request) {
-        return ApiResponse.success(documents(photos.bind(access.actor(user,SCOPE),dispatchNo,slot,request,SCOPE)));
-    }
-    /** 预览只读取本车当前已经绑定的照片。 */
-    @GetMapping("/{slot}/files/{fileId}/content")
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:list')")
-    public ResponseEntity<byte[]> content(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable PhotoSlot slot,@PathVariable @Positive long fileId) {
-        var value=photos.content(access.actor(user,SCOPE),dispatchNo,slot,fileId,null,SCOPE);
-        return ResponseEntity.ok().cacheControl(CacheControl.noStore()).contentType(MediaType.parseMediaType(value.photo().contentType()))
-            .header("X-Content-Type-Options","nosniff").body(value.content());
-    }
-    /** 恢复仅返回油耗上传结果，不通过排车入口暴露其他运营命令。 */
-    @GetMapping("/uploads/{idempotencyKey}")
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<Photo> recover(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable String idempotencyKey) {
-        var actor=access.actor(user,SCOPE);
-        access.require(actor,SCOPE.uploadPermission());
-        var command=photos.command(actor,dispatchNo,idempotencyKey,SCOPE);
-        if(!"UPLOAD_PHOTO".equals(command.action()) || !"SUCCEEDED".equals(command.state()) || command.result()==null)
-            throw OwnedBusinessSupport.conflict("原上传结果尚未确认，请保留原请求稍后核对");
-        var value=access.read(access.write(command.result()),Photo.class);SCOPE.requireSlot(value.slot());
-        return ApiResponse.success(value);
-    }
-}

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/ownedbusiness/model/OwnedBusinessScope.java

@@ -7,8 +7,7 @@ import com.baiyue.common.core.api.ResultCode;
 /** 仅服务端固定入口选择的作用域；不得成为浏览器请求字段或权限别名。 */
 public enum OwnedBusinessScope {
     OWNED(false,"platform:fleet:owned-business:"),
-    OUTSOURCED(true,"platform:fleet:outsourced-business:"),
-    DISPATCH(false,"platform:overseas-warehouse:dispatch:");
+    OUTSOURCED(true,"platform:fleet:outsourced-business:");
     private final boolean pooledCargo;
     private final String prefix;
     /** 业务入口按是否实际接入拼车货物分类，与车辆归属独立。 */
@@ -20,9 +19,9 @@ public enum OwnedBusinessScope {
     /** 运营写权限独立，外配权限不映射成自有权限。 */
     public String editPermission(){return prefix+"edit";}
     /** 照片写权限独立，不扩大到原排车。 */
-    public String uploadPermission(){return prefix+(this==DISPATCH?"edit":"upload");}
+    public String uploadPermission(){return prefix+"upload";}
     /** 外配只支持装车五框，服务调用同样不能绕过。 */
-    public void requireSlot(PhotoSlot slot){if(slot==null || this==OUTSOURCED && !"LOADING".equals(slot.category()) || this==DISPATCH && !"FUEL".equals(slot.category()))throw new BizException(ResultCode.BAD_REQUEST,"当前业务不支持该照片框");}
+    public void requireSlot(PhotoSlot slot){if(slot==null || this==OUTSOURCED && !"LOADING".equals(slot.category()))throw new BizException(ResultCode.BAD_REQUEST,"当前业务不支持该照片框");}
     /** 不存在只显示当前业务归属，不泄露内部身份。 */
-    public BizException missing(){return new BizException(ResultCode.NOT_FOUND,this==DISPATCH?"排车单不存在":"排车单不存在或不属于当前"+(this==OWNED?"自有业务":"外配任务"));}
+    public BizException missing(){return new BizException(ResultCode.NOT_FOUND,"排车单不存在或不属于当前"+(this==OWNED?"自有业务":"外配任务"));}
 }

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/ownedbusiness/port/DispatchLoadingPhotoPort.java

@@ -1,29 +0,0 @@
-package com.baiyue.lastleg.fleet.ownedbusiness.port;
-
-import jakarta.validation.constraints.*;
-import java.util.List;
-import org.springframework.web.multipart.MultipartFile;
-
-/** 整车装车资料公开端口；排车只组合资料事实，不读取车队持久化实现。 */
-public interface DispatchLoadingPhotoPort {
-    enum Slot { LOADING_SCENE, LOADING_LIST, PRE_DEPARTURE_CHECK, DRIVER_LICENSE, RECEIPT }
-    record Photo(Slot slot,String category,String fileId,String fileName,String contentType,String sizeBytes,String uploadedAt,String savedAt) {}
-    record BindPhoto(@NotBlank String recordVersion,@NotBlank @Size(min=8,max=128) String idempotencyKey,@NotBlank String fileId) {}
-    record State(String recordVersion,List<Photo> photos) {}
-    record Documents(String dispatchNo,String recordVersion,String dispatchRecordVersion,String stage,boolean editable,boolean complete,List<Photo> photos) {}
-    record Download(Photo photo,byte[] content) {}
-    /** 只读取原整车附加资料版本与五框，不初始化记录。 */
-    State read(long dispatchId);
-    /** 上传保存原请求意图；不提前计入已保存照片。 */
-    Photo upload(long dispatchId,String operator,Slot slot,String key,MultipartFile file);
-    /** 仅原操作者可恢复原上传结果。 */
-    Photo recover(long dispatchId,String operator,String key);
-    /** 先校验原槽位、完整载荷与操作者；无原成功命令时返回null。 */
-    Documents replayBind(long dispatchId,String operator,Slot slot,BindPhoto request);
-    /** 调用者已持排车父锁；保存照片、资料版本及历史但不单独提交事务。 */
-    State bind(long dispatchId,String operator,Slot slot,BindPhoto request);
-    /** 与绑定及自动发车共同提交完整原结果。 */
-    void recordBind(long dispatchId,String operator,Slot slot,BindPhoto request,Documents result);
-    /** 文件只可从本车当前已绑定槽位下载。 */
-    Download content(long dispatchId,Slot slot,long fileId);
-}

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/ownedbusiness/service/DispatchLoadingPhotoAdapter.java

@@ -1,124 +0,0 @@
-package com.baiyue.lastleg.fleet.ownedbusiness.service;
-
-import com.baomidou.mybatisplus.core.toolkit.IdWorker;
-import com.baiyue.common.core.api.ResultCode;
-import com.baiyue.common.core.exception.BizException;
-import com.baiyue.lastleg.fleet.ownedbusiness.gateway.*;
-import com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessModels;
-import com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessModels.PhotoSlot;
-import com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessRows;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort;
-import com.baiyue.lastleg.fleet.ownedbusiness.repository.OwnedBusinessRepository;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.*;
-import org.springframework.web.multipart.MultipartFile;
-import java.io.IOException;
-import java.time.Instant;
-import java.util.*;
-import static com.baiyue.lastleg.fleet.ownedbusiness.service.OwnedBusinessSupport.*;
-
-/** 在原照片表和命令账本实现装车资料端口，不反向调用排车履约服务。 */
-@Service
-public class DispatchLoadingPhotoAdapter implements DispatchLoadingPhotoPort {
-    private final OwnedBusinessRepository repository;
-    private final OwnedBusinessCommandService commands;
-    private final OwnedBusinessProjection projection;
-    private final OwnedBusinessSupport codec;
-    private final OwnedBusinessFileGateway files;
-    /** 复用现有照片、版本、历史及文件归属校验。 */
-    public DispatchLoadingPhotoAdapter(OwnedBusinessRepository repository,OwnedBusinessCommandService commands,
-        OwnedBusinessProjection projection,OwnedBusinessSupport codec,OwnedBusinessFileGateway files) {
-        this.repository=repository;this.commands=commands;this.projection=projection;this.codec=codec;this.files=files;
-    }
-    public record Binding(Slot slot,BindPhoto request) {}
-    /** GET只读；首次保存前资料版本为0。 */
-    @Override public State read(long id) {
-        var row=repository.record(id);
-        return new State(row==null?"0":row.getRecordVersion().toString(),projection.photos(row).stream()
-            .filter(p->"LOADING".equals(p.category())).map(this::publicPhoto).toList());
-    }
-    /** 先落稳定上传意图，再请求File；未知结果不允许换键重传。 */
-    @Override public Photo upload(long id,String operator,Slot slot,String key,MultipartFile multipart) {
-        codec.key(key);var originalSlot=slot(slot);
-        if(multipart==null || multipart.isEmpty() || multipart.getSize()>HttpOwnedBusinessFileGateway.MAX_SIZE)throw bad("照片须为非空JPG/PNG，最大10MiB");
-        byte[] bytes;try{bytes=multipart.getBytes();}catch(IOException failure){throw bad("无法读取待上传照片");}
-        var payload=new OwnedBusinessFileGateway.Upload(multipart.getOriginalFilename(),multipart.getContentType(),bytes);
-        HttpOwnedBusinessFileGateway.validate(payload);
-        var identity=new OwnedBusinessPhotoService.UploadIdentity(originalSlot,payload.fileName(),payload.contentType(),bytes.length,codec.digest(bytes));
-        var reservation=commands.reserveUpload(id,operator(operator),key,identity);
-        if(!reservation.created())return uploaded(reservation.command());
-        try {
-            var result=photo(originalSlot,files.upload(id,originalSlot,operator,payload));
-            commands.finishUpload(reservation.command(),"SUCCEEDED",result,null);return publicPhoto(result);
-        } catch(RuntimeException failure) {
-            try{commands.finishUpload(reservation.command(),"UNKNOWN_RESULT",null,"DISPATCH_LOADING_UPLOAD_UNKNOWN");}
-            catch(RuntimeException recording){failure.addSuppressed(recording);}
-            throw conflict("照片上传结果未知，请保留原请求键核对");
-        }
-    }
-    /** 上传结果仅限本车原操作者及装车槽位。 */
-    @Override public Photo recover(long id,String operator,String key) {
-        codec.key(key);var command=commands.existing(id,key,operator(operator));
-        if(command==null)throw new BizException(ResultCode.NOT_FOUND,"未找到本车原上传请求");return uploaded(command);
-    }
-    /** 完整原结果先于当前资料版本比较，防止重复推进。 */
-    @Override public Documents replayBind(long id,String operator,Slot slot,BindPhoto request) {
-        validate(slot,request);var old=commands.existing(id,request.idempotencyKey(),operator(operator));
-        if(old==null)return null;
-        commands.same(old,"BIND_LOADING_DOCUMENT",codec.version(request.recordVersion()),new Binding(slot,request));
-        if(!"SUCCEEDED".equals(old.getStatus()))throw conflict("原资料保存结果尚未确认");return codec.read(old.getResultJson(),Documents.class);
-    }
-    /** 父排车锁由调用者持有；附加版本竞争与最后一张发车失败沿外层事务回滚。 */
-    @Override @Transactional(propagation=Propagation.MANDATORY,isolation=Isolation.READ_COMMITTED)
-    public State bind(long id,String operator,Slot slot,BindPhoto request) {
-        validate(slot,request);long version=codec.version(request.recordVersion());var originalSlot=slot(slot);
-        var verified=photo(originalSlot,files.metadata(id,originalSlot,codec.version(request.fileId())));
-        var seed=new OwnedBusinessRows.Record();seed.setId(IdWorker.getId());seed.setDispatchId(id);
-        seed.setCreatedBy(operator);seed.setUpdatedBy(operator);seed.setCreatedAt(codec.utc(Instant.now()));seed.setUpdatedAt(seed.getCreatedAt());
-        var row=repository.lock(seed);
-        if(row==null || row.getRecordVersion()==null || row.getRecordVersion()!=version)throw conflict("装车资料已被其他操作更新，请刷新后核对");
-        var photos=new EnumMap<PhotoSlot,OwnedBusinessModels.Photo>(PhotoSlot.class);for(var p:projection.photos(row))photos.put(p.slot(),p);
-        photos.put(originalSlot,new OwnedBusinessModels.Photo(originalSlot,originalSlot.category(),verified.fileId(),verified.fileName(),verified.contentType(),verified.sizeBytes(),verified.uploadedAt(),Instant.now().toString()));
-        row.setPhotosJson(codec.write(List.copyOf(photos.values())));row.setRecordVersion(Math.addExact(version,1));row.setUpdatedBy(operator);row.setUpdatedAt(codec.utc(Instant.now()));
-        if(repository.update(row,version)!=1)throw conflict("装车资料版本竞争失败");
-        var history=new OwnedBusinessRows.History();history.setId(IdWorker.getId());history.setDispatchId(id);history.setRecordVersion(row.getRecordVersion());
-        history.setAction("BIND_LOADING_DOCUMENT");history.setOperatorId(operator);history.setReason("保存装车照片 "+(slot.ordinal()+1));history.setOccurredAt(row.getUpdatedAt());
-        history.setSnapshotJson(codec.write(new OwnedBusinessModels.Snapshot(projection.operations(row),projection.photos(row),operator)));repository.history(history);
-        return read(id);
-    }
-    /** 保存调用者提供的最终阶段，命令与资料、派送同事务提交。 */
-    @Override @Transactional(propagation=Propagation.MANDATORY)
-    public void recordBind(long id,String operator,Slot slot,BindPhoto request,Documents result) {
-        commands.success(id,operator(operator),request.idempotencyKey(),"BIND_LOADING_DOCUMENT",codec.version(request.recordVersion()),new Binding(slot,request),result);
-    }
-    /** 下载仅允许当前已保存引用，不接受未绑定上传或其他车文件。 */
-    @Override public Download content(long id,Slot slot,long fileId) {
-        var originalSlot=slot(slot);var photo=projection.photos(repository.record(id)).stream()
-            .filter(p->p.slot()==originalSlot && String.valueOf(fileId).equals(p.fileId())).findFirst()
-            .orElseThrow(()->new BizException(ResultCode.NOT_FOUND,"本车未绑定该装车照片"));
-        return new Download(publicPhoto(photo),files.content(id,originalSlot,fileId));
-    }
-    /** 原五框技术名保持文件归属，拒绝油耗框作为装车资料。 */
-    private PhotoSlot slot(Slot slot){if(slot==null)throw bad("请选择有效的装车照片框");return PhotoSlot.valueOf(slot.name());}
-    /** 版本0合法，文件编号必须为正且请求键不得缺失。 */
-    private void validate(Slot slot,BindPhoto request) {
-        slot(slot);if(request==null)throw bad("照片绑定请求缺失");codec.key(request.idempotencyKey());codec.version(request.recordVersion());
-        if(codec.version(request.fileId())<=0)throw bad("文件编号无效");
-    }
-    /** 账本只消费可信操作者；平台/PDA权限在排车入口复核。 */
-    private OwnedBusinessModels.Actor operator(String operator){return new OwnedBusinessModels.Actor(operator,operator,Set.of());}
-    /** 回执必须是已知成功上传，其他类别或未明确结果不得充数。 */
-    private Photo uploaded(OwnedBusinessRows.Command command) {
-        if(!"UPLOAD_PHOTO".equals(command.getAction()) || !"SUCCEEDED".equals(command.getStatus()) || command.getResultJson()==null)throw conflict("原上传结果尚未确认，请保留原请求");
-        var value=codec.read(command.getResultJson(),OwnedBusinessModels.Photo.class);
-        if(!"LOADING".equals(value.category()))throw bad("原上传不是装车照片");return publicPhoto(value);
-    }
-    /** 外部事实仅投影照片字段，不暴露持久化记录。 */
-    private Photo publicPhoto(OwnedBusinessModels.Photo photo) {
-        return new Photo(Slot.valueOf(photo.slot().name()),photo.category(),photo.fileId(),photo.fileName(),photo.contentType(),photo.sizeBytes(),photo.uploadedAt(),photo.savedAt());
-    }
-    /** 上传回执不伪造保存时间。 */
-    private OwnedBusinessModels.Photo photo(PhotoSlot slot,OwnedBusinessFileGateway.Evidence value) {
-        return new OwnedBusinessModels.Photo(slot,slot.category(),Long.toString(value.fileId()),value.fileName(),value.contentType(),Long.toString(value.sizeBytes()),value.uploadedAt(),null);
-    }
-}

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/ownedbusiness/service/OwnedBusinessProjection.java

@@ -53,7 +53,8 @@ public class OwnedBusinessProjection {
         var resources=codec.read(source.getResourcesJson(),Resources.class);
         if(resources.vehicle()==null)throw OwnedBusinessSupport.conflict("原车辆快照缺失");
         var ops=operations(record);var photos=photos(record);int pallets=palletCount(source);
-        if(scope==OwnedBusinessScope.OUTSOURCED && (ops.actualDistanceMiles()!=null || ops.fuelConsumptionLitresPer100Km()!=null))throw OwnedBusinessSupport.conflict("外配运营记录含不支持的里程、油耗或照片");
+        if(scope==OwnedBusinessScope.OUTSOURCED && (ops.actualDistanceMiles()!=null || ops.fuelConsumptionLitresPer100Km()!=null
+            || photos.stream().anyMatch(p->!"LOADING".equals(p.category()))))throw OwnedBusinessSupport.conflict("外配运营记录含不支持的里程、油耗或照片");
         var arrivals=new HashMap<String,String>();for(var a:ops.arrivals())arrivals.put(a.destinationKey(),a.actualArrivedAt());
         var destinations=new LinkedHashMap<String,Destination>();
         for(var item:cargo) {

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/ownedbusiness/service/OwnedBusinessQueryService.java

@@ -93,10 +93,9 @@ public class OwnedBusinessQueryService {
         if(source.getOwnedVehicleOwnership()==null)throw conflict("本单缺少装车时车辆归属证据，不能归入"+(scope==OwnedBusinessScope.OWNED?"自有":"外配")+"业务");
         if(!Set.of("OWNED","DISPATCHED").contains(source.getOwnedVehicleOwnership()))throw conflict("装车车辆归属不合法");
         if(source.getPooledCargo()==null)throw conflict("本单缺少实际拼车分类依据");
-        if(scope!=OwnedBusinessScope.DISPATCH && scope.isPooledCargo()!=source.getPooledCargo())throw scope.missing();
+        if(scope.isPooledCargo()!=source.getPooledCargo())throw scope.missing();
         if(!"ACTIVE".equals(source.getStatus()) || source.getStage()==null || !Set.of("AFTER_LOADING","DELIVERING","DELIVERED").contains(source.getStage())
             || source.getLoadingCompletedAt()==null || source.getLoadingConfirmationJson()==null)throw conflict("本单尚无合法装车完成事实");
-        if(scope==OwnedBusinessScope.DISPATCH && !Set.of("DELIVERING","DELIVERED").contains(source.getStage()))throw conflict("仅派送中和配送完成可管理车辆资料");
         var resource=codec.read(source.getResourcesJson(),DispatchContracts.Resources.class).vehicle();
         boolean master=resource!=null && resource.mode()!=null && "MASTER".equals(resource.mode().name()) && "MASTER".equals(source.getOwnedResourceMode())
             && resource.vehicleId()!=null && Objects.equals(source.getOwnedVehicleId(),resource.vehicleId());

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/pickup/FleetPickupMapper.java

@@ -39,9 +39,6 @@ public interface FleetPickupMapper extends BaseMapper<FleetPickupTask> {
     /** 解除计划中的取货关联，保留历史后允许再次安排。 */
     @Update("UPDATE ll_fleet_pickup_task SET trip_no=NULL,status='WAITING',updated_at=CURRENT_TIMESTAMP WHERE trip_no=#{tripNo} AND status='ASSIGNED'")
     int unassign(@Param("tripNo") String tripNo);
-    /** 原单同时取消时保留车次关联供详情和审计追溯，不再回到待安排。 */
-    @Update("UPDATE ll_fleet_pickup_task SET status='CANCELLED',updated_at=CURRENT_TIMESTAMP WHERE trip_no=#{tripNo} AND status='ASSIGNED'")
-    int cancelTasks(@Param("tripNo") String tripNo);
     /** 不可变操作历史覆盖安排、解除、取货、到仓及结案。 */
     @Insert("INSERT INTO ll_fleet_pickup_history(customer_id,transfer_no,trip_no,action,operator_id,occurred_at,detail) VALUES(#{customer},#{number},#{trip},#{action},#{operator},CURRENT_TIMESTAMP,#{detail})")
     int history(@Param("customer") String customer,@Param("number") String number,@Param("trip") String trip,

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/pickup/FleetPickupModels.java

@@ -24,10 +24,7 @@ public final class FleetPickupModels {
                          @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<@NotNull @Positive Long> evidenceFileIds) {
-        /** 无照片的非送仓命令保持原调用形式。 */
-        public Command(Long recordVersion,String idempotencyKey,String reason){this(recordVersion,idempotencyKey,reason,null);}
-    }
+                          @NotBlank @Size(max=1000) String reason) { }
     public record Pickup(@NotNull @Min(0) Long recordVersion,
                          @NotBlank @Size(min=8,max=128) String idempotencyKey,
                          @Min(1) @Max(5000) int actualPackages,
@@ -38,9 +35,6 @@ public final class FleetPickupModels {
                        String status, String tripNo, String vehiclePlate, String driverName, String driverPhone,
                        Instant plannedDepartureAt, Integer actualPackages, Instant pickedAt, Instant arrivedAt,
                        String remark, List<Evidence> evidence) { }
-    public record Evidence(String fileId, String fileName, String contentType, long sizeBytes,String phase) {
-        /** 旧取货凭证明确归入取货阶段，不冒充到仓照片。 */
-        public Evidence(String fileId,String fileName,String contentType,long sizeBytes){this(fileId,fileName,contentType,sizeBytes,"PICKUP");}
-    }
+    public record Evidence(String fileId, String fileName, String contentType, long sizeBytes) { }
     public record History(String action, String tripNo, String operatorId, Instant occurredAt, String detail) { }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/pickup/FleetPickupRepository.java

@@ -34,8 +34,6 @@ public class FleetPickupRepository {
     public FleetPickupTask lockTask(long id) { return mapper.lockTask(id); }
     /** 释放未开始的成员关联。 */
     public int unassign(String number) { return mapper.unassign(number); }
-    /** 联动取消保留原车次与转运单的可追溯关联。 */
-    public int cancelTasks(String number) { return mapper.cancelTasks(number); }
     /** 保存不可变业务操作记录。 */
     public void history(FleetPickupTask task,String action,String operator,String detail) { mapper.history(task.getCustomerId(),task.getTransferNo(),task.getTripNo(),action,operator,detail); }
     /** 核对旧拼车承运关系，防止同票走两条运输链。 */

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/pickup/FleetPickupService.java

@@ -28,13 +28,11 @@ public class FleetPickupService {
     private final VehicleRepository vehicles;
     private final TripOperationsEvidenceGateway files;
     private final ObjectMapper json;
-    private final PickupDepartureReview departureReview;
     /** 共用现有车次、司机资格、车辆占用及鉴权文件能力。 */
     public FleetPickupService(FleetPickupRepository repository,FleetTripService trips,FleetWarehouseDirectory warehouses,
-        DriverService drivers,VehicleRepository vehicles,TripOperationsEvidenceGateway files,ObjectMapper json,PickupDepartureReview departureReview) {
+        DriverService drivers,VehicleRepository vehicles,TripOperationsEvidenceGateway files,ObjectMapper json) {
         this.repository=repository;this.trips=trips;this.warehouses=warehouses;this.drivers=drivers;
         this.vehicles=vehicles;this.files=files;this.json=json;
-        this.departureReview=departureReview;
     }
     /** 审核通过的原单自动出现在候选中，客户自送和库存转运不参与。 */
     @Transactional(readOnly=true,isolation=org.springframework.transaction.annotation.Isolation.REPEATABLE_READ)
@@ -122,7 +120,6 @@ public class FleetPickupService {
         if(replayed(trip,request.idempotencyKey(),hash))return trips.detail(number);
         version(trip,request.recordVersion());
         if(!"PLANNED".equals(trip.getStatus()) || repository.tasks(number).isEmpty())throw conflict("仅有取货任务的计划车次可以发车");
-        departureReview.requireApproved(trip.getId());
         requireResources(trip);
         for(var task:repository.tasks(number))eligible(source(task.getCustomerId(),task.getTransferNo(),true));
         trip.setStatus("IN_TRANSIT");trip.setDepartedAt(now());
@@ -145,47 +142,28 @@ public class FleetPickupService {
         var trip=pickupTrip(number,true);String hash=commandHash("PICKED:"+customer+":"+transferNo,request);
         if(replayed(trip,request.idempotencyKey(),hash))return tasks(number);
         version(trip,request.recordVersion());var task=member(trip,customer,transferNo);
-        if(!Set.of("PLANNED","IN_TRANSIT").contains(trip.getStatus()) || !"ASSIGNED".equals(task.getStatus()))throw conflict("该单尚未处于可确认取货阶段");
-        if("PLANNED".equals(trip.getStatus()))departureReview.requireApproved(trip.getId());
-        if(request.actualPackages()<=0 || request.evidenceFileIds()==null || request.evidenceFileIds().isEmpty() || request.evidenceFileIds().size()>10)throw bad("请填写实提箱数并上传取货照片");
+        if(!"IN_TRANSIT".equals(trip.getStatus()) || !"ASSIGNED".equals(task.getStatus()))throw conflict("请先发车，且该单尚未确认取货");
         eligible(source(customer,transferNo,true));
         var evidence=request.evidenceFileIds().stream().distinct().map(id->{
             if(!repository.ownsUpload(task.getTransferOrderId(),number,id))throw bad("取货凭证不属于当前订单或车次");
             var file=files.metadata(trip.getId(),id);
-            if(file.contentType()==null || !file.contentType().startsWith("image/"))throw bad("请上传有效取货照片");
             return new FleetPickupModels.Evidence(String.valueOf(file.fileId()),file.fileName(),file.contentType(),file.sizeBytes());
         }).toList();
         task.setStatus("PICKED");task.setActualPackages(request.actualPackages());task.setPickedAt(now());
         task.setEvidenceJson(write(evidence));task.setRemark(blank(request.remark()));task.setUpdatedAt(now());repository.update(task);
         repository.history(task,"PICKED",operator,"实提"+request.actualPackages()+"箱；"+Objects.toString(task.getRemark(),""));
-        // 全车照片和实提数量核齐后自动进入派送中，不能以发车按钮代替取货照片。
-        if("PLANNED".equals(trip.getStatus()) && repository.tasks(number).stream().allMatch(row->"PICKED".equals(row.getStatus()))) {
-            requireResources(trip);trip.setStatus("IN_TRANSIT");trip.setDepartedAt(now());
-        }
         trips.recordExecution(trip,request.recordVersion(),"PICKUP_PICKED","确认原单取货",operator);
         repository.command(number,request.idempotencyKey(),hash);return tasks(number);
     }
-    /** 到仓照片独立归档，全部送仓后自动完成本次取货派送并开放PDA清点。 */
+    /** 到仓确认只开放 PDA 清点，不覆盖预报箱数和 SKU 件数。 */
     @Transactional
     public List<FleetPickupModels.Task> arrive(String number,String customer,String transferNo,String operator,FleetPickupModels.Command request) {
         var trip=pickupTrip(number,true);String hash=commandHash("ARRIVED:"+customer+":"+transferNo,request);
         if(replayed(trip,request.idempotencyKey(),hash))return tasks(number);
         version(trip,request.recordVersion());var task=member(trip,customer,transferNo);
         if(!"IN_TRANSIT".equals(trip.getStatus()) || !"PICKED".equals(task.getStatus()))throw conflict("请先确认该单已取货");
-        if(request.evidenceFileIds()==null || request.evidenceFileIds().isEmpty() || request.evidenceFileIds().size()>10)throw bad("请上传到仓照片");
-        var old=evidence(task);var arrival=new ArrayList<FleetPickupModels.Evidence>(old);
-        for(long id:request.evidenceFileIds().stream().distinct().toList()) {
-            if(!repository.ownsUpload(task.getTransferOrderId(),number,id) || old.stream().anyMatch(file->file.fileId().equals(String.valueOf(id))))throw bad("请上传本票新的到仓照片，不能复用取货照片");
-            var file=files.metadata(trip.getId(),id);
-            if(file.contentType()==null || !file.contentType().startsWith("image/"))throw bad("请上传有效到仓照片");
-            arrival.add(new FleetPickupModels.Evidence(String.valueOf(file.fileId()),file.fileName(),file.contentType(),file.sizeBytes(),"ARRIVAL"));
-        }
-        source(customer,transferNo,true);task.setStatus("ARRIVED");task.setArrivedAt(now());task.setEvidenceJson(write(arrival));task.setUpdatedAt(now());repository.update(task);
+        source(customer,transferNo,true);task.setStatus("ARRIVED");task.setArrivedAt(now());task.setUpdatedAt(now());repository.update(task);
         repository.history(task,"ARRIVED",operator,request.reason());
-        if(repository.tasks(number).stream().allMatch(row->"ARRIVED".equals(row.getStatus()))) {
-            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())));
-        }
         trips.recordExecution(trip,request.recordVersion(),"PICKUP_ARRIVED",request.reason(),operator);
         repository.command(number,request.idempotencyKey(),hash);return tasks(number);
     }

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/pickup/PickupDepartureReview.java

@@ -1,7 +0,0 @@
-package com.baiyue.lastleg.fleet.pickup;
-
-/** 取货发车必须通过排车主单的本轮两级审核。 */
-public interface PickupDepartureReview {
-    /** 调用方已持车次锁，校验并锁定对应排车审核事实。 */
-    void requireApproved(long tripId);
-}

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/pickup/PickupOrderCancellation.java

@@ -1,9 +0,0 @@
-package com.baiyue.lastleg.fleet.pickup;
-
-import java.util.List;
-
-/** 原单所属域负责取消未执行取货的转运业务，失败时整车取消回滚。 */
-public interface PickupOrderCancellation {
-    /** 调用方持有车次锁，按稳定来源顺序取消全部成员。 */
-    void cancel(List<FleetPickupModels.Source> sources,String tripNo,String operator,String reason);
-}

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

@@ -34,7 +34,6 @@ public class FleetTripService {
     @jakarta.annotation.Resource private com.baiyue.lastleg.appointmentwork.AppointmentWorkDispatchPort appointmentAllocations;
     private final FleetTripRepository repository;
     @jakarta.annotation.Resource private com.baiyue.lastleg.fleet.pickup.FleetPickupRepository pickups;
-    @jakarta.annotation.Resource private com.baiyue.lastleg.fleet.pickup.PickupOrderCancellation pickupCancellation;
     private final FleetDispatchGateway dispatches;
     private final VehicleRepository vehicles;
     private final DriverService drivers;
@@ -468,20 +467,18 @@ public class FleetTripService {
 
 
 
-    /** 取消未执行车次，取货同时取消全部转运原单并释放资源。 */
+    /** 取消未执行车次，释放资源并将取货原单退回待安排。 */
     @Transactional
     public FleetTripModels.Detail cancel(String tripNo, String operator, FleetTripModels.Cancel request) {
         FleetTripEntity trip = planned(tripNo, request.recordVersion());
         requireReason(request.reason());
         if ("PICKUP".equals(trip.getTripPurpose())) {
             // 取消车次与释放原单关联同事务，失败时全部回滚。
-            var tasks=pickups.tasks(tripNo);
-            for (var task : tasks) {
+            for (var task : pickups.tasks(tripNo)) {
                 if (!"ASSIGNED".equals(task.getStatus())) throw conflict("已开始取货，不能取消车次");
+                pickups.history(task,"UNASSIGN",operator,request.reason());
             }
-            pickupCancellation.cancel(tasks.stream().map(task->new com.baiyue.lastleg.fleet.pickup.FleetPickupModels.Source(task.getCustomerId(),task.getTransferNo())).toList(),tripNo,operator,request.reason());
-            for(var task:tasks)pickups.history(task,"CANCEL",operator,"取消排车及转运单："+request.reason());
-            if(pickups.cancelTasks(tripNo)!=tasks.size())throw conflict("取货关联已变化，取消未完成");
+            pickups.unassign(tripNo);
         }
         if (!repository.listBindings(trip.getId()).isEmpty()) throw conflict("请先解除客户排车单关联，再取消车次");
         if (bookingReservations.hasConfirmed(trip.getId())) throw conflict("请先取消已确认的外接预订，再取消车次");
@@ -557,7 +554,6 @@ public class FleetTripService {
         if (trip == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "车次不存在");
         if (trip.getRecordVersion() != version) throw conflict("车次已被修改，请刷新后重试");
         if (!"PLANNED".equals(trip.getStatus())) throw conflict("仅计划中的车次允许此操作");
-        if("PICKUP".equals(trip.getTripPurpose()) && pickups.tasks(number).stream().anyMatch(task->!"ASSIGNED".equals(task.getStatus())))throw conflict("已开始取货，不能修改资源、计划或取消排车");
         return trip;
     }
     /** 复核创建请求摘要，同键不同内容不允许复用。 */

lastleg-service/src/main/java/com/baiyue/lastleg/transfer/mapper/TransferPickupCancellationMapper.java

@@ -1,30 +0,0 @@
-package com.baiyue.lastleg.transfer.mapper;
-
-import com.baiyue.lastleg.transfer.entity.WarehouseTransferOrder;
-import org.apache.ibatis.annotations.*;
-
-/** 仅取消本客户外来取货的待执行原单，不释放或回滚任何已入库库存。 */
-@Mapper
-public interface TransferPickupCancellationMapper {
-    /** 与PDA共用转运原单锁，串行核验收货事实。 */
-    @Select("SELECT * FROM ll_warehouse_transfer_order WHERE customer_id=#{customer} AND transfer_no=#{number} FOR UPDATE")
-    WarehouseTransferOrder lock(@Param("customer") String customer,@Param("number") String number);
-    /** 任何收货、箱清点或托盘测量开始后均禁止普通取消。 */
-    @Select("SELECT (SELECT COUNT(*) FROM ll_warehouse_transfer_receipt WHERE customer_id=#{customer} AND transfer_order_id=#{id}) + (SELECT COUNT(*) FROM ll_warehouse_transfer_carton WHERE customer_id=#{customer} AND transfer_order_id=#{id} AND counted_at IS NOT NULL) + (SELECT COUNT(*) FROM ll_warehouse_transfer_pallet WHERE customer_id=#{customer} AND transfer_order_id=#{id})")
-    int started(@Param("customer") String customer,@Param("id") long id);
-    /** 同一取消事务只接受待PDA收货的转运单。 */
-    @Update("UPDATE ll_warehouse_transfer_order SET status='CANCELLED',updated_at=CURRENT_TIMESTAMP WHERE customer_id=#{customer} AND id=#{id} AND status='WAIT_PDA_RECEIVING'")
-    int cancelTransfer(@Param("customer") String customer,@Param("id") long id);
-    /** 写入主单取消事实并递增版本，防止旧页面继续写入。 */
-    @Update("UPDATE ll_order SET current_status='CANCELLED',sub_order_status='WAREHOUSE_TRANSFER:CANCELLED',version=version+1,updated_at=CURRENT_TIMESTAMP WHERE customer_id=#{customer} AND id=#{id} AND current_status='INBOUND_MEASURING'")
-    int cancelOrder(@Param("customer") String customer,@Param("id") long id);
-    /** 只取消尚未接货的外来入仓单。 */
-    @Update("UPDATE ll_inbound_order SET status='CANCELLED',updated_at=CURRENT_TIMESTAMP WHERE customer_id=#{customer} AND id=#{id} AND status='PENDING_INBOUND'")
-    int cancelInbound(@Param("customer") String customer,@Param("id") long id);
-    /** 只取消原转运生成且仍待PDA的唯一计划。 */
-    @Update("UPDATE ll_inbound_plan SET status='CANCELLED',version=version+1,updated_at=CURRENT_TIMESTAMP WHERE customer_id=#{customer} AND source_order_id=#{order} AND creation_mode='WAREHOUSE_TRANSFER' AND status='PDA_PENDING'")
-    int cancelPlan(@Param("customer") String customer,@Param("order") long order);
-    /** 不可变历史保留取消前状态、原车次与操作者。 */
-    @Insert("INSERT INTO ll_loading_order_status_history(customer_id,order_id,from_status,to_status,event_id,remark,created_at) SELECT customer_id,id,current_status,'CANCELLED',#{trip},CONCAT('取消取货排车及转运单；操作人：',#{operator},'；原因：',#{reason}),CURRENT_TIMESTAMP FROM ll_order WHERE customer_id=#{customer} AND id=#{id}")
-    int history(@Param("customer") String customer,@Param("id") long id,@Param("trip") String trip,@Param("operator") String operator,@Param("reason") String reason);
-}

lastleg-service/src/main/java/com/baiyue/lastleg/transfer/repository/TransferPickupCancellationRepository.java

@@ -1,24 +0,0 @@
-package com.baiyue.lastleg.transfer.repository;
-
-import com.baiyue.lastleg.transfer.mapper.TransferPickupCancellationMapper;
-import org.springframework.stereotype.Repository;
-
-/** 未执行取货取消的原单、入仓与历史持久化边界。 */
-@Repository
-public class TransferPickupCancellationRepository {
-    private final TransferPickupCancellationMapper mapper;
-    /** 注入本业务取消映射器。 */
-    public TransferPickupCancellationRepository(TransferPickupCancellationMapper mapper){this.mapper=mapper;}
-    /** 锁定真实客户所属转运来源。 */
-    public com.baiyue.lastleg.transfer.entity.WarehouseTransferOrder lock(String customer,String number){return mapper.lock(customer,number);}
-    /** 已存在清点、托盘或收货事实时禁止普通取消。 */
-    public boolean started(String customer,long id){return mapper.started(customer,id)>0;}
-    /** 取消转运并检查当前状态。 */
-    public int cancelTransfer(String customer,long id){return mapper.cancelTransfer(customer,id);}
-    /** 取消尾程主单并记录当前状态来源。 */
-    public int cancelOrder(String customer,long id,String trip,String operator,String reason){mapper.history(customer,id,trip,operator,reason);return mapper.cancelOrder(customer,id);}
-    /** 取消原入仓单，保留不可删除的业务关联。 */
-    public int cancelInbound(String customer,long id){return mapper.cancelInbound(customer,id);}
-    /** 取消待收货计划，已执行的计划导致整车取消失败。 */
-    public int cancelPlan(String customer,long order){return mapper.cancelPlan(customer,order);}
-}

lastleg-service/src/main/java/com/baiyue/lastleg/transfer/service/TransferPickupCancellationService.java

@@ -1,32 +0,0 @@
-package com.baiyue.lastleg.transfer.service;
-
-import com.baiyue.lastleg.fleet.pickup.*;
-import com.baiyue.lastleg.transfer.repository.TransferPickupCancellationRepository;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.*;
-import org.springframework.http.HttpStatus;
-import org.springframework.web.server.ResponseStatusException;
-import java.util.List;
-
-/** 取货排车取消时原子取消其全部转运、尾程、入仓单及待执行入仓计划。 */
-@Service
-public class TransferPickupCancellationService implements PickupOrderCancellation {
-    private final TransferPickupCancellationRepository repository;
-    /** 取消只访问本域持久化边界，不反向调用排车服务。 */
-    public TransferPickupCancellationService(TransferPickupCancellationRepository repository){this.repository=repository;}
-    /** 任一来源已经执行或归属不符时抛错，使外层整车取消全部回滚。 */
-    @Override @Transactional(propagation=Propagation.MANDATORY)
-    public void cancel(List<FleetPickupModels.Source> sources,String tripNo,String operator,String reason) {
-        if(sources==null || sources.isEmpty())throw conflict();
-        for(var source:sources) {
-            var row=repository.lock(source.customerId(),source.transferNo());
-            if(row==null || !"WAREHOUSE_PICKUP".equals(row.getDeliveryMethod()) || !row.getTransferNo().equals(row.getInboundCode()) || !"WAIT_PDA_RECEIVING".equals(row.getStatus()) || repository.started(source.customerId(),row.getId()))throw conflict();
-            if(repository.cancelTransfer(source.customerId(),row.getId())!=1
-                || repository.cancelOrder(source.customerId(),row.getLastlegOrderId(),tripNo,operator,reason)!=1
-                || repository.cancelInbound(source.customerId(),row.getInboundOrderId())!=1
-                || repository.cancelPlan(source.customerId(),row.getLastlegOrderId())!=1)throw conflict();
-        }
-    }
-    /** 保留用户上下文，不把部分取消作为成功返回。 */
-    private static ResponseStatusException conflict(){return new ResponseStatusException(HttpStatus.CONFLICT,"转运单已开始收货或关联状态变化，不能取消排车及转运单，请刷新核对");}
-}

lastleg-service/src/main/java/com/baiyue/lastleg/transfer/service/WarehouseTransferService.java

@@ -94,7 +94,6 @@ import java.util.stream.Collectors;
 public class WarehouseTransferService {
     @Resource private TransferQuantityService transferQuantityService;
     @Resource private com.baiyue.lastleg.fleet.pickup.FleetPickupService pickupService;
-    @Resource private com.baiyue.lastleg.dispatch.transport.TransportTaskService transportTaskService;
     /** 退货单在转运来源中的展示编码，避免把退货单号误当成普通入仓码查询。 */
     public static final String RETURN_ORDER_PREFIX = "RETURN_ORDER:";
     @Resource private com.baiyue.lastleg.service.LastlegDocumentNumberGenerator compactNumbers;
@@ -815,7 +814,6 @@ public class WarehouseTransferService {
         return new WarehouseTransferResponses.Label(transferNo, cartons, html);
     }
 
-    /** 审核与入仓计划、上门取货排车原子提交，重放复用原业务关联。 */
     @Transactional
     public WarehouseTransferResponses.Detail review(String customerId, String transferNo, String operatorId,
                                                      WarehouseTransferRequests.Review request) {
@@ -838,7 +836,6 @@ public class WarehouseTransferService {
                     .contains(transfer.getStatus())) {
                 if (APPROVED.equals(next) && transfer.getTransferNo().equals(transfer.getInboundCode())) {
                     activateTransferInbound(customerId, transfer, LocalDateTime.now());
-                    transportTaskService.ensureApprovedPickup(customerId, transferNo, operatorId);
                 }
                 return detail(customerId, transferNo);
             }
@@ -868,9 +865,6 @@ public class WarehouseTransferService {
                 "Warehouse transfer reviewed: " + next
                     + (StringUtils.hasText(request.remark()) ? "; " + request.remark().trim() : ""), now);
         }
-        if (APPROVED.equals(next) && incomingTransit) {
-            transportTaskService.ensureApprovedPickup(customerId, transferNo, operatorId);
-        }
         return detail(customerId, transferNo);
     }
 

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

@@ -1907,7 +1907,6 @@ CREATE TABLE IF NOT EXISTS ll_dispatch_order (
   review_state VARCHAR(32) NOT NULL DEFAULT 'DRAFT' COMMENT '审核子流程当前状态',
   review_round BIGINT NOT NULL DEFAULT 0 COMMENT '当前审核轮次',
   review_basis_hash CHAR(64) NULL COMMENT '本审核轮次核对的货物和资源依据摘要',
-  exceptions_json JSON NULL COMMENT '派送异常登记记录及图片引用，不改变派送及库存状态',
   dispatch_review_json JSON NULL COMMENT '当前调度审核事实快照',
   loading_review_json JSON NULL COMMENT '当前理货审核事实快照',
   resources_json JSON NULL COMMENT '本趟主档或临时车辆司机的真实资源快照',

lastleg-service/src/main/resources/openapi/dispatch-loading-documents-v1.yaml

@@ -1,394 +0,0 @@
-openapi: 3.0.3
-info:
-  title: 排车装车资料（Admin/PDA共用）
-  version: 1.0.0
-  description: LOADING阶段即可同步上传并保存五个整车照片框；照片齐全不会提前发车。装车确认时资料已齐则直接进入DELIVERING，否则进入AFTER_LOADING，最后一次绑定自动生成派送并进入DELIVERING。触发推进的装车确认或照片绑定与派送同事务，失败保留先前已保存资料。复用车队照片记录，技术槽位仅表示照片1至5，不代表驾驶证审核或真实签收。PDA每次核验Token冻结仓，平台list只读、edit写；原键仅原操作者恢复。
-security:
-- bearerAuth: []
-paths:
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/loading-documents:
-    get:
-      operationId: getDispatchLoadingDocuments
-      summary: 读取本车装车资料或原上传结果
-      x-permission-code: platform:overseas-warehouse:dispatch:list
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Documents'
-  /api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-documents:
-    get:
-      operationId: getDispatchLoadingDocumentsPda
-      summary: 读取本车装车资料或原上传结果
-      x-permission-code: lastleg:pda:operate
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Documents'
-      x-required-role: OVERSEAS_WAREHOUSE_PDA_OPERATOR
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/loading-documents/{slot}/uploads:
-    post:
-      operationId: uploadDispatchLoadingPhoto
-      summary: 上传整车装车照片，尚未绑定
-      x-permission-code: platform:overseas-warehouse:dispatch:edit
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Photo'
-      requestBody:
-        required: true
-        content:
-          multipart/form-data:
-            schema:
-              type: object
-              required:
-              - file
-              - idempotencyKey
-              properties:
-                file:
-                  type: string
-                  format: binary
-                  description: 非空JPG/PNG，最大10MiB
-                idempotencyKey:
-                  type: string
-                  minLength: 8
-                  maxLength: 128
-  /api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-documents/{slot}/uploads:
-    post:
-      operationId: uploadDispatchLoadingPhotoPda
-      summary: 上传整车装车照片，尚未绑定
-      x-permission-code: lastleg:pda:operate
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Photo'
-      requestBody:
-        required: true
-        content:
-          multipart/form-data:
-            schema:
-              type: object
-              required:
-              - file
-              - idempotencyKey
-              properties:
-                file:
-                  type: string
-                  format: binary
-                  description: 非空JPG/PNG，最大10MiB
-                idempotencyKey:
-                  type: string
-                  minLength: 8
-                  maxLength: 128
-      x-required-role: OVERSEAS_WAREHOUSE_PDA_OPERATOR
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/loading-documents/{slot}:
-    put:
-      operationId: bindDispatchLoadingPhoto
-      summary: 保存装车照片；五框齐全时自动进入派送中
-      x-permission-code: platform:overseas-warehouse:dispatch:edit
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Documents'
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/BindPhoto'
-  /api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-documents/{slot}:
-    put:
-      operationId: bindDispatchLoadingPhotoPda
-      summary: 保存装车照片；五框齐全时自动进入派送中
-      x-permission-code: lastleg:pda:operate
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Documents'
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/BindPhoto'
-      x-required-role: OVERSEAS_WAREHOUSE_PDA_OPERATOR
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/loading-documents/{slot}/files/{fileId}/content:
-    get:
-      operationId: readDispatchLoadingPhoto
-      summary: 读取本车装车资料或原上传结果
-      x-permission-code: platform:overseas-warehouse:dispatch:list
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      - $ref: '#/components/parameters/fileId'
-      responses:
-        '200':
-          description: no-store图片内容
-          content:
-            image/jpeg:
-              schema:
-                type: string
-                format: binary
-            image/png:
-              schema:
-                type: string
-                format: binary
-  /api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-documents/{slot}/files/{fileId}/content:
-    get:
-      operationId: readDispatchLoadingPhotoPda
-      summary: 读取本车装车资料或原上传结果
-      x-permission-code: lastleg:pda:operate
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      - $ref: '#/components/parameters/fileId'
-      responses:
-        '200':
-          description: no-store图片内容
-          content:
-            image/jpeg:
-              schema:
-                type: string
-                format: binary
-            image/png:
-              schema:
-                type: string
-                format: binary
-      x-required-role: OVERSEAS_WAREHOUSE_PDA_OPERATOR
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/loading-documents/uploads/{idempotencyKey}:
-    get:
-      operationId: recoverDispatchLoadingPhoto
-      summary: 读取本车装车资料或原上传结果
-      x-permission-code: platform:overseas-warehouse:dispatch:edit
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/idempotencyKey'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Photo'
-  /api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-documents/uploads/{idempotencyKey}:
-    get:
-      operationId: recoverDispatchLoadingPhotoPda
-      summary: 读取本车装车资料或原上传结果
-      x-permission-code: lastleg:pda:operate
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/idempotencyKey'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Photo'
-      x-required-role: OVERSEAS_WAREHOUSE_PDA_OPERATOR
-components:
-  securitySchemes:
-    bearerAuth:
-      type: http
-      scheme: bearer
-      bearerFormat: JWT
-  parameters:
-    dispatchNo:
-      name: dispatchNo
-      in: path
-      required: true
-      schema:
-        type: string
-    slot:
-      name: slot
-      in: path
-      required: true
-      schema:
-        type: string
-        enum: &id001
-        - LOADING_SCENE
-        - LOADING_LIST
-        - PRE_DEPARTURE_CHECK
-        - DRIVER_LICENSE
-        - RECEIPT
-    fileId:
-      name: fileId
-      in: path
-      required: true
-      schema:
-        type: string
-    idempotencyKey:
-      name: idempotencyKey
-      in: path
-      required: true
-      schema:
-        type: string
-  schemas:
-    Photo:
-      type: object
-      required:
-      - slot
-      - fileId
-      - fileName
-      - contentType
-      - sizeBytes
-      - uploadedAt
-      properties:
-        slot:
-          type: string
-          enum: *id001
-        category:
-          type: string
-          enum:
-          - LOADING
-        fileId:
-          type: string
-        fileName:
-          type: string
-        contentType:
-          type: string
-        sizeBytes:
-          type: string
-        uploadedAt:
-          type: string
-        savedAt:
-          type: string
-          nullable: true
-    Documents:
-      type: object
-      required:
-      - dispatchNo
-      - recordVersion
-      - editable
-      - photos
-      - dispatchRecordVersion
-      - stage
-      - complete
-      properties:
-        dispatchNo:
-          type: string
-        recordVersion:
-          type: string
-        editable:
-          type: boolean
-        photos:
-          type: array
-          items:
-            $ref: '#/components/schemas/Photo'
-        dispatchRecordVersion:
-          type: string
-        stage:
-          type: string
-          enum:
-          - LOADING
-          - AFTER_LOADING
-          - DELIVERING
-          - DELIVERED
-        complete:
-          type: boolean
-          description: 五个固定框各有一张已保存照片
-    BindPhoto:
-      type: object
-      required:
-      - recordVersion
-      - idempotencyKey
-      - fileId
-      properties:
-        recordVersion:
-          type: string
-          pattern: ^(0|[1-9][0-9]*)$
-        idempotencyKey:
-          type: string
-          minLength: 8
-          maxLength: 128
-        fileId:
-          type: string

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

@@ -8,10 +8,6 @@ info:
     list读取、create安排、edit分配/执行/释放、depart发车、cancel取消权限前缀均为platform:overseas-warehouse:dispatch:。
     创建及执行使用稳定idempotencyKey；重试保留完整原载荷。取消仅限未发车；完成后分别释放司机、车辆。
     到仓取货逐原单确认实提和送仓，送仓只开放仓库收货门禁；本土卡车同步原单运输状态，完成须本任务凭证。
-    仓储转运上门取货入仓单审核通过时自动生成待发车排车并绑定原转运单；重复审核不重复建单，主动取消排车时对应转运、尾程、入仓单和待收货计划一并取消。
-    PICKUP 维护车辆后复用 dispatches/{dispatchNo}/submit-review、dispatch-review、loading-review 两级审核入口及版本化命令。
-    调度通过后待理货审核，任一级驳回返回车辆信息修改重提；两级通过后进入装货中；逐票上传取货照片并确认后自动进入派送中，逐票上传到仓照片并确认后自动完成取货派送，再走原仓库收货流程，不走仓内拣货扣库存。
-    车辆、司机或计划时刻变化作废本轮审核；运输版本与排车审核版本各自递增，命令使用对应详情的当前版本。
 servers:
   - url: /api/platform/v1/last-leg/dispatches/transport-tasks
 security:

lastleg-service/src/main/resources/openapi/dispatch-vehicle-documents-v1.yaml

@@ -1,242 +0,0 @@
-openapi: 3.0.3
-info:
-  title: 排车车辆资料
-  version: 1.0.0
-  description: 仅平台有效排车DELIVERING/DELIVERED可用；兼容有无拼车货物，沿装车归属证据校验。共享原车队照片、版本、命令与历史，不新建附件存储。派送文件仍使用delivery-orders
-    documents；不把车队RECEIPT照片当签收。列表权限只读，排车edit独立写；恢复还需list。
-security:
-- bearerAuth: []
-paths:
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents:
-    get:
-      operationId: getDispatchVehicleDocuments
-      summary: 读取本车油耗图片；复用车队附加记录
-      x-permission-code: platform:overseas-warehouse:dispatch:list
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Documents'
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents/{slot}/uploads:
-    post:
-      operationId: uploadDispatchVehiclePhoto
-      summary: 准备本车油耗图片；尚未绑定保存
-      x-permission-code: platform:overseas-warehouse:dispatch:edit
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Photo'
-      requestBody:
-        required: true
-        content:
-          multipart/form-data:
-            schema:
-              type: object
-              required:
-              - file
-              - idempotencyKey
-              properties:
-                file:
-                  type: string
-                  format: binary
-                  description: 非空JPG/PNG，最大10MiB
-                idempotencyKey:
-                  type: string
-                  minLength: 8
-                  maxLength: 128
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents/{slot}:
-    put:
-      operationId: bindDispatchVehiclePhoto
-      summary: 按附加版本绑定原上传文件，不改变排车或签收状态
-      x-permission-code: platform:overseas-warehouse:dispatch:edit
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Documents'
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/BindPhoto'
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents/{slot}/files/{fileId}/content:
-    get:
-      operationId: readDispatchVehiclePhoto
-      summary: 只读取本车当前绑定图片
-      x-permission-code: platform:overseas-warehouse:dispatch:list
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      - $ref: '#/components/parameters/fileId'
-      responses:
-        '200':
-          description: no-store图片内容
-          content:
-            image/jpeg:
-              schema:
-                type: string
-                format: binary
-            image/png:
-              schema:
-                type: string
-                format: binary
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents/uploads/{idempotencyKey}:
-    get:
-      operationId: recoverDispatchVehiclePhoto
-      summary: 只恢复当前操作者原油耗上传成功结果，未知结果拒绝重传
-      x-permission-code: platform:overseas-warehouse:dispatch:edit
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/idempotencyKey'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Photo'
-components:
-  securitySchemes:
-    bearerAuth:
-      type: http
-      scheme: bearer
-      bearerFormat: JWT
-  parameters:
-    dispatchNo:
-      name: dispatchNo
-      in: path
-      required: true
-      schema:
-        type: string
-    slot:
-      name: slot
-      in: path
-      required: true
-      schema:
-        type: string
-        enum:
-        - FUEL_START
-        - FUEL_END
-    fileId:
-      name: fileId
-      in: path
-      required: true
-      schema:
-        type: string
-    idempotencyKey:
-      name: idempotencyKey
-      in: path
-      required: true
-      schema:
-        type: string
-  schemas:
-    Photo:
-      type: object
-      required:
-      - slot
-      - fileId
-      - fileName
-      - contentType
-      - sizeBytes
-      - uploadedAt
-      properties:
-        slot:
-          type: string
-          enum:
-          - FUEL_START
-          - FUEL_END
-        category:
-          type: string
-          enum:
-          - FUEL
-        fileId:
-          type: string
-        fileName:
-          type: string
-        contentType:
-          type: string
-        sizeBytes:
-          type: string
-        uploadedAt:
-          type: string
-        savedAt:
-          type: string
-          nullable: true
-    Documents:
-      type: object
-      required:
-      - dispatchNo
-      - recordVersion
-      - editable
-      - photos
-      properties:
-        dispatchNo:
-          type: string
-        recordVersion:
-          type: string
-        editable:
-          type: boolean
-        photos:
-          type: array
-          items:
-            $ref: '#/components/schemas/Photo'
-    BindPhoto:
-      type: object
-      required:
-      - recordVersion
-      - idempotencyKey
-      - fileId
-      properties:
-        recordVersion:
-          type: string
-          pattern: ^(0|[1-9][0-9]*)$
-        idempotencyKey:
-          type: string
-          minLength: 8
-          maxLength: 128
-        fileId:
-          type: string

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

@@ -3,16 +3,12 @@ info:
   title: 仓储转运上门取货与车辆排车
   version: 1.0.0
   description: |
-    WAREHOUSE_PICKUP 外来转运单审核通过后，同事务自动生成绑定原单的 PICKUP 排车单（PC号），待分配车辆司机；客户自送、库存转运不自动排车。
-    自动计划暂定为审核时刻发车、24小时后结束，并在备注标明待调度确认；不填写实际发车、实提或送仓事实。
-    取货排车先维护车辆信息、提交调度审核，经调度和理货员同轮审核通过后进入装货中。逐票上传取货照片并确认实提，全车齐全后自动进入派送中；逐票上传独立到仓照片，全部到仓后自动完成取货派送，再继续原仓库收货流程。
-    修改车辆、司机或计划时刻后本轮审核失效，须重新提交；审核不触发仓内拣货或库存扣减。
-    重复审核沿原单锁复用已有任务，不重复建单，也不恢复已主动取消的任务；取消排车时对应转运单、尾程单、入仓单及待PDA计划同事务取消，不再进入取货候选。
+    审核通过的 WAREHOUSE_PICKUP 外来转运单自动进入待取货候选；客户自送、库存转运、未审核及已完成测量单不进入。
     入仓取货和出库派送共用 ll_fleet_trip 及车辆司机占用，tripPurpose 分别为 PICKUP / DELIVERY，禁止混用库存出库命令、外接预订及余位发布。
     同车多单必须送往同一公共海外仓，原客户归属与转运单保留，不重复生成尾程单、不修改预报箱唛或库存。
     取货确认必须填写实提箱数并引用本票本车已上传的 PDF/JPG/PNG 凭证；送仓后开放 PDA 清点。
     司机实提箱数不替代仓库实收。全部送仓后结案运输，车辆和司机仍通过原 resources/release 分别结束任务。
-    取消 PLANNED 车次原子取消本车全部对应转运单、尾程单、入仓单及待PDA计划并释放资源；任一成员已有清点或收货事实则全部回滚，已发车不可取消。
+    取消 PLANNED 车次原子释放资源和未执行取货关联，原单重新成为候选；已发车不可取消。
     写命令具备车次版本及请求键，同键同内容重放不重复写入，同键不同内容拒绝。普通业务返回 HTTP 200 + body.code。
 security:
   - bearerAuth: []
@@ -83,7 +79,7 @@ paths:
     parameters: [{$ref: '#/components/parameters/tripNo'}, {$ref: '#/components/parameters/customerId'}, {$ref: '#/components/parameters/transferNo'}]
     post:
       summary: 逐票确认取货
-      description: 仅平台主体，权限 platform:fleet:trip:edit。两级审核通过的计划车次或已出发车次，任务 ASSIGNED；核对本票本车图片上传归属后转 PICKED，实提箱数不覆盖预报。全车取货照片齐全后自动进入 IN_TRANSIT，排车阶段为 DELIVERING。
+      description: 仅平台主体，权限 platform:fleet:trip:edit。车次已发车且任务 ASSIGNED，核对本票本车上传归属后转 PICKED，实提箱数不覆盖预报。
       requestBody:
         required: true
         content:
@@ -102,7 +98,7 @@ paths:
     parameters: [{$ref: '#/components/parameters/tripNo'}, {$ref: '#/components/parameters/customerId'}, {$ref: '#/components/parameters/transferNo'}]
     post:
       summary: 确认本票送达海外仓
-      description: 仅平台主体，权限 platform:fleet:trip:edit。仅 PICKED 可以转 ARRIVED；evidenceFileIds 必填且为本票本车新上传的图片，不得复用取货照片。Evidence.phase 为 PICKUP 或 ARRIVAL 区分两次照片。全车均 ARRIVED 后自动完成运输，开放原 PDA 清点，不直接完成测量或入库。
+      description: 仅平台主体，权限 platform:fleet:trip:edit。仅 PICKED 可以转 ARRIVED；开放原 PDA 清点，不直接完成测量或入库。
       requestBody: {$ref: '#/components/requestBodies/command'}
       responses: {'200': {description: ApiResponse 当前本车 Task 数组；车次版本已更新}}
   /api/platform/v1/last-leg/fleet/pickups/{tripNo}/complete:
@@ -161,4 +157,3 @@ components:
               recordVersion: {type: integer, format: int64, minimum: 0}
               idempotencyKey: {type: string, minLength: 8, maxLength: 128}
               reason: {type: string, maxLength: 1000}
-              evidenceFileIds: {type: array, minItems: 1, maxItems: 10, items: {type: string}, description: 送仓确认必填，必须为本票本车新上传的到仓图片}

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

@@ -920,8 +920,7 @@ paths:
       parameters:
       - name: warehouseId
         in: query
-        description: 可选真实起运仓；未指定时按 warehouseTab 跨仓分页浏览，草稿及建单仍要求同一起运仓。
-        required: false
+        required: true
         schema:
           type: string
       - name: planIds
@@ -1683,53 +1682,10 @@ paths:
       required: true
       schema:
         type: string
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/exceptions:
-    post:
-      summary: 登记派送异常
-      description: 权限 platform:overseas-warehouse:dispatch:edit；仅有效仓库派送单DELIVERING可登记，保存后阶段不变，不产生退货、签收或库存变化。原键重试恢复原结果。
-      security:
-      - bearerAuth: []
-      responses:
-        '200':
-          description: 统一ApiResponse；业务失败通过code返回，不能仅凭HTTP200判断成功。
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  requestId:
-                    type: string
-                    nullable: true
-                  traceId:
-                    type: string
-                    nullable: true
-                  timestamp:
-                    type: string
-                    format: date-time
-                  data:
-                    allOf:
-                    - $ref: '#/components/schemas/DispatchCommandResult'
-                    nullable: true
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/DispatchMarkException'
-    parameters:
-    - name: dispatchNo
-      in: path
-      required: true
-      schema:
-        type: string
   /api/platform/v1/last-leg/dispatches/{dispatchNo}/loading-complete:
     post:
-      summary: 确认装车完成，资料齐全时自动进入派送中
-      description: 权限 platform:overseas-warehouse:dispatch:loading-complete。 装车中可通过loading-documents同步保存五张装车照片。原请求保存实载确认；成功action为LOADING_COMPLETE，资料已齐时stage为DELIVERING，未齐时为AFTER_LOADING，result保留真实Loaded装车证据。装车确认与资料齐全两项均完成时自动生成派送并发车；触发该次推进的装车确认或最后一次绑定与派送同事务回滚，先前已保存照片保留。重试装车原键保持原最终阶段结果，当前阶段另行读取。
+      summary: 确认装车完成并自动进入派送中
+      description: 权限 platform:overseas-warehouse:dispatch:loading-complete。 原请求在同一事务完成实载确认、全车派送单生成及发车；成功action为LOADING_COMPLETE、stage为DELIVERING，result保留真实Loaded装车证据。任一步失败整体回滚，重试原键恢复最终结果，不另行安排派送或确认发车。
       security:
       - bearerAuth: []
       responses:
@@ -1924,7 +1880,7 @@ paths:
   /api/platform/v1/last-leg/dispatches/{dispatchNo}/evidence/{kind}:
     post:
       summary: 上传本趟车辆或司机证据
-      description: 客服阶段使用 platform:overseas-warehouse:dispatch:edit；调度待审/理货待审分别使用 platform:fleet:trip:dispatch-review / platform:fleet:trip:loading-review，无需维护车辆权限。VEHICLE和DRIVER支持PDF/JPG/PNG，DRIVER_PHOTO和EXCEPTION仅JPG/PNG；EXCEPTION仅派送中使用排车edit权限，引用随异常登记保存。非空且不超过10MiB；平台、本车、类型复合归属。审核补充附件随ReviewCommand保存，不修改资源，不重启审核。
+      description: 客服阶段使用 platform:overseas-warehouse:dispatch:edit；调度待审/理货待审分别使用 platform:fleet:trip:dispatch-review / platform:fleet:trip:loading-review，无需维护车辆权限。VEHICLE和DRIVER支持PDF/JPG/PNG，DRIVER_PHOTO仅JPG/PNG，非空且不超过10MiB；平台、本车、类型复合归属。审核补充附件随ReviewCommand保存，不修改资源，不重启审核。
       security:
       - bearerAuth: []
       responses:
@@ -1979,7 +1935,6 @@ paths:
         - VEHICLE
         - DRIVER
         - DRIVER_PHOTO
-        - EXCEPTION
   /api/platform/v1/last-leg/dispatches/{dispatchNo}/evidence/{kind}/{fileId}:
     get:
       summary: 读取本车证据元数据
@@ -2026,7 +1981,6 @@ paths:
         - VEHICLE
         - DRIVER
         - DRIVER_PHOTO
-        - EXCEPTION
     - name: fileId
       in: path
       required: true
@@ -2070,7 +2024,6 @@ paths:
         - VEHICLE
         - DRIVER
         - DRIVER_PHOTO
-        - EXCEPTION
     - name: fileId
       in: path
       required: true
@@ -5190,7 +5143,6 @@ components:
       - LOADING_COMPLETE
       - ARRANGE_DELIVERY
       - DEPART
-      - MARK_EXCEPTION
     DispatchGate:
       type: object
       x-java-record: DispatchContracts.Gate
@@ -5253,14 +5205,6 @@ components:
       type: object
       x-java-record: DispatchContracts.DriverEvidence
       properties:
-        photoFileIds:
-          type: array
-          maxItems: 20
-          uniqueItems: true
-          description: 维护车辆司机时保存的本趟司机照片，按DRIVER_PHOTO类别校验，与驾驶证附件独立。
-          items:
-            type: string
-            pattern: ^[1-9][0-9]*$
         licenseNo:
           type: string
           nullable: true
@@ -6371,10 +6315,6 @@ components:
           items:
             $ref: '#/components/schemas/DispatchBatchReference'
           nullable: true
-        exceptions:
-          type: array
-          items:
-            $ref: '#/components/schemas/DispatchExceptionRecord'
       required:
       - route
       - plannedDepartureAt
@@ -6382,7 +6322,6 @@ components:
       - estimatedArrivalAt
       - fbaAppointments
       - appointmentBatches
-      - exceptions
     DispatchDocuments:
       type: object
       x-java-record: DispatchViews.Documents
@@ -8002,66 +7941,5 @@ components:
       - sourceInboundOrderNo
       - sourceInboundCode
       - productQuantity
-
-    DispatchExceptionType:
-      type: string
-      enum: [REFUSED, PARTIAL_RECEIPT, VEHICLE_EXCEPTION]
-      description: 拒收、部分签收、车辆异常。
-    DispatchReturnDirection:
-      type: string
-      enum: [OVERSEAS_WAREHOUSE, OTHER]
-      description: 退回海外仓、其他；仅登记去向，不自动退货入库。
-    DispatchMarkException:
-      type: object
-      x-java-record: DispatchCommands.MarkException
-      required: [recordVersion, idempotencyKey, exceptionType]
-      properties:
-        recordVersion:
-          oneOf:
-          - type: string
-            pattern: ^[0-9]+$
-          - type: integer
-            minimum: 0
-        idempotencyKey:
-          type: string
-        exceptionType:
-          $ref: '#/components/schemas/DispatchExceptionType'
-        returnDirection:
-          allOf:
-          - $ref: '#/components/schemas/DispatchReturnDirection'
-          nullable: true
-        description:
-          type: string
-          maxLength: 1000
-          nullable: true
-        imageFileIds:
-          type: array
-          maxItems: 20
-          uniqueItems: true
-          items:
-            type: string
-            pattern: ^[1-9][0-9]*$
-    DispatchExceptionRecord:
-      type: object
-      x-java-record: DispatchViews.ExceptionRecord
-      required: [exceptionType, returnDirection, description, imageFileIds, occurredAt]
-      properties:
-        exceptionType:
-          $ref: '#/components/schemas/DispatchExceptionType'
-        returnDirection:
-          allOf:
-          - $ref: '#/components/schemas/DispatchReturnDirection'
-          nullable: true
-        description:
-          type: string
-          nullable: true
-        imageFileIds:
-          type: array
-          items:
-            type: string
-        occurredAt:
-          type: string
-          format: date-time
-
   securitySchemes:
     bearerAuth: { type: http, scheme: bearer, bearerFormat: JWT }

lastleg-service/src/main/resources/openapi/overseas-pda-operations-v1.yaml

@@ -253,8 +253,8 @@ paths:
         type: string
   /api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-complete:
     post:
-      summary: 确认装车完成，资料齐全时自动进入派送中
-      description: 权限 OVERSEAS_WAREHOUSE_PDA_OPERATOR + lastleg:pda:operate。只用整车recordVersion和全载荷幂等键；扫码执行真实库存SHIP，装车完成和发车不重复SHIP。错误或结果未知保留原请求核对。 装车中可通过loading-documents同步保存五张装车照片。原请求保存实载确认；成功action为LOADING_COMPLETE，资料已齐时stage为DELIVERING，未齐时为AFTER_LOADING，result保留真实Loaded装车证据。装车确认与资料齐全两项均完成时自动生成派送并发车；触发该次推进的装车确认或最后一次绑定与派送同事务回滚，先前已保存照片保留。重试装车原键保持原最终阶段结果，当前阶段另行读取。
+      summary: 确认装车完成并自动进入派送中
+      description: 权限 OVERSEAS_WAREHOUSE_PDA_OPERATOR + lastleg:pda:operate。只用整车recordVersion和全载荷幂等键；扫码执行真实库存SHIP，装车完成和发车不重复SHIP。错误或结果未知保留原请求核对。 原请求在同一事务完成实载确认、全车派送单生成及发车；成功action为LOADING_COMPLETE、stage为DELIVERING，result保留真实Loaded装车证据。任一步失败整体回滚，重试原键恢复最终结果，不另行安排派送或确认发车。
       security:
       - bearerAuth: []
       responses:

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

@@ -38,9 +38,6 @@ class SmartDispatchOpenApiContractTest {
         assertThat(map(paths.get(base+"/drafts"))).containsKey("get");
         var candidate=map(map(paths.get(base+"/candidates")).get("get"));
         var parameterNames=((List<?>)candidate.get("parameters")).stream().map(SmartDispatchOpenApiContractTest::map).map(p->p.get("name")).toList();
-        var warehouseParameter=((List<?>)candidate.get("parameters")).stream().map(SmartDispatchOpenApiContractTest::map)
-            .filter(p->"warehouseId".equals(p.get("name"))).findFirst().orElseThrow();
-        assertThat(warehouseParameter.get("required")).isEqualTo(false);
         assertThat(parameterNames).contains("warehouseId","destinationWarehouseCode","draftToken","page","size","warehouseTab").doesNotContain("customerId","fbaWarehouseCode");
         assertThat(map(map(schemas.get("DispatchCandidateList")).get("properties")).keySet())
             .containsExactlyInAnyOrder("candidates","snapshotAt","complete","total","page","size","pages");

lastleg-service/src/test/java/com/baiyue/lastleg/dispatch/controller/SmartDispatchControllerTest.java

@@ -45,16 +45,6 @@ class SmartDispatchControllerTest {
             .andExpect(status().isOk());
         verify(aggregate).candidates(actor,new CandidateQuery("92",null,null,"LAX9",null,null,1,20,"ALL"));verifyNoInteractions(planning);
     }
-    /** 区域入口无需隐藏默认仓，全部与城市均由服务端分页。 */
-    @Test void candidateHttpQueryAllowsRegionalBrowsingWithoutWarehouse()throws Exception {
-        var mvc=MockMvcBuilders.standaloneSetup(controller).setCustomArgumentResolvers(new AuthenticationPrincipalArgumentResolver()).build();
-        SecurityContextHolder.getContext().setAuthentication(new UsernamePasswordAuthenticationToken(platform(),null,List.of()));
-        for(String tab:List.of("ALL","LAX","NYC")) {
-            mvc.perform(get("/api/platform/v1/last-leg/dispatches/candidates").param("warehouseTab",tab)).andExpect(status().isOk());
-            verify(aggregate).candidates(actor,new CandidateQuery(null,null,null,null,null,null,1,20,tab));
-        }
-        verifyNoInteractions(planning);
-    }
     /** 每个写入都将冻结DTO原样传递，拥有者只能来自认证主体。 */
     @Test void allDraftRoutesDelegateFrozenVersionedRequests(){
         var create=new CreateDraft("create","92");var container=new CreateContainer(0L,"container","d",15);

lastleg-service/src/test/java/com/baiyue/lastleg/dispatch/gateway/HttpDispatchEvidenceGatewayTest.java

@@ -45,15 +45,6 @@ class HttpDispatchEvidenceGatewayTest {
         var pdf=new HttpDispatchEvidenceGateway.Metadata(3L,0L,"OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE","9","driver.pdf","application/pdf",128L);
         assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",pdf),9,DispatchEvidenceGateway.Kind.DRIVER_PHOTO,3L)).isInstanceOf(ResponseStatusException.class);
     }
-    /** 异常图片独立归属本车，审核照片及PDF均不能用作异常图片。 */
-    @Test void exceptionImagesRejectOtherKindsCarsAndPdf() {
-        var photo=new HttpDispatchEvidenceGateway.Metadata(3L,0L,"OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE","9","exception.png","image/png",128L);
-        assertThat(HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",photo),9,DispatchEvidenceGateway.Kind.EXCEPTION,3L).fileId()).isEqualTo(3L);
-        assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",photo),10,DispatchEvidenceGateway.Kind.EXCEPTION,3L)).isInstanceOf(ResponseStatusException.class);
-        assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",photo),9,DispatchEvidenceGateway.Kind.DRIVER_PHOTO,3L)).isInstanceOf(ResponseStatusException.class);
-        var pdf=new HttpDispatchEvidenceGateway.Metadata(3L,0L,"OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE","9","exception.pdf","application/pdf",128L);
-        assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",pdf),9,DispatchEvidenceGateway.Kind.EXCEPTION,3L)).isInstanceOf(ResponseStatusException.class);
-    }
     /** 客户、旧主档或缺失媒体类型均拒绝，不因为文件本身存在而放行。 */
     @Test void rejectsForeignTenantMasterScopeAndMalformedMetadata() {
         for(var value:java.util.List.of(

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

@@ -148,7 +148,7 @@ public class DispatchAggregatePersistenceTest {
         String dispatch(ResourceMode mode,Long driverId,List<Long> ids) throws Exception {
             var created=f.tx.execute(t->f.service.create(f.actor,f.create("evidence-"+UUID.randomUUID(),List.of())));
             var resource=new DispatchContracts.Resources(null,new DispatchContracts.DriverSnapshot(mode,driverId,"测试司机","123456789",
-                new DispatchContracts.DriverEvidence("TEST-LICENSE",LocalDate.of(2099,1,1),ids,Instant.parse("2098-01-01T00:00:00Z"),List.of())));
+                new DispatchContracts.DriverEvidence("TEST-LICENSE",LocalDate.of(2099,1,1),ids,Instant.parse("2098-01-01T00:00:00Z"))));
             f.db.update("UPDATE ll_dispatch_order SET resources_json=? WHERE dispatch_no=?",f.json.writeValueAsString(resource),created.dispatchNo());return created.dispatchNo();
         }
         /** File内容固定为离线测试字节；真实复合归属由既有两个HTTP网关合同分别覆盖。 */
@@ -591,7 +591,7 @@ public class DispatchAggregatePersistenceTest {
             return new DispatchCommands.Create(key,"9",new DispatchCommands.Vehicle(ResourceMode.EXTERNAL,null,"TEST-TRUCK","测试承运方",
                 new DispatchContracts.Capacity(15,new BigDecimal("10000"),new BigDecimal("50")),List.of(101L)),
                 new DispatchCommands.Driver(ResourceMode.EXTERNAL,null,"测试司机","123456789",
-                    new DispatchContracts.DriverEvidence("TEST-LICENSE",java.time.LocalDate.of(2099,1,1),List.of(202L),departure.plusSeconds(86400),List.of())),
+                    new DispatchContracts.DriverEvidence("TEST-LICENSE",java.time.LocalDate.of(2099,1,1),List.of(202L),departure.plusSeconds(86400))),
                 departure,null,null,sources,List.of());
         }
 

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

@@ -1,89 +0,0 @@
-package com.baiyue.lastleg.dispatch.service;
-
-import com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway;
-import com.baiyue.lastleg.dispatch.port.DispatchCommands;
-import com.baiyue.lastleg.dispatch.port.DispatchContracts;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.springframework.security.authentication.TestingAuthenticationToken;
-import org.springframework.security.core.context.SecurityContextHolder;
-import org.springframework.test.util.ReflectionTestUtils;
-import java.util.List;
-import static com.baiyue.lastleg.dispatch.port.DispatchTypes.*;
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.*;
-
-/** 通过真实Mapper和事务验证异常登记，不把登记事实解释成签收或退货。 */
-class DispatchExceptionPersistenceTest {
-    /** 登记使用排车独立维护权限。 */
-    @BeforeEach void authorize() { SecurityContextHolder.getContext().setAuthentication(new TestingAuthenticationToken("operator-test","","platform:overseas-warehouse:dispatch:edit")); }
-    /** 清除线程身份，避免影响其他权限回归。 */
-    @AfterEach void clear() { SecurityContextHolder.clearContext(); }
-
-    /** 每种原型类型均可保存，原键重试不追加，最终完成后仍恢复原结果。 */
-    @Test void recordsAllTypesAndReplaysWithoutChangingDeliveryFacts() throws Exception {
-        var f=new DispatchAggregatePersistenceTest.Fixture();var no=create(f);long version=0;
-        var before=f.db.queryForMap("SELECT stage,shipped_package_count,departed_at,review_state FROM ll_dispatch_order");
-        for(var type:ExceptionType.values()) {
-            var body=new DispatchCommands.MarkException(version,"exception-"+type,type,ReturnDirection.OVERSEAS_WAREHOUSE,"真实异常",List.of());
-            var saved=f.tx.execute(t->f.service.markException(f.actor,no,body));
-            var replay=f.tx.execute(t->f.service.markException(f.actor,no,body));
-            assertThat(saved.stage()).isEqualTo(Stage.DELIVERING);assertThat(replay.replayed()).isTrue();
-            assertThat(replay.recordVersion()).isEqualTo(saved.recordVersion());version=saved.recordVersion();
-        }
-        var records=f.service.detail(f.actor,no).dispatchInfo().exceptions();assertThat(records).hasSize(3);
-        assertThat(records).allSatisfy(r->{assertThat(r.description()).isEqualTo("真实异常");assertThat(r.occurredAt()).isNotNull();});
-        assertThat(f.db.queryForMap("SELECT stage,shipped_package_count,departed_at,review_state FROM ll_dispatch_order")).isEqualTo(before);
-        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_inventory_ledger",Long.class)).isZero();
-        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_history WHERE action='MARK_EXCEPTION'",Long.class)).isEqualTo(3);
-        var first=new DispatchCommands.MarkException(0L,"exception-REFUSED",ExceptionType.REFUSED,ReturnDirection.OVERSEAS_WAREHOUSE,"真实异常",List.of());
-        f.db.update("UPDATE ll_dispatch_order SET stage='DELIVERED'");
-        assertThat(f.tx.execute(t->f.service.markException(f.actor,no,first)).replayed()).isTrue();
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,new DispatchCommands.MarkException(0L,"exception-REFUSED",ExceptionType.REFUSED,null,"改了内容",List.of())))).isInstanceOf(RuntimeException.class);
-        assertThat(f.service.detail(f.actor,no).dispatchInfo().exceptions()).hasSize(3);
-    }
-
-    /** 非派送阶段、过期版本、只读身份、PDA及运输任务不能登记。 */
-    @Test void rejectsWrongStageVersionPermissionAndTask() throws Exception {
-        var f=new DispatchAggregatePersistenceTest.Fixture();var no=create(f);var body=request(0,"blocked",List.of());
-        for(var stage:List.of("BEFORE_LOADING","LOADING","AFTER_LOADING","DELIVERED")) {
-            f.db.update("UPDATE ll_dispatch_order SET stage=?",stage);
-            assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,body))).hasMessageContaining("仅派送中");
-        }
-        f.db.update("UPDATE ll_dispatch_order SET stage='DELIVERING'");
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,request(9,"stale",List.of())))).hasMessageContaining("版本");
-        SecurityContextHolder.getContext().setAuthentication(new TestingAuthenticationToken("operator-test","","platform:overseas-warehouse:dispatch:list"));
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,body))).hasMessageContaining("权限");
-        authorize();f.db.update("UPDATE ll_dispatch_order SET task_type='LOCAL_TRUCK'");
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,body))).hasMessageContaining("仅派送中");
-        f.db.update("UPDATE ll_dispatch_order SET task_type='DELIVERY',status='CANCELLED'");
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,body))).hasMessageContaining("仅派送中");
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(new DispatchContracts.Actor("pda",ActorMode.PDA,"9"),no,body))).hasMessageContaining("仅平台");
-        assertThat(f.db.queryForObject("SELECT record_version FROM ll_dispatch_order",Long.class)).isZero();
-    }
-
-    /** 图片严格核对当前车和类别；附件失败或缺类型不保存任何业务记录。 */
-    @Test void verifiesImageOwnershipAndKeepsFailedRequestUnchanged() throws Exception {
-        var f=new DispatchAggregatePersistenceTest.Fixture();var no=create(f);var id=f.repository.find(no).getId();
-        var files=mock(DispatchEvidenceGateway.class);ReflectionTestUtils.setField(f.service,"evidence",files);
-        when(files.metadata(id,DispatchEvidenceGateway.Kind.EXCEPTION,91L)).thenThrow(new IllegalArgumentException("文件不属于当前车"));
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,request(0,"files",List.of(91L))))).hasMessageContaining("不属于");
-        assertThat(f.service.detail(f.actor,no).dispatchInfo().exceptions()).isEmpty();
-        var missingType=new DispatchCommands.MarkException(0L,"no-type",null,null,null,List.of());
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,missingType))).hasMessageContaining("请选择异常类型");
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,request(0,"duplicates",List.of(91L,91L))))).hasMessageContaining("图片引用");
-        doReturn(new DispatchEvidenceGateway.File(91L,"现场.png","image/png",10L)).when(files).metadata(id,DispatchEvidenceGateway.Kind.EXCEPTION,91L);
-        f.tx.execute(t->f.service.markException(f.actor,no,request(0,"files",List.of(91L))));
-        assertThat(f.service.detail(f.actor,no).dispatchInfo().exceptions().get(0).imageFileIds()).containsExactly(91L);
-        verify(files,times(2)).metadata(id,DispatchEvidenceGateway.Kind.EXCEPTION,91L);
-    }
-
-    /** 创建真实排车后仅以SQL模拟已发车前置，不声称此用例执行装车流程。 */
-    private String create(DispatchAggregatePersistenceTest.Fixture f) {
-        var created=f.tx.execute(t->f.service.create(f.actor,f.configured("create",List.of())));
-        f.db.update("UPDATE ll_dispatch_order SET stage='DELIVERING',shipped_package_count=3,departed_at=CURRENT_TIMESTAMP");return created.dispatchNo();
-    }
-    /** 构造类型必填、其余选填的最小登记请求。 */
-    private DispatchCommands.MarkException request(long version,String key,List<Long> images) { return new DispatchCommands.MarkException(version,key,ExceptionType.VEHICLE_EXCEPTION,null,null,images); }
-}

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

@@ -1,15 +1,6 @@
 package com.baiyue.lastleg.dispatch.service;
 
 import com.baiyue.lastleg.dispatch.mapper.*;
-import com.baiyue.lastleg.fleet.ownedbusiness.service.*;
-import com.baiyue.lastleg.fleet.ownedbusiness.gateway.OwnedBusinessFileGateway;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort.BindPhoto;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort.Documents;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort.Slot;
-import com.baiyue.lastleg.fleet.ownedbusiness.mapper.*;
-import com.baiyue.lastleg.fleet.ownedbusiness.repository.OwnedBusinessRepository;
-import java.nio.file.*;
-import java.util.regex.Pattern;
 import com.baiyue.lastleg.dispatch.pda.service.DispatchPdaWorkflowService;
 import com.baiyue.lastleg.dispatch.port.*;
 import com.baiyue.lastleg.dispatch.repository.*;
@@ -28,53 +19,43 @@ import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 import static org.mockito.ArgumentMatchers.*;
 
-/** 装车后五框门禁、保存发车共同事务及跨端竞争使用真实单据和版本。 */
+/** 装完即发车的共同事务、原键最终结果及跨端竞争使用真实根单据和版本。 */
 class DispatchLoadingDeparturePersistenceTest {
     /** 每例恢复隔离身份，不影响其他服务权限测试。 */
     @AfterEach void clearSecurity(){SecurityContextHolder.clearContext();}
 
-    /** 装车完成不发车，第五张保存自动发车，旧装车键保持原装车后结果。 */
-    @Test void loadingWaitsForFivePhotosThenDepartsOnce() throws Exception {
+    /** 一次确认完成全部客户发运；原键重放返回派送中，不再生成子单或执行来源。 */
+    @Test void loadingCompletesAllCustomersAndReplaysOnlyFinalResult() throws Exception {
         authorize();var f=new Fixture();
         var result=f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("complete")));
-        assertThat(result.action()).isEqualTo(Action.LOADING_COMPLETE);assertThat(result.stage()).isEqualTo(Stage.AFTER_LOADING);
-        assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_delivery_order",Long.class)).isZero();
-        for(int i=0;i<4;i++)assertThat(f.bind(i,f.f.actor).stage()).isEqualTo("AFTER_LOADING");
-        assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_delivery_order",Long.class)).isZero();
-        var fifth=f.bind(4,new Actor("picker",ActorMode.PDA,"9"));assertThat(fifth.stage()).isEqualTo("DELIVERING");
-        assertThat(fifth.complete()).isTrue();assertThat(fifth.photos()).hasSize(5);
-        var replayPhoto=f.f.tx.execute(s->f.documents.bind(new Actor("picker",ActorMode.PDA,"9"),f.number,Slot.RECEIPT,new BindPhoto("4","photo-bind-4","1004")));
-        assertThat(replayPhoto).isEqualTo(fifth);
-        assertThat(result.counts().shippedPackageCount()).isZero();assertThat(result.result()).isInstanceOf(DispatchResults.Loaded.class);
+        assertThat(result.action()).isEqualTo(Action.LOADING_COMPLETE);assertThat(result.stage()).isEqualTo(Stage.DELIVERING);
+        assertThat(result.counts().shippedPackageCount()).isEqualTo(8);assertThat(result.result()).isInstanceOf(DispatchResults.Loaded.class);
         assertThat(f.f.db.queryForList("SELECT status FROM ll_outbound_order",String.class)).containsExactly("OUTBOUNDED","OUTBOUNDED");
         assertThat(f.f.db.queryForList("SELECT status FROM ll_delivery_order",String.class)).containsExactly("DELIVERING","DELIVERING");
         assertThat(f.f.db.queryForObject("SELECT status FROM ll_fleet_trip",String.class)).isEqualTo("IN_TRANSIT");
         assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_pda_pick",Long.class)).isEqualTo(2);
-        assertThat(f.f.db.queryForObject("SELECT result_json FROM ll_dispatch_command WHERE idempotency_key='complete'",String.class)).contains("AFTER_LOADING");
+        assertThat(f.f.db.queryForObject("SELECT result_json FROM ll_dispatch_command WHERE idempotency_key='complete'",String.class)).contains("DELIVERING");
         var replay=f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("complete")));
         assertThat(replay.replayed()).isTrue();assertThat(replay.recordVersion()).isEqualTo(result.recordVersion());assertThat(replay.result()).isEqualTo(result.result());
-        assertThat(f.f.tx.execute(s->f.f.service.command(f.f.actor,f.number,"complete")).stage()).isEqualTo(Stage.AFTER_LOADING);
+        assertThat(f.f.tx.execute(s->f.f.service.command(f.f.actor,f.number,"complete")).stage()).isEqualTo(Stage.DELIVERING);
         verify(f.delivery,times(1)).prepareForDeparture(any(),any(),anyString());verify(f.sourceWorkflow,times(1)).departWholeSources(any(),any(),any(),any());
         assertThat(f.f.service.actions(f.f.actor,f.f.repository.find(f.number))).doesNotContainKeys(Action.ARRANGE_DELIVERY,Action.DEPART);
         assertThatThrownBy(()->f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("stale-new")))).hasMessageContaining("版本或审核阶段");
     }
 
-    /** 派送失败回滚第五张绑定，保留已确认装车和前四张资料，原文件可重试。 */
-    @Test void preparationAndDepartureFailuresRollBackTheFifthPhoto() throws Exception {
+    /** 任一后续步骤失败都恢复装车中，已提交的真实拣货保持，不留下中间装车或子单。 */
+    @Test void preparationAndDepartureFailuresRollBackTheEntireLoadingCommand() throws Exception {
         authorize();
         for(boolean failPreparation:List.of(true,false)) {
             var f=new Fixture();
-            f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("complete")));
-            for(int i=0;i<4;i++)f.bind(i,f.f.actor);
             if(failPreparation)doThrow(new IllegalStateException("模拟单据准备失败")).when(f.delivery).prepareForDeparture(any(),any(),anyString());
             else doThrow(new IllegalStateException("模拟来源发运失败")).when(f.sourceWorkflow).departWholeSources(any(),any(),any(),any());
-            assertThatThrownBy(()->f.bind(4,f.f.actor)).isInstanceOf(IllegalStateException.class);
-            var row=f.f.repository.find(f.number);assertThat(row.getStage()).isEqualTo("AFTER_LOADING");assertThat(row.getRecordVersion()).isEqualTo(f.version+1);
-            assertThat(row.getLoadingCompletionHash()).isNotNull();
-            assertThat(f.documents.get(f.f.actor,f.number).photos()).hasSize(4);assertThat(row.getArrangementKey()).isNull();assertThat(row.getDepartedAt()).isNull();
+            assertThatThrownBy(()->f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("failed")))).isInstanceOf(IllegalStateException.class);
+            var row=f.f.repository.find(f.number);assertThat(row.getStage()).isEqualTo("LOADING");assertThat(row.getRecordVersion()).isEqualTo(f.version);
+            assertThat(row.getLoadingCompletionHash()).isNull();assertThat(row.getArrangementKey()).isNull();assertThat(row.getDepartedAt()).isNull();
             assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_outbound_order",Long.class)).isZero();
             assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_delivery_order",Long.class)).isZero();
-            assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_command WHERE action IN ('ARRANGE_DELIVERY','DEPART')",Long.class)).isZero();
+            assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_command WHERE action IN ('LOADING_COMPLETE','ARRANGE_DELIVERY','DEPART')",Long.class)).isZero();
             assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_pda_pick",Long.class)).isEqualTo(2);
             assertThat(f.f.db.queryForObject("SELECT status FROM ll_fleet_trip",String.class)).isEqualTo("PLANNED");
         }
@@ -87,12 +68,12 @@ class DispatchLoadingDeparturePersistenceTest {
         var bad=new DispatchCommands.LoadingComplete(f.version,"bad-manifest","changed",f.measurements,null);
         assertThatThrownBy(()->f.f.tx.execute(s->f.service.complete(pda,f.number,bad))).hasMessageContaining("真实装载清单已变化");
         verify(f.delivery,never()).prepareForDeparture(any(),any(),anyString());
-        var result=f.f.tx.execute(s->f.service.complete(pda,f.number,f.request("pda")));assertThat(result.stage()).isEqualTo(Stage.AFTER_LOADING);
+        var result=f.f.tx.execute(s->f.service.complete(pda,f.number,f.request("pda")));assertThat(result.stage()).isEqualTo(Stage.DELIVERING);
         SecurityContextHolder.getContext().setAuthentication(new TestingAuthenticationToken("picker","","ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR"));
         assertThatThrownBy(()->f.f.tx.execute(s->f.service.complete(pda,f.number,f.request("pda")))).hasMessageContaining("装车完成权限");
     }
 
-    /** 同一版本后台/PDA同时确认只有一次装车提交，资料未齐不发车。 */
+    /** 同一版本后台/PDA同时确认只有一条完整链提交，不会产生半车或重复派送。 */
     @Test void concurrentAdminAndPdaCompleteOnlyOneDeparture() throws Exception {
         authorize();var f=new Fixture();var start=new CountDownLatch(1);var workers=Executors.newFixedThreadPool(2);
         try {
@@ -100,99 +81,20 @@ class DispatchLoadingDeparturePersistenceTest {
             var b=workers.submit(()->f.tryComplete(start,new Actor("picker",ActorMode.PDA,"9"),"pda"));
             start.countDown();assertThat(List.of(a.get(25,TimeUnit.SECONDS),b.get(25,TimeUnit.SECONDS))).containsExactlyInAnyOrder(true,false);
         } finally {workers.shutdownNow();}
-        assertThat(f.f.repository.find(f.number).getStage()).isEqualTo("AFTER_LOADING");
-        verify(f.delivery,never()).prepareForDeparture(any(),any(),anyString());verify(f.sourceWorkflow,never()).departWholeSources(any(),any(),any(),any());
-    }
-
-    /** 装车中可上传，装车前与跨仓拒绝，平台只读权限不能保存照片。 */
-    @Test void loadingDocumentsEnforceStageWarehouseAndWritePermission() throws Exception {
-        authorize();var f=new Fixture();
-        assertThat(f.documents.get(f.f.actor,f.number).stage()).isEqualTo("LOADING");
-        f.f.db.update("UPDATE ll_dispatch_order SET stage='BEFORE_LOADING'");
-        assertThatThrownBy(()->f.documents.get(f.f.actor,f.number)).hasMessageContaining("进入装车中后");
-        f.f.db.update("UPDATE ll_dispatch_order SET stage='LOADING'");
-        f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("complete")));
-        assertThatThrownBy(()->f.documents.get(new Actor("picker",ActorMode.PDA,"99"),f.number)).hasMessageContaining("当前绑定仓");
-        assertThatThrownBy(()->f.f.tx.execute(s->f.documents.bind(f.f.actor,f.number,null,new BindPhoto("0","wrong-slot","1000")))).hasMessageContaining("装车照片框");
-        SecurityContextHolder.getContext().setAuthentication(new TestingAuthenticationToken("reader","","platform:overseas-warehouse:dispatch:list"));
-        assertThat(f.documents.get(f.f.actor,f.number).editable()).isFalse();
-        assertThatThrownBy(()->f.bind(0,f.f.actor)).hasMessageContaining("无装车资料操作权限");
-    }
-
-    /** 两端同版本竞争第五张，仅一个绑定和一次真实派送成功。 */
-    @Test void concurrentFifthPhotoCannotDispatchTwice() throws Exception {
-        authorize();var f=new Fixture();f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("complete")));
-        for(int i=0;i<4;i++)f.bind(i,f.f.actor);
-        var start=new CountDownLatch(1);var workers=Executors.newFixedThreadPool(2);
-        try {
-            var results=new ArrayList<Future<Boolean>>();
-            for(String key:List.of("admin-last","pda-last"))results.add(workers.submit(()->{
-                authorize();try {start.await(5,TimeUnit.SECONDS);var actor=key.startsWith("pda")?new Actor("picker",ActorMode.PDA,"9"):f.f.actor;
-                    f.f.tx.execute(s->f.documents.bind(actor,f.number,Slot.RECEIPT,new BindPhoto("4",key,"1004")));return true;
-                }catch(com.baiyue.common.core.exception.BizException expected){return false;}
-                finally {SecurityContextHolder.clearContext();}
-            }));
-            start.countDown();assertThat(List.of(results.get(0).get(25,TimeUnit.SECONDS),results.get(1).get(25,TimeUnit.SECONDS))).containsExactlyInAnyOrder(true,false);
-        } finally {workers.shutdownNow();}
-        verify(f.delivery,times(1)).prepareForDeparture(any(),any(),anyString());
-        assertThat(f.documents.get(f.f.actor,f.number).photos()).hasSize(5);
         assertThat(f.f.repository.find(f.number).getStage()).isEqualTo("DELIVERING");
+        verify(f.delivery,times(1)).prepareForDeparture(any(),any(),anyString());verify(f.sourceWorkflow,times(1)).departWholeSources(any(),any(),any(),any());
     }
 
-    /** 资料先齐不能提前发车；确认装车后直接派送，原键返回相同最终结果。 */
-    @Test void photosReadyBeforeLoadingConfirmationDepartAndReplayOnce() throws Exception {
-        authorize();var f=new Fixture();
-        for(int i=0;i<5;i++)assertThat(f.bind(i,f.f.actor).stage()).isEqualTo("LOADING");
-        verify(f.delivery,never()).prepareForDeparture(any(),any(),anyString());
-        var result=f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("ready-complete")));
-        assertThat(result.action()).isEqualTo(Action.LOADING_COMPLETE);
-        assertThat(result.stage()).isEqualTo(Stage.DELIVERING);assertThat(result.counts().shippedPackageCount()).isEqualTo(8);
-        assertThat(result.result()).isInstanceOf(DispatchResults.Loaded.class);
-        var replay=f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("ready-complete")));
-        assertThat(replay.replayed()).isTrue();assertThat(replay.stage()).isEqualTo(Stage.DELIVERING);
-        assertThat(replay.recordVersion()).isEqualTo(result.recordVersion());assertThat(replay.result()).isEqualTo(result.result());
-        assertThat(f.f.tx.execute(s->f.f.service.command(f.f.actor,f.number,"ready-complete")).stage()).isEqualTo(Stage.DELIVERING);
-        verify(f.delivery,times(1)).prepareForDeparture(any(),any(),anyString());
-        verify(f.sourceWorkflow,times(1)).departWholeSources(any(),any(),any(),any());
-    }
-
-    /** 资料先齐时派送失败回滚本次装车确认，五张已保存照片保留供原请求重试。 */
-    @Test void readyDocumentsSurviveFailedLoadingAndOriginalRequestCanRetry() throws Exception {
-        authorize();var f=new Fixture();for(int i=0;i<5;i++)f.bind(i,f.f.actor);
-        doThrow(new IllegalStateException("模拟发运失败")).when(f.sourceWorkflow).departWholeSources(any(),any(),any(),any());
-        assertThatThrownBy(()->f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("retry-ready")))).hasMessageContaining("模拟发运失败");
-        assertThat(f.f.repository.find(f.number).getStage()).isEqualTo("LOADING");
-        assertThat(f.documents.get(f.f.actor,f.number).complete()).isTrue();
-        assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_delivery_order",Long.class)).isZero();
-        assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_command WHERE idempotency_key='retry-ready'",Long.class)).isZero();
-        doNothing().when(f.sourceWorkflow).departWholeSources(any(),any(),any(),any());
-        assertThat(f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("retry-ready"))).stage()).isEqualTo(Stage.DELIVERING);
-    }
-
-    /** 最后一张照片与装车确认同时提交，不论谁先拿父锁均只发车一次。 */
-    @Test void lastPhotoAndLoadingConfirmationCanFinishConcurrently() throws Exception {
-        authorize();var f=new Fixture();for(int i=0;i<4;i++)f.bind(i,f.f.actor);
-        var start=new CountDownLatch(1);var workers=Executors.newFixedThreadPool(2);
-        try {
-            var load=workers.submit(()->f.tryComplete(start,f.f.actor,"concurrent-load"));
-            var photo=workers.submit(()->{authorize();try {start.await(5,TimeUnit.SECONDS);return f.bind(4,new Actor("picker",ActorMode.PDA,"9"));}finally{SecurityContextHolder.clearContext();}});
-            start.countDown();assertThat(load.get(25,TimeUnit.SECONDS)).isTrue();assertThat(photo.get(25,TimeUnit.SECONDS)).isNotNull();
-        } finally {workers.shutdownNow();}
-        assertThat(f.f.repository.find(f.number).getStage()).isEqualTo("DELIVERING");
-        verify(f.delivery,times(1)).prepareForDeparture(any(),any(),anyString());
-        verify(f.sourceWorkflow,times(1)).departWholeSources(any(),any(),any(),any());
-    }
-
-    /** 配置资料与装车权限及PDA既有角色，不授予人工派送、发车权限。 */
+    /** 仅配置装车完成及PDA既有角色权限，不授予人工派送、发车权限。 */
     private static void authorize(){SecurityContextHolder.getContext().setAuthentication(new TestingAuthenticationToken("operator","",
-        "platform:overseas-warehouse:dispatch:list","platform:overseas-warehouse:dispatch:edit","platform:overseas-warehouse:dispatch:loading-complete","lastleg:pda:operate","ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR"));}
+        "platform:overseas-warehouse:dispatch:loading-complete","lastleg:pda:operate","ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR"));}
 
     /** 主流程与发车使用真实SQL，派送提供者受控写入真实子单来验证共同回滚。 */
     private static final class Fixture {
         final DispatchAggregatePersistenceTest.Fixture f=new DispatchAggregatePersistenceTest.Fixture();
         final DispatchDeliveryPort delivery=mock(DispatchDeliveryPort.class);
         final DispatchPdaWorkflowService sourceWorkflow=mock(DispatchPdaWorkflowService.class);
-        final DispatchLoadingDepartureService service;final DispatchLoadingDocumentService documents;final String number;final long version;final String manifest;
+        final DispatchLoadingDepartureService service;final String number;final long version;final String manifest;
         final List<LoadingMeasurement> measurements;
         /** 创建两客户货物并走真实两级审核、真实拣货归属，不伪造已装车状态。 */
         Fixture() throws Exception {
@@ -224,23 +126,7 @@ class DispatchLoadingDeparturePersistenceTest {
             var hashes=new DispatchCommandHasher(f.json);
             var sources=new DispatchSourceRepository(mock(DispatchCandidateMapper.class),mock(ReturnDispatchCandidateMapper.class),f.session.getMapper(DispatchSourceMapper.class));
             var departure=new DispatchDepartureService(f.service,f.repository,sources,delivery,sourceWorkflow,f.fleet,ledger,hashes,f.json);
-            f.session.getConfiguration().addMapper(OwnedBusinessMapper.class);
-            String schema=Files.readString(Path.of("src/main/resources/db/lastleg.sql"));
-            for(String suffix:List.of("record","command","history")) {
-                var matcher=Pattern.compile("(?s)CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_"+suffix+" \\(.*?;").matcher(schema);
-                assertThat(matcher.find()).isTrue();
-                f.db.execute(matcher.group().replace(" JSON"," LONGTEXT").replace(" COLLATE utf8mb4_bin","").replaceFirst("(?s) ENGINE=InnoDB.*?;$",";"));
-            }
-            var records=new OwnedBusinessRepository(f.session.getMapper(OwnedBusinessMapper.class),mock(OwnedBusinessQueryMapper.class));
-            var codec=new OwnedBusinessSupport(f.json);var files=mock(OwnedBusinessFileGateway.class);
-            when(files.metadata(anyLong(),any(),anyLong())).thenAnswer(call->new OwnedBusinessFileGateway.Evidence(call.getArgument(2),"loading.png","image/png",12,"2026-10-21T00:00:00Z"));
-            var photos=new DispatchLoadingPhotoAdapter(records,new OwnedBusinessCommandService(records,codec),new OwnedBusinessProjection(codec),codec,files);
-            service=new DispatchLoadingDepartureService(f.service,delivery,departure,ledger,hashes,photos);
-            documents=new DispatchLoadingDocumentService(f.service,service,photos);
-        }
-        /** 每张照片保留独立版本与幂等键，复用真实附加记录保存事务。 */
-        Documents bind(int index,Actor actor) {
-            return f.tx.execute(s->documents.bind(actor,number,DispatchLoadingDocumentService.SLOTS.get(index),new BindPhoto(Integer.toString(index),"photo-bind-"+index,Long.toString(1000L+index))));
+            service=new DispatchLoadingDepartureService(f.service,delivery,departure,ledger,hashes);
         }
         /** 每次请求沿用最初真实测量和版本，便于验证竞争及原键恢复。 */
         DispatchCommands.LoadingComplete request(String key){return new DispatchCommands.LoadingComplete(version,key,manifest,measurements,"实装发车");}

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

@@ -23,44 +23,6 @@ import static org.mockito.Mockito.*;
 
 /** 根版本、幂等、真实客户作业与扫码持久化；库存/归属应用命令在此明确模拟，另由原域直接测试验证。 */
 class DispatchPickingPersistenceTest {
-    /** 数量可自然同步不代表能接管其他车的实际托盘。 */
-    @Test void receivedPalletClaimedByAnotherDispatchCannotBePicked() throws Exception {
-        var fixture=new Picking(true);fixture.receivedPlans(9,11);
-        fixture.f.db.update("UPDATE ll_dispatch_physical_pallet_lock SET dispatch_order_id=999 WHERE warehouse_pallet_id=501");
-        assertThatThrownBy(()->fixture.f.tx.execute(s->fixture.service.pick(fixture.actor,fixture.number,fixture.item,
-            new DispatchCommands.Pick(fixture.version,"occupied-pallet",11L,9,0,null,null))))
-            .isInstanceOf(com.baiyue.common.core.exception.BizException.class).hasMessageContaining("占用");
-        verify(fixture.inventory,never()).ship(any(),any(),any());
-        assertThat(fixture.f.db.queryForList("SELECT package_count FROM ll_dispatch_item ORDER BY customer_id",Integer.class)).containsExactly(10,10);
-    }
-    /** 预排两托10+10、实收9+11，首次扫码同步真实数量并保留原审核，原键重放不重复扣货。 */
-    @Test void receivedPalletCountsReplaceEstimatesAtomically() throws Exception {
-        var fixture=new Picking(true);fixture.receivedPlans(9,11);
-        var firstRequest=new DispatchCommands.Pick(fixture.version,"received-nine",11L,9,0,null,null);
-        var first=fixture.f.tx.execute(s->fixture.service.pick(fixture.actor,fixture.number,fixture.item,firstRequest));
-        assertThat(fixture.f.db.queryForList("SELECT package_count FROM ll_dispatch_item ORDER BY customer_id",Integer.class)).containsExactly(9,11);
-        assertThat(fixture.f.db.queryForObject("SELECT package_count FROM ll_dispatch_order",Integer.class)).isEqualTo(20);
-        assertThat(fixture.f.db.queryForObject("SELECT review_state FROM ll_dispatch_order",String.class)).isEqualTo("APPROVED");
-        var replay=fixture.f.tx.execute(s->fixture.service.pick(fixture.actor,fixture.number,fixture.item,firstRequest));
-        assertThat(replay.replayed()).isTrue();
-        var second=fixture.f.tx.execute(s->fixture.service.pick(fixture.actor,fixture.number,fixture.secondItem,
-            new DispatchCommands.Pick(first.recordVersion(),"received-eleven",12L,11,0,null,null)));
-        assertThat(((DispatchResults.Picked)second.result()).pickingReconciled()).isTrue();
-        verify(fixture.inventory,times(2)).ship(anyString(),eq("picker"),any());
-        assertThat(fixture.f.db.queryForObject("SELECT SUM(available_packages) FROM ll_inventory_position",Long.class)).isZero();
-    }
-
-    /** 实收绑定后扣货失败必须同时回滚数量、绑定、总数和原审核。 */
-    @Test void receivedQuantityAndBindingRollBackWhenStockWriteFails() throws Exception {
-        var fixture=new Picking(true);fixture.receivedPlans(8,11);
-        doThrow(new IllegalStateException("库存命令失败")).when(fixture.inventory).ship(anyString(),anyString(),any());
-        assertThatThrownBy(()->fixture.f.tx.execute(s->fixture.service.pick(fixture.actor,fixture.number,fixture.item,
-            new DispatchCommands.Pick(fixture.version,"receipt-rollback",11L,8,0,null,null)))).isInstanceOf(IllegalStateException.class);
-        assertThat(fixture.f.db.queryForList("SELECT package_count FROM ll_dispatch_item ORDER BY customer_id",Integer.class)).containsExactly(10,10);
-        assertThat(fixture.f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_item WHERE warehouse_pallet_id IS NOT NULL",Long.class)).isZero();
-        assertThat(fixture.f.db.queryForObject("SELECT package_count FROM ll_dispatch_order",Integer.class)).isEqualTo(20);
-        assertThat(fixture.f.db.queryForObject("SELECT record_version FROM ll_dispatch_order",Long.class)).isEqualTo(fixture.version);
-    }
     /** 原键在后续版本仍恢复原结果，不能重复调用SHIP或创建第二条真实扫码。 */
     @Test void sameKeyShipsOnceAndLastPickDoesNotConfirmLoading() throws Exception {
         var fixture=new Picking();var request=new DispatchCommands.Pick(fixture.version,"pda-pick-original",11L,3,6,null,"实际扫码");
@@ -106,7 +68,6 @@ class DispatchPickingPersistenceTest {
         final DispatchAggregatePersistenceTest.Fixture f=new DispatchAggregatePersistenceTest.Fixture();
         final InventoryCommandService inventory=mock(InventoryCommandService.class);final DispatchPickOrderAttributionService attribution=mock(DispatchPickOrderAttributionService.class);
         final DispatchPickingService service;final String number;final long item,version;final Long secondItem;
-        final DispatchSourceRepository sources;
         final DispatchContracts.Actor actor=new DispatchContracts.Actor("picker",ActorMode.PDA,"9");
         /** 建立真实客户来源、作业表、扫码表与可以参与回滚的库存行。 */
         Picking() throws Exception {this(false);}
@@ -133,33 +94,10 @@ class DispatchPickingPersistenceTest {
             doAnswer(call->{com.baiyue.lastleg.inventory.command.dto.InventoryCommandRequests.Move move=call.getArgument(2);f.db.update("UPDATE ll_inventory_position SET available_packages=available_packages-?,version=version+1 WHERE id=? AND customer_id=?",move.packages(),move.positionId(),call.getArgument(0));return null;}).when(inventory).ship(anyString(),eq("picker"),any());
             doAnswer(call->{String customer=call.getArgument(0);DispatchPdaPick pick=call.getArgument(1);long order="101".equals(customer)?9001L:9002L;long receipt="101".equals(customer)?1L:2L;f.db.update("INSERT INTO ll_dispatch_pda_pick_order(id,customer_id,pick_id,order_id,receipt_id,packages,product_quantity)VALUES(?,?,?,?,?,?,?)",pick.getId(),customer,pick.getId(),order,receipt,pick.getPackages(),pick.getProductQuantity());return List.of(new DispatchPickOrderAttributionService.OrderPackages(order,pick.getPackages()));})
                 .when(attribution).attribute(anyString(),any(DispatchPdaPick.class),isNull());
-            sources=spy(new DispatchSourceRepository(mock(DispatchCandidateMapper.class),mock(ReturnDispatchCandidateMapper.class),f.session.getMapper(DispatchSourceMapper.class)));
+            var sources=new DispatchSourceRepository(mock(DispatchCandidateMapper.class),mock(ReturnDispatchCandidateMapper.class),f.session.getMapper(DispatchSourceMapper.class));
             var commands=new DispatchCommandLedger(new DispatchCommandRepository(f.session.getMapper(DispatchCommandMapper.class)),new DispatchCommandCodec(f.json));
             service=new DispatchPickingService(f.service,f.repository,sources,new DispatchPickingRepository(session.getMapper(DispatchPdaTaskMapper.class),session.getMapper(DispatchPdaPickMapper.class),session.getMapper(InventoryPositionMapper.class),session.getMapper(DispatchItemMapper.class)),attribution,inventory,mock(ReturnRelabelDispatchStock.class),commands,new DispatchCommandHasher(f.json),f.json);
             for(var field:List.of("physicalClaims","relabelSources","sourceRules"))org.springframework.test.util.ReflectionTestUtils.setField(service,field,org.springframework.test.util.ReflectionTestUtils.getField(f.service,field));
-            org.springframework.test.util.ReflectionTestUtils.setField(service,"fleet",f.fleet);
-        }
-        /** 来源查询在此隔离，实收同步仍使用真实主单、明细、库存及车次事务。 */
-        void receivedPlans(int first,int second) {
-            f.db.update("UPDATE ll_dispatch_item SET warehouse_pallet_id=NULL,source_stage='PLAN',package_count=10");
-            f.db.update("UPDATE ll_dispatch_order SET package_count=20");
-            var rules=(DispatchService)org.springframework.test.util.ReflectionTestUtils.getField(service,"sourceRules");
-            for(int n=1;n<=2;n++) {
-                long plan=n,pallet=500+n;String customer=n==1?"101":"102";int count=n==1?first:second;
-                f.candidates.get(plan).packageCount(count);
-                f.db.update("UPDATE ll_inventory_position SET available_packages=? WHERE id=?",count,10+n);
-                doReturn(List.of(f.candidates.get(plan))).when(sources).selectedPlan(customer,plan);
-                doReturn(true).when(sources).receivedPlanCompleted(customer,plan);
-                doReturn(List.of(9000+plan)).when(sources).sourceOrders(customer,null,plan);
-                doReturn(List.of(9000+plan)).when(sources).sourceOrders(customer,pallet,plan);
-                doReturn(plan).when(sources).lockPlan(customer,plan);
-                doReturn(1).when(sources).materialize(anyLong(),eq(customer),eq(plan),eq(pallet),anyLong(),any());
-            }
-            when(rules.selectionGroup(anyString(),any())).thenAnswer(call->{
-                var selected=(DispatchCommands.CargoSelection)call.getArgument(1);long plan=selected.planPalletId();var row=f.candidates.get(plan);
-                return new DispatchPlanningModels.SelectionGroup("group","version",List.of(new DispatchPlanningModels.SelectionGroupSource(
-                    selected,"PLAN:"+plan,row.customerId(),row.customerName(),"INBOUND_PLAN","PLAN-"+plan,row.packageCount())),List.of(),true,List.of());
-            });
         }
         /** 使用实际实体属性建最小测试表，不修改或声称验证正式DDL。 */
         private static String sqlType(Class<?> type){return type==Long.class?"BIGINT":type==Integer.class?"INT":type==LocalDateTime.class?"TIMESTAMP(3)":"VARCHAR(20000)";}

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

@@ -17,22 +17,6 @@ import static org.mockito.ArgumentMatchers.*;
 
 /** 真实PDA任务投影衔接原计划；来源提供者隔离，GET不得写绑定或库存。 */
 class DispatchPlanPdaReadPersistenceTest {
-    /** 完成状态查询走真实Mapper，未完成或其他客户的计划不能被当作本托实收。 */
-    @Test void completionGateUsesOriginalCustomerAndPlan() throws Exception {
-        var f=new Fixture();
-        f.f.db.execute("CREATE TABLE ll_inbound_plan(id BIGINT,customer_id VARCHAR(64),status VARCHAR(64))");
-        f.f.db.execute("CREATE TABLE ll_inbound_plan_pallet(id BIGINT,plan_id BIGINT,customer_id VARCHAR(64))");
-        f.f.db.update("INSERT INTO ll_inbound_plan VALUES(1,'101','IN_PROGRESS')");
-        f.f.db.update("INSERT INTO ll_inbound_plan_pallet VALUES(2,1,'101')");
-        var mapper=f.f.session.getMapper(com.baiyue.lastleg.dispatch.mapper.DispatchSourceMapper.class);
-        assertThat(mapper.receivedPlanCompleted("101",2L)).isZero();
-        for(var status:List.of("COMPLETED","PENDING_RECONCILIATION")) {
-            f.f.db.update("UPDATE ll_inbound_plan SET status=?",status);
-            assertThat(mapper.receivedPlanCompleted("101",2L)).isOne();
-            assertThat(mapper.receivedPlanCompleted("other",2L)).isZero();
-            assertThat(mapper.receivedPlanCompleted("101",3L)).isZero();
-        }
-    }
     /** 已实收原计划直接提供首拣仓位，查询不推进原车版本或写入实托。 */
     @Test void receivedPlanExposesPositionWithoutMaterializing() throws Exception {
         var f=new Fixture();var before=f.dbState();
@@ -44,23 +28,15 @@ class DispatchPlanPdaReadPersistenceTest {
         verify(f.sources,never()).materialize(anyLong(),anyString(),anyLong(),anyLong(),anyLong(),any());
         verify(f.rules,never()).lockExecutionSources(anyString(),anyList());
     }
-    /** 在途和来源身份变化均不成为可拣库存。 */
+    /** 在途、预留托盘和实收数量漂移均不成为可拣库存。 */
     @Test void unreceivedOrChangedPlanHasNoPositions() throws Exception {
         var f=new Fixture();var row=f.f.candidates.get(1L);
         row.sourceStage("PLAN");assertThat(f.read().items().get(0).positions()).isEmpty();
-        row.sourceStage("RECEIVED");row.overseasWarehouseId("99");assertThat(f.read().items().get(0).positions()).isEmpty();
+        row.sourceStage("RECEIVED");row.packageCount(2);assertThat(f.read().items().get(0).positions()).isEmpty();
+        row.packageCount(3);row.overseasWarehouseId("99");assertThat(f.read().items().get(0).positions()).isEmpty();
         row.overseasWarehouseId("9");row.customerId("other");assertThat(f.read().items().get(0).positions()).isEmpty();
         verify(f.sources,never()).stock(anyString(),anyLong(),anyBoolean());
     }
-    /** 自动预分配的10+10不约束实收9+11；查询给出实际数量且不改数据库。 */
-    @Test void plannedTenAndTenProjectsReceivedNineAndEleven() throws Exception {
-        var f=new Fixture(true);var before=f.dbState();
-        var task=f.read();
-        assertThat(task.items()).extracting(DispatchViews.PdaItem::scheduledPackages).containsExactly(9L,11L);
-        assertThat(task.items()).allSatisfy(i->assertThat(i.positions()).isNotEmpty());
-        assertThat(task.counts().packageCount()).isEqualTo(20);
-        assertThat(f.dbState()).isEqualTo(before);
-    }
     /** 原计划不能吸收新的订单或未经原车审核的同托来源。 */
     @Test void changedOrdersOrAdditionalPalletSourceBlocksFirstPick() throws Exception {
         var f=new Fixture();
@@ -77,18 +53,11 @@ class DispatchPlanPdaReadPersistenceTest {
     @Test void actualStockMustMatchWarehousePalletAndQuantity() throws Exception {
         var f=new Fixture();
         for(var stock:List.of(new Stock(11,21,501L,"99",3,0,0,0,1),
-            new Stock(11,21,502L,"9",3,0,0,0,1),new Stock(11,21,501L,"9",2,0,0,0,1),
-            new Stock(11,21,501L,"9",3,1,0,0,1),new Stock(11,21,501L,"9",3,0,1,0,1))) {
+            new Stock(11,21,502L,"9",3,0,0,0,1),new Stock(11,21,501L,"9",2,0,0,0,1))) {
             when(f.sources.stock("101",501L,false)).thenReturn(List.of(stock));
             assertThat(f.read().items().get(0).positions()).isEmpty();
         }
     }
-    /** 收货尚未结束时不把当前部分实收数量当成整托最终数量。 */
-    @Test void receivingPlanDoesNotExposePartialPallet() throws Exception {
-        var f=new Fixture();when(f.sources.receivedPlanCompleted("101",1L)).thenReturn(false);
-        assertThat(f.read().items().get(0).positions()).isEmpty();
-        verify(f.sources,never()).stock(anyString(),anyLong(),anyBoolean());
-    }
     /** 复用真实排车及PDA Mapper，模拟原计划来源快照。 */
     private static final class Fixture {
         final DispatchAggregatePersistenceTest.Fixture f=new DispatchAggregatePersistenceTest.Fixture();
@@ -96,13 +65,9 @@ class DispatchPlanPdaReadPersistenceTest {
         final DispatchService rules=mock(DispatchService.class);
         final DispatchPdaQueryService queries;final String number;
         /** 原车已审核，只清除自然收货尚未补写的实托字段。 */
-        Fixture() throws Exception {this(false);}
-        /** 同一客户两托先预排再实收，模拟计划拆分与真实入托数量不同。 */
-        Fixture(boolean twoPallets) throws Exception {
-            var selection=f.source(1,"101",501,"ONT8",twoPallets?10:3);
-            var selections=new java.util.ArrayList<DispatchCommands.CargoSelection>();selections.add(selection);
-            if(twoPallets)selections.add(f.source(2,"101",502,"ONT8",10));
-            var created=f.tx.execute(s->f.service.create(f.actor,f.configured("plan-pda-read",selections)));
+        Fixture() throws Exception {
+            var selection=f.source(1,"101",501,"ONT8",3);
+            var created=f.tx.execute(s->f.service.create(f.actor,f.configured("plan-pda-read",List.of(selection))));
             f.approve(created);number=created.dispatchNo();
             f.db.update("UPDATE ll_dispatch_item SET warehouse_pallet_id=NULL,source_stage='PLAN'");
             f.db.execute("CREATE TABLE ll_inventory_position(id BIGINT,customer_id VARCHAR(64),balance_id BIGINT,pallet_id BIGINT,overseas_warehouse_id VARCHAR(64),available_packages BIGINT,hold_packages BIGINT,allocated_packages BIGINT,picked_packages BIGINT)");
@@ -111,28 +76,12 @@ class DispatchPlanPdaReadPersistenceTest {
             queries=new DispatchPdaQueryService(new DispatchPdaReadRepository(new SqlSessionTemplate(factory.getObject()).getMapper(DispatchWholePdaReadMapper.class)),f.service);
             ReflectionTestUtils.setField(queries,"sources",sources);ReflectionTestUtils.setField(queries,"sourceRules",rules);
             when(sources.selectedPlan("101",1L)).thenReturn(List.of(f.candidates.get(1L)));
-            when(sources.receivedPlanCompleted(anyString(),anyLong())).thenReturn(true);
             when(sources.sourceOrders("101",null,1L)).thenReturn(List.of(9001L));
             when(sources.sourceOrders("101",501L,1L)).thenReturn(List.of(9001L));
             when(sources.stock("101",501L,false)).thenReturn(List.of(new Stock(11,21,501L,"9",3,0,0,0,1)));
             when(rules.selectionGroup(anyString(),any())).thenReturn(new DispatchPlanningModels.SelectionGroup(
                 "group","version",List.of(new DispatchPlanningModels.SelectionGroupSource(
                     selection,"PLAN:1","101","测试客户","INBOUND_PLAN","PLAN-1",3)),List.of(),true,List.of()));
-            if(twoPallets) {
-                for(int n=1;n<=2;n++) {
-                    long plan=n,pallet=500+n;int count=n==1?9:11;
-                    f.candidates.get(plan).packageCount(count);
-                    when(sources.selectedPlan("101",plan)).thenReturn(List.of(f.candidates.get(plan)));
-                    when(sources.sourceOrders("101",null,plan)).thenReturn(List.of(9000+plan));
-                    when(sources.sourceOrders("101",pallet,plan)).thenReturn(List.of(9000+plan));
-                    when(sources.stock("101",pallet,false)).thenReturn(List.of(new Stock(10+n,20+n,pallet,"9",count,0,0,0,1)));
-                }
-                when(rules.selectionGroup(anyString(),any())).thenAnswer(call->{
-                    var selected=(DispatchCommands.CargoSelection)call.getArgument(1);long plan=selected.planPalletId();
-                    return new DispatchPlanningModels.SelectionGroup("group","version",List.of(new DispatchPlanningModels.SelectionGroupSource(
-                        selected,"PLAN:"+plan,"101","测试客户","INBOUND_PLAN","PLAN-"+plan,plan==1?9:11)),List.of(),true,List.of());
-                });
-            }
         }
         /** 读取正式PDA入口。 */
         DispatchViews.PdaTask read(){return f.tx.execute(s->queries.task(new DispatchContracts.Actor("picker",ActorMode.PDA,"9"),number));}

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

@@ -1,47 +0,0 @@
-package com.baiyue.lastleg.dispatch.service;
-
-import com.baiyue.lastleg.dispatch.mapper.DispatchCandidatePageMapper;
-import com.baiyue.lastleg.dispatch.port.DispatchContracts.Actor;
-import com.baiyue.lastleg.dispatch.port.DispatchPlanningModels.CandidateQuery;
-import com.baiyue.lastleg.dispatch.port.DispatchTypes.ActorMode;
-import org.apache.ibatis.session.Configuration;
-import org.junit.jupiter.api.Test;
-import org.springframework.test.util.ReflectionTestUtils;
-import java.util.*;
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.*;
-
-/** 区域候选的读取范围与单仓写入职责分离，不依赖测试环境数据。 */
-class DispatchRegionalCandidatesTest {
-    /** 真实服务接受不指定仓的三种区域，保留服务端分页总数；非法仓和区域仍拒绝。 */
-    @Test void serviceAcceptsRegionalQueriesAndRejectsMalformedScopes() {
-        var sources=mock(DispatchService.class);var appointments=mock(DispatchAppointmentAllocations.class);
-        var service=new DispatchAggregateService(null,null,sources,null,null,null,new com.fasterxml.jackson.databind.ObjectMapper());
-        ReflectionTestUtils.setField(service,"appointments",appointments);
-        var actor=new Actor("7",ActorMode.PLATFORM,null);
-        when(sources.candidatePage(eq("7"),any())).thenReturn(new DispatchService.CandidatePage(List.of(),41));
-        when(sources.selectionGroups(List.of())).thenReturn(Map.of());when(appointments.candidates(List.of())).thenReturn(Map.of());
-        for(String tab:List.of("ALL","LAX","NYC")) {
-            var query=new CandidateQuery(null,null,null,null,null,null,2,20,tab);
-            var result=service.candidates(actor,query);
-            assertThat(result.total()).isEqualTo(41);assertThat(result.page()).isEqualTo(2);assertThat(result.pages()).isEqualTo(3);
-            verify(sources).candidatePage("7",query);
-        }
-        assertThatThrownBy(()->service.candidates(actor,new CandidateQuery("bad",null,null,null,null,null,1,20,"ALL"))).hasMessageContaining("起运仓筛选无效");
-        assertThatThrownBy(()->service.candidates(actor,new CandidateQuery(null,null,null,null,null,null,1,20,"bad"))).hasMessageContaining("仓库页签不合法");
-    }
-    /** 解析实际Mapper动态SQL，统计和分页采用相同区域条件，单仓消费者继续绑定真实仓。 */
-    @Test void countAndPageUseOptionalWarehouseAndTheSameRegionPredicate() {
-        var config=new Configuration();config.addMapper(DispatchCandidatePageMapper.class);
-        for(String method:List.of("count","page")) for(String tab:List.of("ALL","LAX","NYC")) for(String warehouse:List.of("ALL_WAREHOUSES","321")) {
-            var query=new CandidateQuery(warehouse.equals("321")?warehouse:null,null,null,null,null,null,1,20,tab);
-            var sql=config.getMappedStatement(DispatchCandidatePageMapper.class.getName()+"."+method).getBoundSql(Map.of("query",query,"offset",0)).getSql();
-            if(query.warehouseId()==null)assertThat(sql).doesNotContain("overseasWarehouseId=?");
-            else assertThat(sql).contains("overseasWarehouseId=?");
-            if(tab.equals("LAX"))assertThat(sql).contains("REGEXP 'lax|洛杉矶|los angeles'");
-            if(tab.equals("NYC"))assertThat(sql).contains("REGEXP 'nyc|jfk|");
-            if(tab.equals("ALL"))assertThat(sql).doesNotContain("REGEXP 'lax|", "REGEXP 'nyc|");
-            if(method.equals("page"))assertThat(sql).contains("LIMIT ? OFFSET ?");
-        }
-    }
-}

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

@@ -157,7 +157,7 @@ class DispatchRepairWorkflowTest {
         assertThat(created.dispatchNo()).isNotEqualTo("DP-1");
         var current=dispatch.detail(aggregateFixture.actor,created.dispatchNo());
         assertThat(current.actions().get(DispatchTypes.Action.CANCEL).allowed()).isTrue();
-        assertThat(current.actions()).doesNotContainKey(DispatchTypes.Action.ARRANGE_DELIVERY);
+        assertThat(current.actions().get(DispatchTypes.Action.ARRANGE_DELIVERY).allowed()).isFalse();
         assertThat(created.stage()).isEqualTo(DispatchTypes.Stage.BEFORE_LOADING);
         assertThat(db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_pallet_lock WHERE status='ACTIVE' AND dispatch_order_id<>1", Long.class)).isEqualTo(1);
         assertThat(db.queryForObject("SELECT dispatch_order_id FROM ll_dispatch_physical_pallet_lock WHERE active_warehouse_pallet_id=501",Long.class)).isEqualTo(aggregateFixture.repository.find(created.dispatchNo()).getId());

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

@@ -1,93 +0,0 @@
-package com.baiyue.lastleg.dispatch.service;
-
-import com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway;
-import com.baiyue.lastleg.dispatch.port.DispatchCommands;
-import com.baiyue.lastleg.dispatch.port.DispatchContracts;
-import org.junit.jupiter.api.Test;
-import org.springframework.test.util.ReflectionTestUtils;
-
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.mockito.Mockito.atLeastOnce;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.verify;
-
-/** 车辆维护保存司机照片后，真实资源快照、审核和原键恢复均保留相同引用。 */
-class DispatchResourcePhotosPersistenceTest {
-    /** 新字段缺省不改变升级前命令及审核依据的摘要，实际照片变化仍必须识别。 */
-    @Test void optionalPhotosPreserveLegacyHashesButBindActualReferences() throws Exception {
-        var f = new DispatchAggregatePersistenceTest.Fixture();
-        var input = f.configured("legacy-photos", List.of());
-        var request = update(input, 0L, "legacy-edit", List.of());
-        var oldJson = f.json.valueToTree(request);
-        ((com.fasterxml.jackson.databind.node.ObjectNode) oldJson.path("driver").path("evidence")).remove("photoFileIds");
-        var hashes = new DispatchCommandHasher(f.json);
-        var action = com.baiyue.lastleg.dispatch.port.DispatchTypes.Action.EDIT;
-        var oldHash = hashes.command(f.actor, action, "PC-OLD", 0L, oldJson);
-        assertThat(hashes.command(f.actor, action, "PC-OLD", 0L, request)).isEqualTo(oldHash);
-        assertThat(hashes.source(request)).isEqualTo(hashes.source(oldJson));
-        var withPhotos = update(input, 0L, "legacy-edit", List.of(401L, 402L));
-        assertThat(hashes.command(f.actor, action, "PC-OLD", 0L, withPhotos)).isNotEqualTo(oldHash)
-            .isEqualTo(hashes.command(f.actor, action, "PC-OLD", 0L, update(input, 0L, "legacy-edit", List.of(402L, 401L))));
-    }
-
-    /** 使用真实资源持久化与两级审核，防止车队资源规范化吞掉独立司机照片。 */
-    @Test void savedPhotosSurviveReplayAndBothReviews() throws Exception {
-        var f = new DispatchAggregatePersistenceTest.Fixture();
-        var input = f.configured("photos-create", List.of(f.source(1, "101", 501, "ONT8", 3)));
-        var created = f.tx.execute(t -> f.service.create(f.actor, input));
-        var request = update(input, created.recordVersion(), "photos-save", List.of(401L));
-        var saved = f.tx.execute(t -> f.service.update(f.actor, created.dispatchNo(), request));
-        assertThat(f.tx.execute(t -> f.service.update(f.actor, created.dispatchNo(), request)).replayed()).isTrue();
-        var approved = f.approve(saved);
-        var detail = f.tx.execute(t -> f.service.detail(f.actor, created.dispatchNo()));
-        assertThat(detail.vehicleInfo().driver().evidence().photoFileIds()).containsExactly(401L);
-        assertThat(detail.vehicleInfo().driver().evidence().fileIds()).containsExactly(202L);
-        verify(gateway(f), atLeastOnce()).metadata(f.repository.find(created.dispatchNo()).getId(), DispatchEvidenceGateway.Kind.DRIVER_PHOTO, 401L);
-        assertThat(approved.recordVersion()).isGreaterThan(saved.recordVersion());
-    }
-
-    /** 错车或错类附件失败时，事务不得覆盖原资源、推进版本或留下成功命令。 */
-    @Test void foreignPhotoCannotChangeSavedResources() throws Exception {
-        var f = new DispatchAggregatePersistenceTest.Fixture();
-        var input = f.configured("foreign-photo-create", List.of(f.source(1, "101", 501, "ONT8", 3)));
-        var created = f.tx.execute(t -> f.service.create(f.actor, input));
-        var before = f.db.queryForMap("SELECT resources_json,record_version FROM ll_dispatch_order WHERE dispatch_no=?", created.dispatchNo());
-        doThrow(new IllegalArgumentException("本车分类归属不匹配")).when(gateway(f))
-            .metadata(f.repository.find(created.dispatchNo()).getId(), DispatchEvidenceGateway.Kind.DRIVER_PHOTO, 401L);
-        var request = update(input, created.recordVersion(), "foreign-photo-save", List.of(401L));
-        assertThatThrownBy(() -> f.tx.execute(t -> f.service.update(f.actor, created.dispatchNo(), request)))
-            .hasMessageContaining("归属不匹配");
-        assertThat(f.db.queryForMap("SELECT resources_json,record_version FROM ll_dispatch_order WHERE dispatch_no=?", created.dispatchNo())).isEqualTo(before);
-        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_command WHERE idempotency_key='foreign-photo-save'", Long.class)).isZero();
-    }
-
-    /** 编辑清空照片必须真实持久化；历史资源缺该字段时仍按空集合读取。 */
-    @Test void photosCanBeRemovedAndOldSnapshotsRemainReadable() throws Exception {
-        var f = new DispatchAggregatePersistenceTest.Fixture();
-        var input = f.configured("remove-photo-create", List.of());
-        var created = f.tx.execute(t -> f.service.create(f.actor, input));
-        var saved = f.tx.execute(t -> f.service.update(f.actor, created.dispatchNo(), update(input, created.recordVersion(), "add-photo", List.of(401L))));
-        f.tx.execute(t -> f.service.update(f.actor, created.dispatchNo(), update(input, saved.recordVersion(), "remove-photo", List.of())));
-        assertThat(f.tx.execute(t -> f.service.detail(f.actor, created.dispatchNo())).vehicleInfo().driver().evidence().photoFileIds()).isEmpty();
-        var legacy = f.json.readValue("{\"licenseNo\":\"TEST\",\"fileIds\":[202]}", DispatchContracts.DriverEvidence.class);
-        assertThat(legacy.photoFileIds()).isEmpty();
-        assertThat(legacy.fileIds()).containsExactly(202L);
-    }
-
-    /** 仅替换司机照片，保留车辆、驾驶证和计划字段。 */
-    private static DispatchCommands.Update update(DispatchCommands.Create input, long version, String key, List<Long> photos) {
-        var d = input.driver();
-        var e = d.evidence();
-        var driver = new DispatchCommands.Driver(d.mode(), d.driverId(), d.name(), d.phone(),
-            new DispatchContracts.DriverEvidence(e.licenseNo(), e.licenseExpiresOn(), e.fileIds(), e.expectedTaskEndAt(), photos));
-        return new DispatchCommands.Update(version, key, input.vehicle(), driver, input.plannedDepartureAt(), input.estimatedArrivalAt(), "维护照片");
-    }
-
-    /** 只替代外部附件提供者，资源、命令和事务仍走真实服务。 */
-    private static DispatchEvidenceGateway gateway(DispatchAggregatePersistenceTest.Fixture f) {
-        return (DispatchEvidenceGateway) ReflectionTestUtils.getField(f.service, "evidence");
-    }
-}

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

@@ -11,32 +11,6 @@ import static org.assertj.core.api.Assertions.*;
 
 /** 审核两端共用真实持久主单，驳回回客服且不能复用上一轮批准。 */
 class DispatchReviewWorkflowPersistenceTest {
-    /** 取货复用同轮两级审核与驳回重提，不创建仓内拣货任务。 */
-    @Test void pickupUsesBothReviewsAndRejectsSkippingOrStaleApproval() throws Exception {
-        var f=new DispatchAggregatePersistenceTest.Fixture();
-        var created=f.tx.execute(s->f.service.create(f.actor,f.configured("pickup-review",List.of(f.source(1,"101",501,"ONT8",3)))));
-        f.db.update("UPDATE ll_dispatch_order SET task_type='PICKUP' WHERE dispatch_no=?",created.dispatchNo());
-        var transport=org.mockito.Mockito.mock(com.baiyue.lastleg.dispatch.transport.TransportTaskService.class);
-        var trip=new com.baiyue.lastleg.fleet.trip.FleetTripEntity();trip.setStopsJson("[]");
-        org.mockito.Mockito.when(transport.transport(org.mockito.ArgumentMatchers.eq(created.dispatchNo()),org.mockito.ArgumentMatchers.anyBoolean())).thenReturn(trip);
-        org.springframework.test.util.ReflectionTestUtils.setField(f.service,"transportTasks",transport);
-        var submitted=submit(f,created,"pickup-submit");assertQueue(f,created.dispatchNo(),BeforeLoadingSection.DISPATCH_REVIEW);
-        assertThatThrownBy(()->review(f,f.actor,submitted,true,"skip",Decision.APPROVED,null)).hasMessageContaining("状态已变化");
-        var approved=review(f,f.actor,submitted,false,"pickup-dispatch",Decision.APPROVED,null);
-        assertQueue(f,created.dispatchNo(),BeforeLoadingSection.LOADING_REVIEW);
-        var rejected=review(f,f.actor,approved,true,"pickup-reject",Decision.REJECTED,"车辆不符");
-        assertQueue(f,created.dispatchNo(),BeforeLoadingSection.VEHICLE_INFO);
-        var next=submit(f,rejected,"pickup-resubmit");
-        var nextApproved=review(f,f.actor,next,false,"pickup-dispatch-2",Decision.APPROVED,null);
-        var loaded=review(f,f.actor,nextApproved,true,"pickup-loading-2",Decision.APPROVED,null);
-        assertThat(loaded.stage()).isEqualTo(Stage.LOADING);
-        var row=f.repository.find(created.dispatchNo());
-        assertThat(row.getReviewState()).isEqualTo("APPROVED");
-        assertThat(f.service.actions(f.actor,row).get(Action.PICK).allowed()).isFalse();
-        assertThat(f.service.actions(f.actor,row).get(Action.LOADING_COMPLETE).allowed()).isFalse();
-        assertThat(f.repository.outbounds(row.getId())).isEmpty();
-        org.mockito.Mockito.verify(transport,org.mockito.Mockito.times(5)).verifyPickupReview(created.dispatchNo());
-    }
     /** 客服、调度、理货队列互斥，任一级驳回都只回客服队列。 */
     @Test void eachReviewRejectionReturnsOnlyToCustomerServiceQueue() throws Exception {
         var f=new DispatchAggregatePersistenceTest.Fixture();

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

@@ -15,35 +15,6 @@ import static org.mockito.ArgumentMatchers.*;
 import static org.assertj.core.api.Assertions.*;
 
 class TransportTaskProjectionTest {
-    /** 已出发也不能跳过照片阶段，全部取货照片确认后才进入派送中。 */
-    @Test void oldDepartureDoesNotSkipPickupPhotosStage() {
-        var roots=mock(DispatchAggregateRepository.class);var links=mock(TransportTaskRepository.class);var pickups=mock(com.baiyue.lastleg.fleet.pickup.FleetPickupRepository.class);
-        var projection=new TransportTaskProjection(roots,links,mock(UsTruckOrderRepository.class),mock(DispatchNumberGenerator.class),new ObjectMapper().findAndRegisterModules());
-        org.springframework.test.util.ReflectionTestUtils.setField(projection,"pickupFacts",pickups);
-        var root=new DispatchAggregate();root.setId(2L);root.setDispatchNo("PC1");root.setTaskType("PICKUP");root.setRecordVersion(10L);root.setStage("LOADING");
-        var task=new com.baiyue.lastleg.fleet.pickup.FleetPickupTask();task.setStatus("ASSIGNED");
-        when(links.byTrip(1L)).thenReturn(root);when(roots.lock("PC1")).thenReturn(root);when(roots.saveState(eq(root),anyLong())).thenReturn(1);when(pickups.tasks("TR1")).thenReturn(java.util.List.of(task));
-        var trip=new FleetTripEntity();trip.setId(1L);trip.setTripNo("TR1");trip.setTripPurpose("PICKUP");trip.setStatus("IN_TRANSIT");
-        projection.changed(new TransportTripChanged(trip,"PICKUP_DEPART","出发","OP"));assertThat(root.getStage()).isEqualTo("LOADING");
-        task.setStatus("PICKED");projection.changed(new TransportTripChanged(trip,"PICKUP_PICKED","照片核齐","OP"));assertThat(root.getStage()).isEqualTo("DELIVERING");
-        trip.setStatus("COMPLETED");projection.changed(new TransportTripChanged(trip,"PICKUP_ARRIVED","到仓照片核齐","OP"));assertThat(root.getStage()).isEqualTo("DELIVERED");
-    }
-    /** 审核推进后车次版本可能较小，换车仍须递增主单版本并作废两级审核。 */
-    @Test void pickupResourceChangeInvalidatesApprovalWithoutRegressingVersion() throws Exception {
-        var roots=mock(DispatchAggregateRepository.class);var links=mock(TransportTaskRepository.class);
-        var json=new ObjectMapper().findAndRegisterModules();
-        var projection=new TransportTaskProjection(roots,links,mock(UsTruckOrderRepository.class),mock(DispatchNumberGenerator.class),json);
-        var root=new DispatchAggregate();root.setId(2L);root.setDispatchNo("PC1");root.setTaskType("PICKUP");root.setStatus("ACTIVE");root.setStage("LOADING");root.setRecordVersion(10L);root.setReviewRound(1L);root.setReviewState("APPROVED");root.setReviewBasisHash("basis");root.setResourcesJson("{}");
-        var review=new com.baiyue.lastleg.dispatch.port.DispatchContracts.Review(com.baiyue.lastleg.dispatch.port.DispatchTypes.ReviewStatus.APPROVED,null,"OP",java.time.Instant.now(),1,"basis",null,null);
-        root.setDispatchReviewJson(json.writeValueAsString(review));root.setLoadingReviewJson(json.writeValueAsString(review));
-        when(links.byTrip(1L)).thenReturn(root);when(roots.lock("PC1")).thenReturn(root);when(roots.saveState(root,10L)).thenReturn(1);
-        assertThatCode(()->projection.requireApproved(1L)).doesNotThrowAnyException();
-        var trip=new FleetTripEntity();trip.setId(1L);trip.setTripPurpose("PICKUP");trip.setStatus("PLANNED");trip.setRecordVersion(4L);trip.setUpdatedAt(LocalDateTime.now());
-        projection.changed(new TransportTripChanged(trip,"ASSIGN","换车","OP"));
-        assertThat(root.getRecordVersion()).isEqualTo(11L);assertThat(root.getReviewState()).isEqualTo("DRAFT");assertThat(root.getStage()).isEqualTo("BEFORE_LOADING");
-        assertThatThrownBy(()->projection.requireApproved(1L)).hasMessageContaining("调度审核和理货员审核");
-        verify(roots).saveState(root,10L);
-    }
     /** 旧取消入口产生的运输事实也必须撤销原单安排和资源投影。 */
     @Test void legacyCancellationSynchronizesDispatchAndUnlocksSource(){
         var roots=mock(DispatchAggregateRepository.class);var links=mock(TransportTaskRepository.class);var trucks=mock(UsTruckOrderRepository.class);

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

@@ -58,30 +58,6 @@ class TransportTaskServiceTest {
     @Test void evidenceDownloadRequiresPersistedConfirmation(){
         assertThatThrownBy(()->service.evidence("PC1",77L)).hasMessageContaining("没有该完成凭证");verifyNoInteractions(files);
     }
-    /** 只对审核通过的上门取货生成排车，已有及取消任务都不得重建。 */
-    @Test void approvalCreatesOnlyEligibleUnassignedPickup() {
-        var facts=mock(FleetPickupRepository.class);
-        var subject=spy(new TransportTaskService(roots,links,mock(TransportTaskProjection.class),tripRepo,trips,
-            mock(FleetPickupService.class),facts,trucks,mock(FleetPoolOrderQueries.class),mock(DriverService.class),
-            mock(FleetTransportVehicleGuard.class),files,new ObjectMapper().findAndRegisterModules()));
-        var source=new FleetPickupSource();source.setId(42L);source.setTransferNo("ZY1");source.setInboundCode("ZY1");
-        source.setDeliveryMethod("WAREHOUSE_PICKUP");source.setStatus("WAIT_PDA_RECEIVING");
-        when(facts.source("C1","ZY1",true)).thenReturn(source);
-        doReturn(null).when(subject).createPickup(anyString(),any());
-        subject.ensureApprovedPickup("C1","ZY1","OP");
-        var request=org.mockito.ArgumentCaptor.forClass(FleetPickupModels.Create.class);
-        verify(subject).createPickup(eq("OP"),request.capture());
-        assertThat(request.getValue().sources()).containsExactly(new FleetPickupModels.Source("C1","ZY1"));
-        assertThat(request.getValue().idempotencyKey()).isEqualTo("transfer-approval:42");
-        assertThat(request.getValue().expectedDriverEndAt()).isAfter(request.getValue().plannedDepartureAt());
-        clearInvocations(subject);
-        when(facts.lockTask(42L)).thenReturn(new FleetPickupTask());
-        subject.ensureApprovedPickup("C1","ZY1","OP2");
-        verify(subject,never()).createPickup(anyString(),any());
-        source.setDeliveryMethod("CUSTOMER_DELIVERY");clearInvocations(facts);
-        subject.ensureApprovedPickup("C1","ZY1","OP");
-        verify(facts,never()).lockTask(anyLong());
-    }
     /** 构造固定版本的测试执行命令。 */
     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/ownedbusiness/DispatchVehicleDocumentTest.java

@@ -1,76 +0,0 @@
-package com.baiyue.lastleg.fleet.ownedbusiness;
-
-import com.baiyue.common.core.exception.BizException;
-import com.baiyue.lastleg.dispatch.port.DispatchDetailReader;
-import com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessModels.*;
-import com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessScope;
-import com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessRows;
-import com.baiyue.lastleg.fleet.ownedbusiness.repository.OwnedBusinessRepository;
-import com.baiyue.lastleg.fleet.ownedbusiness.service.*;
-import com.baiyue.lastleg.fleet.outsourcedbusiness.service.OutsourcedBusinessService;
-import com.baiyue.lastleg.fleet.ownedbusiness.controller.DispatchVehicleDocumentController;
-import com.baiyue.lastleg.fleet.ownedbusiness.gateway.OwnedBusinessFileGateway;
-import org.springframework.security.access.prepost.PreAuthorize;
-import org.springframework.web.server.ResponseStatusException;
-import org.junit.jupiter.api.Test;
-import java.util.*;
-import static org.junit.jupiter.api.Assertions.*;
-import static org.mockito.Mockito.*;
-
-/** 排车资料复用同一车辆照片记录，不扩大旧入口或改变履约状态。 */
-class DispatchVehicleDocumentTest {
-    /** 无拼车和实际拼车都能在派送后读取；原车队分类和冻结装车门禁继续生效。 */
-    @Test void dispatchScopeAcceptsBothCargoGroupsOnlyAfterDeparture() {
-        var repo=mock(OwnedBusinessRepository.class);var codec=OwnedBusinessFixtures.codec();
-        var queries=new OwnedBusinessQueryService(repo,new OwnedBusinessProjection(codec),codec,mock(DispatchDetailReader.class));
-        var source=OwnedBusinessFixtures.source();when(repo.source(source.getDispatchNo())).thenReturn(source);
-        assertThrows(BizException.class,()->queries.requireScoped(source.getDispatchNo(),OwnedBusinessScope.DISPATCH));
-        for(boolean pooled:List.of(false,true))for(String stage:List.of("DELIVERING","DELIVERED")) {
-            source.setPooledCargo(pooled);source.setStage(stage);
-            assertSame(source,queries.requireScoped(source.getDispatchNo(),OwnedBusinessScope.DISPATCH));
-        }
-        assertThrows(BizException.class,()->queries.requireOwned(source.getDispatchNo()));
-        source.setOwnedLoadingCompletionHash("other-load");
-        assertThrows(BizException.class,()->queries.requireScoped(source.getDispatchNo(),OwnedBusinessScope.DISPATCH));
-        verify(repo,never()).update(any(),anyLong());
-    }
-    /** 排车入口只接受油耗图片；签收和装车文件仍走派送单，旧外配仍不能上传油耗。 */
-    @Test void scopesKeepIndependentWritePermissionsAndPhotoCategories() {
-        var scope=OwnedBusinessScope.DISPATCH;
-        assertEquals("platform:overseas-warehouse:dispatch:list",scope.listPermission());
-        assertEquals("platform:overseas-warehouse:dispatch:edit",scope.uploadPermission());
-        for(var slot:PhotoSlot.values()) {
-            if(slot.category().equals("FUEL")) { assertDoesNotThrow(()->scope.requireSlot(slot));assertThrows(BizException.class,()->OwnedBusinessScope.OUTSOURCED.requireSlot(slot)); }
-            else assertThrows(BizException.class,()->scope.requireSlot(slot));
-        }
-        var actor=new Actor("reader","只读",Set.of(scope.listPermission()));
-        var row=new OwnedBusinessProjection(OwnedBusinessFixtures.codec()).row(OwnedBusinessFixtures.source(),null,OwnedBusinessFixtures.cargo(),List.of(),actor,scope);
-        assertFalse(row.actions().upload().allowed());
-    }
-    /** 油耗与车队装车照片共存，排车补充油耗不破坏外配业务读取。 */
-    @Test void sharedFuelPhotosDoNotInvalidateOutsourcedProjection() {
-        var codec=OwnedBusinessFixtures.codec();var record=new OwnedBusinessRows.Record();record.setRecordVersion(3L);record.setArrivalsJson("[]");
-        record.setPhotosJson(codec.write(List.of(new Photo(PhotoSlot.FUEL_START,"FUEL","77","fuel.png","image/png","9","2026-10-21T00:00:00Z","2026-10-21T00:00:00Z"))));
-        var projection=new OwnedBusinessProjection(codec);var source=OwnedBusinessFixtures.source();source.setPooledCargo(true);source.setStage("DELIVERED");
-        var row=projection.row(source,record,OwnedBusinessFixtures.cargo(),List.of(),OwnedBusinessFixtures.actor(),OwnedBusinessScope.OUTSOURCED);
-        assertEquals(1,row.photoSummary().fuelCount());assertEquals("3",row.recordVersion());assertEquals(8L,source.getRecordVersion());assertEquals("DELIVERED",source.getStage());
-        assertEquals("77",projection.photos(record).get(0).fileId());
-        var queries=mock(OwnedBusinessQueryService.class);
-        when(queries.detail(any(),eq(source.getDispatchNo()),eq(OwnedBusinessScope.OUTSOURCED)))
-            .thenReturn(new Detail(row,null,List.of(),projection.photos(record)));
-        var outsourced=new OutsourcedBusinessService(queries,mock(OwnedBusinessRecordService.class),mock(OwnedBusinessPhotoService.class),projection,codec);
-        assertTrue(outsourced.detail(OwnedBusinessFixtures.actor(),source.getDispatchNo()).photos().isEmpty());
-    }
-    /** 新入口读写权限独立；服务层同样拒绝仅查看账号和车队权限绕入。 */
-    @Test void controllerAndPhotoServiceKeepDispatchWriteBoundary() throws Exception {
-        assertEquals("hasAuthority('platform:overseas-warehouse:dispatch:list')",Arrays.stream(DispatchVehicleDocumentController.class.getMethods())
-            .filter(m->m.getName().equals("get")).findFirst().orElseThrow().getAnnotation(PreAuthorize.class).value());
-        for(String name:List.of("upload","bind","recover"))assertEquals("hasAuthority('platform:overseas-warehouse:dispatch:edit')",Arrays.stream(DispatchVehicleDocumentController.class.getMethods())
-            .filter(m->m.getName().equals(name)).findFirst().orElseThrow().getAnnotation(PreAuthorize.class).value());
-        var queries=mock(OwnedBusinessQueryService.class);var repo=mock(OwnedBusinessRepository.class);var files=mock(OwnedBusinessFileGateway.class);var codec=OwnedBusinessFixtures.codec();
-        var service=new OwnedBusinessPhotoService(queries,mock(OwnedBusinessRecordService.class),repo,mock(OwnedBusinessCommandService.class),new OwnedBusinessProjection(codec),codec,files);
-        for(var actor:List.of(new Actor("read","只读",Set.of(OwnedBusinessScope.DISPATCH.listPermission())),OwnedBusinessFixtures.actor()))
-            assertThrows(ResponseStatusException.class,()->service.upload(actor,"PC-1",PhotoSlot.FUEL_START,"upload-original",null,OwnedBusinessScope.DISPATCH));
-        verifyNoInteractions(files,repo,queries);
-    }
-}

lastleg-service/src/test/java/com/baiyue/lastleg/fleet/pickup/FleetPickupMapperTest.java

@@ -60,12 +60,4 @@ class FleetPickupMapperTest {
         db.update("INSERT INTO ll_fleet_pickup_task VALUES(1,'C1','WT-1','TR-1','PICKED',CURRENT_TIMESTAMP)");
         assertThat(mapper.unassign("TR-1")).isZero();assertThat(mapper.task(1L).getTripNo()).isEqualTo("TR-1");
     }
-    /** 联动取消保留原车次身份，已取货成员不能被取消SQL覆盖。 */
-    @Test void cancellationKeepsSourceLinkAndDoesNotRewritePickedFacts() {
-        db.update("INSERT INTO ll_fleet_pickup_task VALUES(1,'C1','WT-1','TR-1','ASSIGNED',CURRENT_TIMESTAMP)");
-        db.update("INSERT INTO ll_fleet_pickup_task VALUES(6,'C6','WT-6','TR-1','PICKED',CURRENT_TIMESTAMP)");
-        assertThat(mapper.cancelTasks("TR-1")).isEqualTo(1);
-        assertThat(mapper.task(1L).getTripNo()).isEqualTo("TR-1");assertThat(mapper.task(1L).getStatus()).isEqualTo("CANCELLED");
-        assertThat(mapper.task(6L).getStatus()).isEqualTo("PICKED");assertThat(mapper.cancelTasks("TR-1")).isZero();
-    }
 }

lastleg-service/src/test/java/com/baiyue/lastleg/fleet/pickup/FleetPickupServiceTest.java

@@ -15,15 +15,11 @@ import static org.mockito.ArgumentMatchers.*;
 
 class FleetPickupServiceTest {
     FleetPickupRepository repository;FleetTripService trips;FleetPickupService service;
-    PickupDepartureReview departureReview;
-    DriverService drivers;VehicleRepository vehicles;
     TripOperationsEvidenceGateway files;FleetTripEntity trip;FleetPickupSource source;FleetPickupTask task;
     final Map<String,String> commands=new HashMap<>();
     @BeforeEach void setup() {
         repository=mock(FleetPickupRepository.class);trips=mock(FleetTripService.class);files=mock(TripOperationsEvidenceGateway.class);
-        departureReview=mock(PickupDepartureReview.class);
-        drivers=mock(DriverService.class);vehicles=mock(VehicleRepository.class);
-        service=new FleetPickupService(repository,trips,mock(FleetWarehouseDirectory.class),drivers,vehicles,files,new ObjectMapper().findAndRegisterModules(),departureReview);
+        service=new FleetPickupService(repository,trips,mock(FleetWarehouseDirectory.class),mock(DriverService.class),mock(VehicleRepository.class),files,new ObjectMapper().findAndRegisterModules());
         trip=new FleetTripEntity();trip.setId(9L);trip.setTripNo("TR-1");trip.setTripPurpose("PICKUP");trip.setStatus("IN_TRANSIT");trip.setWarehouseId(100L);trip.setRecordVersion(2L);
         source=source(1L,"C1","WT-1","100");task=new FleetPickupTask();task.setTransferOrderId(1L);task.setCustomerId("C1");task.setTransferNo("WT-1");task.setTripNo("TR-1");task.setStatus("ASSIGNED");
         when(repository.trip("TR-1",true)).thenReturn(trip);when(repository.trip("TR-1",false)).thenReturn(trip);
@@ -33,29 +29,6 @@ class FleetPickupServiceTest {
         doAnswer(c->{commands.put(c.getArgument(1),c.getArgument(2));return null;}).when(repository).command(anyString(),anyString(),anyString());
         doAnswer(c->{trip.setRecordVersion(trip.getRecordVersion()+1);return null;}).when(trips).recordExecution(any(),anyLong(),anyString(),anyString(),anyString());
     }
-    /** 审核完成后直接在装货阶段上传取货照片，全车核齐自动进入派送。 */
-    @Test void pickupPhotosStartDeliveryWithoutSeparateDeparture() {
-        trip.setStatus("PLANNED");trip.setVehicleId(20L);trip.setDriverId(30L);trip.setExpectedDriverEndAt(LocalDateTime.now(ZoneOffset.UTC).plusDays(1));
-        when(repository.ownsResources(9L,20L,30L)).thenReturn(true);
-        var vehicle=mock(VehicleRepository.VehicleSnapshot.class);when(vehicle.region()).thenReturn("OVERSEAS");when(vehicle.status()).thenReturn("IN_SERVICE");when(vehicles.lockById(20L)).thenReturn(Optional.of(vehicle));
-        var driver=mock(DriverModels.Response.class);var details=mock(DriverModels.Draft.class);when(details.region()).thenReturn("OVERSEAS");when(driver.details()).thenReturn(details);when(drivers.requireDispatchable(eq(30L),any())).thenReturn(driver);
-        when(repository.ownsUpload(1L,"TR-1",88L)).thenReturn(true);
-        when(files.metadata(9L,88L)).thenReturn(new TripOperationsRecordModels.EvidenceFile("88","取货照片.jpg","image/jpeg",500));
-        var request=new FleetPickupModels.Pickup(2L,"pickup-photo-key",5,List.of(88L),null);
-        service.picked("TR-1","C1","WT-1","OP",request);
-        assertThat(task.getStatus()).isEqualTo("PICKED");assertThat(trip.getStatus()).isEqualTo("IN_TRANSIT");assertThat(trip.getDepartedAt()).isNotNull();
-        verify(departureReview).requireApproved(9L);verify(trips,times(1)).recordExecution(any(),eq(2L),eq("PICKUP_PICKED"),anyString(),eq("OP"));
-        service.picked("TR-1","C1","WT-1","OP",request);verify(repository,times(1)).update(task);
-    }
-    /** 原车队发车接口不能在两级审核未通过时写入实际发车事实。 */
-    @Test void legacyDepartureCannotBypassReview() {
-        trip.setStatus("PLANNED");
-        doThrow(new IllegalStateException("请先完成两级审核")).when(departureReview).requireApproved(9L);
-        assertThatThrownBy(()->service.depart("TR-1","OP",new FleetPickupModels.Command(2L,"depart-review-key","发车"))).hasMessageContaining("两级审核");
-        assertThat(trip.getStatus()).isEqualTo("PLANNED");assertThat(trip.getDepartedAt()).isNull();
-        verify(trips,never()).recordExecution(any(),anyLong(),anyString(),anyString(),anyString());
-        assertThat(commands).isEmpty();
-    }
     /** 原单所属域锁定来源后，车队仅以该来源核对真实送仓事实。 */
     @Test void pickupMustArriveBeforePda() {
         assertThatThrownBy(()->service.requireArrived(1L,"WAREHOUSE_PICKUP","WT-1","WT-1")).hasMessageContaining("先完成车辆取货送仓");
@@ -106,23 +79,10 @@ class FleetPickupServiceTest {
     }
     @Test void arrivalOpensPdaAndCompletionKeepsWarehouseOrderInMeasurement() {
         task.setStatus("PICKED");task.setActualPackages(5);task.setPickedAt(LocalDateTime.now(ZoneOffset.UTC));
-        when(repository.ownsUpload(1L,"TR-1",89L)).thenReturn(true);
-        when(files.metadata(9L,89L)).thenReturn(new TripOperationsRecordModels.EvidenceFile("89","到仓照片.jpg","image/jpeg",500));
-        var request=new FleetPickupModels.Command(2L,"arrive-key-1","已送海外仓月台",List.of(89L));
-        service.arrive("TR-1","C1","WT-1","OP",request);
+        service.arrive("TR-1","C1","WT-1","OP",new FleetPickupModels.Command(2L,"arrive-key-1","已送海外仓月台"));
         assertThat(task.getStatus()).isEqualTo("ARRIVED");assertThat(source.getStatus()).isEqualTo("WAIT_PDA_RECEIVING");
-        assertThat(trip.getStatus()).isEqualTo("COMPLETED");assertThat(trip.getCompletionJson()).contains("arrive-key-1");assertThat(source.getStatus()).isEqualTo("WAIT_PDA_RECEIVING");
-        assertThat(task.getEvidenceJson()).contains("ARRIVAL","到仓照片");
-        service.arrive("TR-1","C1","WT-1","OP",request);verify(repository,times(1)).update(task);
-    }
-    /** 到仓必须上传独立的新照片，不能用取货照片冒充或提前开放清点。 */
-    @Test void arrivalRequiresFreshPhotoEvidence() {
-        task.setStatus("PICKED");
-        task.setEvidenceJson("[{\"fileId\":\"88\",\"fileName\":\"取货.jpg\",\"contentType\":\"image/jpeg\",\"sizeBytes\":1,\"phase\":\"PICKUP\"}]");
-        assertThatThrownBy(()->service.arrive("TR-1","C1","WT-1","OP",new FleetPickupModels.Command(2L,"no-photo","送仓"))).hasMessageContaining("上传到仓照片");
-        when(repository.ownsUpload(1L,"TR-1",88L)).thenReturn(true);
-        assertThatThrownBy(()->service.arrive("TR-1","C1","WT-1","OP",new FleetPickupModels.Command(2L,"same-photo","送仓",List.of(88L)))).hasMessageContaining("不能复用取货照片");
-        assertThat(task.getStatus()).isEqualTo("PICKED");verify(repository,never()).update(any());
+        service.complete("TR-1","OP",new FleetPickupModels.Command(3L,"complete-key-1","全部送仓"));
+        assertThat(trip.getStatus()).isEqualTo("COMPLETED");assertThat(trip.getCompletionJson()).contains("complete-key-1");assertThat(source.getStatus()).isEqualTo("WAIT_PDA_RECEIVING");
     }
     @Test void staleVersionAndWrongTripPurposeAreRejected() {
         assertThatThrownBy(()->service.arrive("TR-1","C1","WT-1","OP",new FleetPickupModels.Command(1L,"arrive-key-1","送仓"))).hasMessageContaining("车次已变化");

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

@@ -122,8 +122,6 @@ class FleetTripAuthorizationTest {
         @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.pickup.PickupOrderCancellation pickupCancellation() { return mock(com.baiyue.lastleg.fleet.pickup.PickupOrderCancellation.class); }
         @Bean com.baiyue.lastleg.fleet.trip.work.AppointmentWorkTripChanges workTripChanges() { return mock(com.baiyue.lastleg.fleet.trip.work.AppointmentWorkTripChanges.class); }
         @Bean com.baiyue.lastleg.appointmentwork.AppointmentWorkDispatchPort workDispatches() { return mock(com.baiyue.lastleg.appointmentwork.AppointmentWorkDispatchPort.class); }
         @Bean FleetTripCalendarService calendar() { return mock(FleetTripCalendarService.class); }

lastleg-service/src/test/java/com/baiyue/lastleg/pda/PdaOperationsOpenApiContractTest.java

@@ -75,6 +75,7 @@ class PdaOperationsOpenApiContractTest {
             "/api/pda/v1/last-leg/dispatches/{dispatchNo}/loading:",
             "/api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-complete:",
             "/api/pda/v1/last-leg/dispatches/{dispatchNo}/commands/{idempotencyKey}:",
+            "/api/pda/v1/last-leg/dispatches/{dispatchNo}/depart:",
             "/api/pda/v1/last-leg/outbound-tasks:",
             "/api/pda/v1/last-leg/outbound-tasks/resolve/{businessNo}:",
             "/api/pda/v1/last-leg/outbound-tasks/{taskNo}:",
@@ -82,8 +83,7 @@ class PdaOperationsOpenApiContractTest {
             "/api/pda/v1/last-leg/outbound-tasks/{taskNo}/pallets/{palletNo}/pick:",
             "/api/pda/v1/last-leg/outbound-tasks/{taskNo}/complete:");
         for (String path : paths) assertTrue(yaml.contains(path), path);
-        assertEquals(35, paths.size());
-        assertFalse(yaml.contains("/api/pda/v1/last-leg/dispatches/{dispatchNo}/depart:"));
+        assertEquals(36, paths.size());
         assertFalse(yaml.contains("/api/pda/v1/last-leg/dispatches/{dispatchNo}/complete:"));
         assertTrue(yaml.contains("enum: [LOCATION, PALLET]"));
         assertTrue(yaml.contains("enum: [APPROVE, REWORK]"));

lastleg-service/src/test/java/com/baiyue/lastleg/transfer/service/TransferPickupCancellationPersistenceTest.java

@@ -1,62 +0,0 @@
-package com.baiyue.lastleg.transfer.service;
-
-import com.baomidou.mybatisplus.core.MybatisConfiguration;
-import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
-import com.baiyue.lastleg.fleet.pickup.FleetPickupModels;
-import com.baiyue.lastleg.transfer.mapper.TransferPickupCancellationMapper;
-import com.baiyue.lastleg.transfer.repository.TransferPickupCancellationRepository;
-import org.h2.jdbcx.JdbcDataSource;
-import org.mybatis.spring.SqlSessionTemplate;
-import org.junit.jupiter.api.*;
-import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.datasource.DataSourceTransactionManager;
-import org.springframework.transaction.support.TransactionTemplate;
-import java.util.List;
-import static org.assertj.core.api.Assertions.*;
-
-/** 通过真实SQL验证联动取消、客户隔离以及多票失败回滚。 */
-class TransferPickupCancellationPersistenceTest {
-    JdbcTemplate db;TransactionTemplate tx;TransferPickupCancellationService service;
-    /** 每例建立隔离库，保留取消所需真实字段和状态约束。 */
-    @BeforeEach void setup() throws Exception {
-        var ds=new JdbcDataSource();ds.setURL("jdbc:h2:mem:pickup_cancel_"+System.nanoTime()+";MODE=MySQL;DB_CLOSE_DELAY=-1");db=new JdbcTemplate(ds);tx=new TransactionTemplate(new DataSourceTransactionManager(ds));
-        db.execute("CREATE TABLE ll_warehouse_transfer_order(id BIGINT PRIMARY KEY,customer_id VARCHAR(64),transfer_no VARCHAR(64),inbound_code VARCHAR(64),lastleg_order_id BIGINT,inbound_order_id BIGINT,delivery_method VARCHAR(40),status VARCHAR(32),updated_at TIMESTAMP)");
-        db.execute("CREATE TABLE ll_order(id BIGINT PRIMARY KEY,customer_id VARCHAR(64),current_status VARCHAR(40),sub_order_status VARCHAR(255),version INT,updated_at TIMESTAMP)");
-        db.execute("CREATE TABLE ll_inbound_order(id BIGINT PRIMARY KEY,customer_id VARCHAR(64),status VARCHAR(40),updated_at TIMESTAMP)");
-        db.execute("CREATE TABLE ll_inbound_plan(id BIGINT PRIMARY KEY,customer_id VARCHAR(64),source_order_id BIGINT,creation_mode VARCHAR(40),status VARCHAR(40),version INT,updated_at TIMESTAMP)");
-        db.execute("CREATE TABLE ll_loading_order_status_history(customer_id VARCHAR(64),order_id BIGINT,from_status VARCHAR(40),to_status VARCHAR(40),event_id VARCHAR(64),remark VARCHAR(1000),created_at TIMESTAMP)");
-        db.execute("CREATE TABLE ll_warehouse_transfer_receipt(customer_id VARCHAR(64),transfer_order_id BIGINT)");
-        db.execute("CREATE TABLE ll_warehouse_transfer_carton(customer_id VARCHAR(64),transfer_order_id BIGINT,counted_at TIMESTAMP)");
-        db.execute("CREATE TABLE ll_warehouse_transfer_pallet(customer_id VARCHAR(64),transfer_order_id BIGINT)");
-        for(int i=1;i<=2;i++) {
-            db.update("INSERT INTO ll_warehouse_transfer_order VALUES(?,? ,? ,? ,?,?,'WAREHOUSE_PICKUP','WAIT_PDA_RECEIVING',CURRENT_TIMESTAMP)",i,"C"+i,"WT"+i,"WT"+i,i,i);
-            db.update("INSERT INTO ll_order VALUES(?,?,'INBOUND_MEASURING','WAREHOUSE_TRANSFER:APPROVED',0,CURRENT_TIMESTAMP)",i,"C"+i);
-            db.update("INSERT INTO ll_inbound_order VALUES(?,?,'PENDING_INBOUND',CURRENT_TIMESTAMP)",i,"C"+i);
-            db.update("INSERT INTO ll_inbound_plan VALUES(?, ?,?,'WAREHOUSE_TRANSFER','PDA_PENDING',0,CURRENT_TIMESTAMP)",i,"C"+i,i);
-        }
-        var config=new MybatisConfiguration();config.addMapper(TransferPickupCancellationMapper.class);
-        var factory=new MybatisSqlSessionFactoryBean();factory.setDataSource(ds);factory.setConfiguration(config);
-        service=new TransferPickupCancellationService(new TransferPickupCancellationRepository(new SqlSessionTemplate(factory.getObject()).getMapper(TransferPickupCancellationMapper.class)));
-    }
-    /** 释放本例数据库资源。 */
-    @AfterEach void close(){db.execute("SHUTDOWN");}
-    /** 全车跨客户成员分别取消自己的原单与计划，不影响其他客户。 */
-    @Test void cancelsOnlyTheLinkedBusinessAndKeepsAudit() {
-        tx.executeWithoutResult(s->service.cancel(List.of(new FleetPickupModels.Source("C1","WT1")),"TR1","OP","客户取消"));
-        for(String table:List.of("ll_warehouse_transfer_order","ll_inbound_order","ll_inbound_plan")) {
-            assertThat(db.queryForObject("SELECT status FROM "+table+" WHERE id=1",String.class)).isEqualTo("CANCELLED");
-            assertThat(db.queryForObject("SELECT status FROM "+table+" WHERE id=2",String.class)).isNotEqualTo("CANCELLED");
-        }
-        assertThat(db.queryForObject("SELECT current_status FROM ll_order WHERE id=1",String.class)).isEqualTo("CANCELLED");
-        assertThat(db.queryForObject("SELECT version FROM ll_order WHERE id=1",Integer.class)).isEqualTo(1);
-        assertThat(db.queryForObject("SELECT remark FROM ll_loading_order_status_history",String.class)).contains("OP","客户取消");
-    }
-    /** 后一票已经清点时，前一票取消及历史写入全部回滚。 */
-    @Test void oneStartedMemberRollsBackAllOtherCancellations() {
-        db.update("INSERT INTO ll_warehouse_transfer_carton VALUES('C2',2,CURRENT_TIMESTAMP)");
-        assertThatThrownBy(()->tx.executeWithoutResult(s->service.cancel(List.of(new FleetPickupModels.Source("C1","WT1"),new FleetPickupModels.Source("C2","WT2")),"TR1","OP","取消"))).hasMessageContaining("不能取消");
-        assertThat(db.queryForObject("SELECT COUNT(*) FROM ll_warehouse_transfer_order WHERE status='CANCELLED'",Integer.class)).isZero();
-        assertThat(db.queryForObject("SELECT COUNT(*) FROM ll_loading_order_status_history",Integer.class)).isZero();
-        assertThatThrownBy(()->tx.executeWithoutResult(s->service.cancel(List.of(new FleetPickupModels.Source("C2","WT1")),"TR1","OP","取消"))).hasMessageContaining("不能取消");
-    }
-}

lastleg-service/src/test/java/com/baiyue/lastleg/transfer/service/WarehouseTransferCartonCountTest.java

@@ -27,7 +27,7 @@ class WarehouseTransferCartonCountTest {
         service = spy(new WarehouseTransferService());
         ReflectionTestUtils.setField(service, "transfers", orders);
         var pickupRepository = org.mockito.Mockito.mock(com.baiyue.lastleg.fleet.pickup.FleetPickupRepository.class);
-        ReflectionTestUtils.setField(service, "pickupService", new com.baiyue.lastleg.fleet.pickup.FleetPickupService(pickupRepository,null,null,null,null,null,new ObjectMapper(),mock(com.baiyue.lastleg.fleet.pickup.PickupDepartureReview.class)));
+        ReflectionTestUtils.setField(service, "pickupService", new com.baiyue.lastleg.fleet.pickup.FleetPickupService(pickupRepository,null,null,null,null,null,new ObjectMapper()));
         ReflectionTestUtils.setField(service, "transferCartons", cartons);
         ReflectionTestUtils.setField(service, "transferItems", items);
         ReflectionTestUtils.setField(service, "transferPallets", palletMapper);

lastleg-service/src/test/java/com/baiyue/lastleg/transfer/service/WarehouseTransferServiceTest.java

@@ -202,7 +202,6 @@ class WarehouseTransferServiceTest {
     @Mock com.baiyue.lastleg.relabel.service.RelabelApplicationService relabelService;
     private WarehouseTransferService service;
     @Mock WarehouseTransferReceiptCoordinator receiptCoordinator;
-    @Mock com.baiyue.lastleg.dispatch.transport.TransportTaskService transportTasks;
     @Mock com.baiyue.lastleg.fleet.customer.FleetCustomerDirectory customerDirectory;
 
     private com.baiyue.lastleg.service.LastlegDocumentNumberGenerator compactNumbers;
@@ -210,7 +209,6 @@ class WarehouseTransferServiceTest {
     void setUp() {
         compactNumbers = org.mockito.Mockito.mock(com.baiyue.lastleg.service.LastlegDocumentNumberGenerator.class);
         service = new WarehouseTransferService();
-        ReflectionTestUtils.setField(service, "transportTaskService", transportTasks);
         var measurementRepository = new com.baiyue.lastleg.transfer.repository.TransferMeasurementRepository();
         ReflectionTestUtils.setField(measurementRepository, "cartons", transferCartons);
         ReflectionTestUtils.setField(service, "transferMeasurementRepository", measurementRepository);
@@ -235,7 +233,7 @@ class WarehouseTransferServiceTest {
             });
         ReflectionTestUtils.setField(service, "transfers", transfers);
         var pickupRepository = org.mockito.Mockito.mock(com.baiyue.lastleg.fleet.pickup.FleetPickupRepository.class);
-        ReflectionTestUtils.setField(service, "pickupService", new com.baiyue.lastleg.fleet.pickup.FleetPickupService(pickupRepository,null,null,null,null,null,new ObjectMapper(),mock(com.baiyue.lastleg.fleet.pickup.PickupDepartureReview.class)));
+        ReflectionTestUtils.setField(service, "pickupService", new com.baiyue.lastleg.fleet.pickup.FleetPickupService(pickupRepository,null,null,null,null,null,new ObjectMapper()));
         ReflectionTestUtils.setField(service, "transferItems", transferItems);
         ReflectionTestUtils.setField(service, "transferCartons", transferCartons);
         ReflectionTestUtils.setField(service, "sourceOrders", sourceOrders);
@@ -726,7 +724,6 @@ class WarehouseTransferServiceTest {
         assertEquals(5, line.getValue().getRequiredPackageCount());
         assertEquals("PENDING_INBOUND", inbound.getStatus());
         assertEquals(WarehouseTransferService.WAIT_PDA_RECEIVING, transfer.getStatus());
-        verify(transportTasks).ensureApprovedPickup("TENANT-A", "WTR-1", "USER-1");
     }
 
     @Test

scripts/AGENTS.md

@@ -11,7 +11,7 @@
 | 类别 | 正式入口 | 管理边界 |
 |---|---|---|
 | 本机重型检查限流 | `local-check.ps1` | 所有工作目录、对话共用两个用户级执行名额；PowerShell 7，状态/超时/并发与 Job Object 回收规则见外层 `docs/AI工程执行与协作约束.md`；只读状态不申请重型名额 |
-| 后端分层检查 | `backend-check.ps1` | 局部任务显式选 Focused；模式缺省为 Module，不是日常必跑；必填模块并接入限流，范围见后端根指引，参数见 README |
+| 后端分层检查 | `backend-check.ps1` | 默认指定模块回归，支持测试源码编译和精确测试类；必填模块，自动接入重型限流；全量触发条件见后端根指引，参数及副作用见 README |
 | 测试/灰度单票验收 | `prod-release-acceptance.mjs`、`prod-release-delivery-stage.mjs`、内部 `prod-release-order-stage.mjs` | 显式 test/gray、统一 Gateway/accessToken；同一票义乌到洛杉矶、前置同时核对东莞；full-flow 串行覆盖买单FBA正常链至签收回传及车次资源释放，保留分阶段入口与独立检查点；不调用测试造数模块，不创建账号/主档或删除数据；配置和边界见 README |
 | Admin 全量 HTTP 验证 | `admin-test-env-acceptance.mjs` | 通过显式环境文件运行统一 TEST Gateway/会话，拒绝旧海外网关参数；默认模块覆盖平台全链路，定向验证使用 `--modules`，模块注册和依赖以总入口及 `admin-test-env-modules/README.md` 为准 |
 | Client 全量 HTTP 验证 | `client-test-env-acceptance.mjs` | 通过显式环境文件运行统一 TEST Gateway/会话，拒绝旧海外网关参数；覆盖客户工作台完整链路，`client-phase2-test-env-acceptance.mjs` 只是入库测量与计费专项，不替代全量入口 |

scripts/README.md

@@ -458,13 +458,13 @@ Admin/Client HTTP 脚本的离线合同只验证脚本结构、参数和模块
 .\scripts\backend-check.ps1 -Modules order -Mode Compile
 # 开发迭代：精确类名，支持逗号分隔和全限定名。
 .\scripts\backend-check.ps1 -Modules common-core -Mode Focused -Tests ApiResponseTest
-# 服务级影响且定向覆盖不足：指定模块及上游依赖测试。
+# 单服务收尾：指定模块及上游依赖测试。
 .\scripts\backend-check.ps1 -Modules order
-# 跨服务模块回归：显式列出受影响生产者、消费者。
+# 跨服务收尾：显式列出受影响生产者、消费者。
 .\scripts\backend-check.ps1 -Modules 'order,firstleg'
 ```
 
-三种模式均使用根 reactor 的 `-pl <modules> -am`，不会安装制品到本地仓库，不默认 `clean`。`Compile` 运行 `test-compile`；`Focused`/`Module` 运行 `test`。`-am` 只补上游构建依赖，HTTP/事件下游消费者须显式列入。局部逻辑使用 `Focused` 覆盖修改行为及必要边界即可交付，不因收尾改跑 `Module`；模块回归只用于定向覆盖不足的服务级影响。公共模块按实际消费者验证。模式缺省值为 `Module`，局部任务须显式选 `Focused`；API、Mapper、索引合同按各自条件执行。
+三种模式均使用根 reactor 的 `-pl <modules> -am`，不会安装制品到本地仓库，不默认 `clean`。`Compile` 运行 `test-compile`；`Focused`/`Module` 运行 `test`。`-am` 只补上游构建依赖，HTTP/事件下游消费者须由调用者显式列入。公共模块变更也须核对下游，不能只测试公共模块自身。Focused 只用于迭代，不能替代有行为变化时的模块收尾；API、Mapper、索引等相关静态合同仍按其规则单独执行。
 
 Focused 不接受通配符或方法选择，每个类必须唯一命中所选模块的 `src/test/java`。为允许上游无同名测试，Maven 设置 `surefire.failIfNoSpecifiedTests=false`，随后逐类核对本轮更新的 Surefire XML；报告缺失、陈旧、全部跳过或含失败均不能通过，避免零测试假绿。
 

scripts/admin-test-env-acceptance.mjs

@@ -57,8 +57,6 @@ export function planA0LocationIsolation(locations, requiredSlots = 1,
 }
 
 const MODULE_DEPENDENCIES = new Map([
-  ['inbound-weight-ocr', ['orders']],
-  ['orders', ['merchant-qualification-fixture']],
   ['phase5-root-fulfillment', ['merchant-qualification-fixture']],
   ['pda-loading-link-regression', ['merchant-qualification-fixture']],
   ['phase4-overseas-return-followups', ['phase4-overseas-return-receipt']],

scripts/admin-test-env-modules/README.md

@@ -4,9 +4,7 @@
 
 固定托盘造数中，`inbound-measurement.mjs` 只复用 `TP-001`、`YW-TP-002` 指定池中的现有托盘；一只可复用，不要求两只同时存在，两只均缺失才阻断，不自动选择池外托盘。仅明确设置内部 `allowAnyExistingPallet` 的通用场景可读取当前仓库已有资源；两者均不创建托盘。
 
-OCR模块必须通过`ADMIN_TEST_OCR_IMAGE`显式指定本轮图片，不依赖个人桌面路径；定向运行自动展开客户资质及订单前置。识别失败的空字段允许省略，但识别成功必须有有效重量与单位；人工修正和确认分别增加版本。合成称重测试图只证明上传、识别响应及人工确认协议，不代表现场称重照片或设备验收。费用项目模块按受控编码验证112条正式基线，合法扩展项目保留并单独核对分页和筛选。散板普通状态接口仅验证取消及非法派车拒绝，原单须出现在待匹配需求池；需求池接车到签收另列覆盖缺口，不以手工跳状态冒充履约。
-
-预约工作查询在本轮业务写入后，仅对服务端明确返回的 A0409“预约批次或运输关联已变化，服务端正在协调完整工作清单”或“已开船工作范围变化，请先完成服务端同步”每 5 秒重读，最多等待 240 秒；超时保留失败，其他错误不重试。这是后台完整扫描的就绪等待，不是页面响应性能验收，也不触发同步写接口。
+OCR模块必须通过`ADMIN_TEST_OCR_IMAGE`显式指定本轮图片，不依赖个人桌面路径。合成称重测试图只证明上传、识别响应及人工确认协议，不代表现场称重照片或设备验收。费用项目模块按受控编码验证112条正式基线，合法扩展项目保留并单独核对分页和筛选。散板普通状态接口仅验证取消及非法派车拒绝，原单须出现在待匹配需求池；需求池接车到签收另列覆盖缺口，不以手工跳状态冒充履约。
 
 先运行 `node scripts/acceptance-overview.mjs`（后端根目录，无网络）查看当前默认与可选模块。范围来自真实注册表；本文件描述各模块用途与依赖，不代表所有模块默认执行或已通过。报告解读及跨端/专项边界见 [总索引](../README.md#先看范围再看证据)，最新运行状态只查外层部署契约。
 

scripts/admin-test-env-modules/appointment-work-contract.test.mjs

@@ -1,26 +1,7 @@
 import assert from 'node:assert/strict'
 import test from 'node:test'
 import { readFileSync } from 'node:fs'
-import { run, readAfterSynchronization } from './appointment-work.mjs'
-
-test('同步就绪只重试明确协调状态，超限及其他错误原样保留', async () => {
-  const coordinating = {http:200,body:{code:'A0409',message:'预约批次或运输关联已变化，服务端正在协调完整工作清单'}}
-  const success = {http:200,body:{code:'200',data:{}}}
-  let calls = 0
-  assert.equal(await readAfterSynchronization({request:async()=>++calls === 1 ? coordinating : success}, '/summary', {attempts:3,delay:async()=>{}}),success)
-  assert.equal(calls,2)
-  const scopeChanged = {http:200,body:{code:'A0409',message:'已开船工作范围变化，请先完成服务端同步'}}
-  calls=0
-  assert.equal(await readAfterSynchronization({request:async()=>++calls===1?scopeChanged:success}, '/summary', {attempts:3,delay:async()=>{}}),success)
-  assert.equal(calls,2)
-  calls=0
-  assert.equal(await readAfterSynchronization({request:async()=>{calls++;return coordinating}}, '/summary', {attempts:3,delay:async()=>{}}),coordinating)
-  assert.equal(calls,3)
-  const other={http:500,body:{code:'S0500'}}
-  assert.equal(await readAfterSynchronization({request:async()=>other}, '/summary', {delay:async()=>assert.fail('must not retry')}),other)
-  const conflict={http:200,body:{code:'A0409',message:'预约版本冲突'}}
-  assert.equal(await readAfterSynchronization({request:async()=>conflict}, '/summary', {delay:async()=>assert.fail('must not retry unrelated conflict')}),conflict)
-})
+import { run } from './appointment-work.mjs'
 
 const entry = readFileSync(new URL('../admin-test-env-acceptance.mjs', import.meta.url), 'utf8')
 const moduleSource = readFileSync(new URL('./appointment-work.mjs', import.meta.url), 'utf8')

scripts/admin-test-env-modules/appointment-work.mjs

@@ -1,18 +1,3 @@
-import { setTimeout as sleep } from 'node:timers/promises'
-
-export async function readAfterSynchronization(context, path, { attempts = 49, delay = () => sleep(5000) } = {}) {
-  let response
-  for (let attempt = 1; attempt <= attempts; attempt += 1) {
-    response = await context.request('GET', path)
-    const coordinating = response.http === 200 && String(response.body?.code) === 'A0409'
-      && ['预约批次或运输关联已变化，服务端正在协调完整工作清单',
-        '已开船工作范围变化，请先完成服务端同步'].includes(response.body?.message)
-    if (!coordinating || attempt === attempts) return response
-    await delay()
-  }
-  return response
-}
-
 function count(value) {
   const number = Number(value)
   return Number.isFinite(number) ? number : NaN
@@ -30,7 +15,7 @@ export async function run(context) {
   const from = shanghaiDate(-7)
   const to = shanghaiDate(7)
 
-  const calendarResponse = await readAfterSynchronization(context, `${base}/calendar?from=${from}&to=${to}`)
+  const calendarResponse = await context.request('GET', `${base}/calendar?from=${from}&to=${to}`)
   const calendar = context.apiSuccess(module, '查询预约工作日历', calendarResponse)
   const days = Array.isArray(calendar?.days) ? calendar.days : []
   const dayTotal = days.reduce((sum, day) => sum + Number(day?.total || 0), 0)
@@ -44,14 +29,14 @@ export async function run(context) {
       `date=${day?.date || 'missing'},total=${day?.total ?? 'missing'},typeTotal=${typeTotal}`)
   }
 
-  const summaryResponse = await readAfterSynchronization(context, `${base}/summary`)
+  const summaryResponse = await context.request('GET', `${base}/summary`)
   const summary = context.apiSuccess(module, '查询预约工作汇总', summaryResponse)
   const summaryFields = ['all', 'followToday', 'overdue', 'undated', 'review']
   context.assert(module, '工作汇总五项计数完整', summaryResponse,
     summaryFields.every((field) => Number.isFinite(Number(summary?.[field]))),
     summaryFields.map((field) => `${field}=${summary?.[field] ?? 'missing'}`).join(','))
 
-  const pageResponse = await readAfterSynchronization(context, `${base}/items?view=ALL&page=1&size=20`)
+  const pageResponse = await context.request('GET', `${base}/items?view=ALL&page=1&size=20`)
   const page = context.apiSuccess(module, '查询预约工作事项首页', pageResponse)
   const records = Array.isArray(page?.records) ? page.records : []
   const total = count(page?.total)

scripts/admin-test-env-modules/inbound-weight-ocr-contract.test.mjs

@@ -1,10 +1,8 @@
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import test from 'node:test'
-import { normalizeModuleOrder } from '../admin-test-env-acceptance.mjs'
 
 import {
-  validRecognition, sameOptionalWeight, confirmedVersion,
   confirmedNetSummary,
   isTransientGatewayFailure,
   normalizeWeightPalletOptionPage,
@@ -16,22 +14,7 @@ import {
   workspaceWeightMatchesBaseline,
 } from './inbound-weight-ocr.mjs'
 
-test('OCR failure permits absent optional values but recognition requires a valid weight; correction and confirmation each advance version', () => {
-  assert.equal(validRecognition({ recognitionStatus: 'FAILED' }), true)
-  assert.equal(validRecognition({ recognitionStatus: 'RECOGNIZED' }), false)
-  assert.equal(validRecognition({ recognitionStatus: 'RECOGNIZED', weightValue: 45, weightUnit: 'KG', confidence: 0.9 }), true)
-  assert.equal(validRecognition({ recognitionStatus: 'RECOGNIZED', weightValue: 45, weightUnit: 'KG', confidence: 2 }), false)
-  assert.equal(sameOptionalWeight(undefined, null), true)
-  assert.equal(sameOptionalWeight(undefined, 0), false)
-  assert.equal(sameOptionalWeight(5, 6), false)
-  assert.equal(confirmedVersion(3, false), 4)
-  assert.equal(confirmedVersion(3, true), 5)
-})
-
 test('retries only transient gateway failures for the unauthenticated upload probe', () => {
-  const modules = normalizeModuleOrder(['inbound-weight-ocr'])
-  assert.ok(modules.indexOf('merchant-qualification-fixture') < modules.indexOf('orders'))
-  assert.ok(modules.indexOf('orders') < modules.indexOf('inbound-weight-ocr'))
   assert.equal(isTransientGatewayFailure({ http: 0 }), true)
   assert.equal(isTransientGatewayFailure({ http: 502 }), true)
   assert.equal(isTransientGatewayFailure({ http: 503 }), true)

scripts/admin-test-env-modules/inbound-weight-ocr.mjs

@@ -22,22 +22,6 @@ function closeNumber(actual, expected, tolerance = 0.0005) {
   return Number.isFinite(Number(actual)) && Math.abs(Number(actual) - Number(expected)) < tolerance
 }
 
-export function validRecognition(result) {
-  if (!result || !OCR_STATUSES.has(result.recognitionStatus)) return false
-  if (result.confidence != null && (!Number.isFinite(Number(result.confidence)) || Number(result.confidence) < 0 || Number(result.confidence) > 1)) return false
-  if (result.recognitionStatus === 'FAILED') return result.weightValue == null
-  return result.weightValue != null && Number(result.weightValue) > 0
-    && normalizedGrossKg(result.weightValue, result.weightUnit) != null
-}
-
-export function sameOptionalWeight(actual, expected) {
-  return actual == null || expected == null ? actual == null && expected == null : closeNumber(actual, expected)
-}
-
-export function confirmedVersion(version, hasAdjustment) {
-  return Number(version) + (hasAdjustment ? 2 : 1)
-}
-
 function palletSnapshotComplete(pallet) {
   return Boolean(id(pallet?.palletId))
     && typeof pallet?.palletCode === 'string' && pallet.palletCode.length > 0
@@ -270,7 +254,10 @@ async function createUploadedResult(context, target, pallet, image, overrides =
     Boolean(fileId) && typeof upload?.fileId === 'string',
     `fileIdType=${typeof upload?.fileId}, status=${upload?.recognitionStatus ?? 'missing'}`, SCENARIO_OPTIONS)
   context.assert(MODULE, 'OCR 上传响应字段完整且置信度受限', uploadResponse,
-    validRecognition(upload),
+    upload && OCR_STATUSES.has(upload.recognitionStatus)
+      && Object.hasOwn(upload, 'weightValue') && Object.hasOwn(upload, 'weightUnit')
+      && Object.hasOwn(upload, 'confidence')
+      && (upload.confidence == null || (Number(upload.confidence) >= 0 && Number(upload.confidence) <= 1)),
     `status=${upload?.recognitionStatus ?? 'missing'}, hasWeight=${upload?.weightValue != null}, confidence=${upload?.confidence ?? 'null'}`,
     SCENARIO_OPTIONS)
   if (!fileId) throw new Error('称重图片上传未返回 fileId，无法登记和清理测试资源')
@@ -282,7 +269,8 @@ async function createUploadedResult(context, target, pallet, image, overrides =
     const retry = context.apiSuccess(MODULE, '重试当前称重图片 OCR', retryResponse,
       `fileId=${fileId}`, SCENARIO_OPTIONS)
     context.assert(MODULE, 'OCR 重试保持文件身份并返回识别契约', retryResponse,
-      id(retry?.fileId) === fileId && validRecognition(retry),
+      id(retry?.fileId) === fileId && OCR_STATUSES.has(retry?.recognitionStatus)
+        && Object.hasOwn(retry || {}, 'weightValue') && Object.hasOwn(retry || {}, 'confidence'),
       `sameFile=${id(retry?.fileId) === fileId}, status=${retry?.recognitionStatus ?? 'missing'}`,
       SCENARIO_OPTIONS)
     if (retry) recognized = retry
@@ -486,8 +474,8 @@ export async function run(context) {
     const registeredRow = registered.workspace?.weightResults?.find((row) => id(row.id) === original.resultId)
     context.assert(MODULE, '工作区保留本轮 OCR 原值且未覆盖历史结果', registered.response,
       registeredRow && !baselineIds.has(original.resultId)
-        && sameOptionalWeight(registeredRow.ocrWeightValue, original.result.ocrWeightValue)
-        && (registeredRow.ocrWeightUnit ?? null) === (original.result.ocrWeightUnit ?? null),
+        && closeNumber(registeredRow.ocrWeightValue, original.result.ocrWeightValue)
+        && registeredRow.ocrWeightUnit === original.result.ocrWeightUnit,
       `resultFound=${Boolean(registeredRow)}, baselineCount=${baselineIds.size}, currentCount=${registered.workspace?.weightResults?.length ?? 'n/a'}`,
       SCENARIO_OPTIONS)
 
@@ -518,7 +506,7 @@ export async function run(context) {
     const confirmedTare = Number(confirmed?.palletTareWeightKg)
     const confirmedNet = Number(confirmed?.netWeightKg)
     context.assert(MODULE, '确认结果返回托盘快照、毛重和去皮净重', confirmResponse,
-      confirmed?.recognitionStatus === 'CONFIRMED' && Number(confirmed?.version) === confirmedVersion(original.version, !canConfirmOriginal)
+      confirmed?.recognitionStatus === 'CONFIRMED' && Number(confirmed?.version) === original.version + 1
         && id(confirmed?.palletId) === id(pallet.palletId)
         && confirmed?.palletCode === pallet.palletCode && confirmed?.palletType === pallet.palletType
         && closeNumber(confirmed?.palletCapacityCbm, pallet.capacityCbm)

scripts/admin-test-env-modules/merchant-qualification-fixture-contract.test.mjs

@@ -53,7 +53,7 @@ test('商户夹具通过正式 File 和 IAM 审核流程建立下单资格', ()
   assert.match(fixture, /MERCHANT_TEST_PASSWORD/)
   assert.match(fixture, /context\.options\?\.customerName/)
   assert.match(fixture, /tenantName/)
-  assert.doesNotMatch(fixture, /expectedProcurementPrefix/)
+  assert.match(fixture, /expectedProcurementPrefix: customerName \? null : 'QLYSXDKH'/)
   assert.match(acceptance, /administrator-phone-availability\?phone=/)
   assert.match(acceptance, /attempt < 100/)
   assert.doesNotMatch(acceptance, /phoneSequence % 10/)

scripts/admin-test-env-modules/merchant-qualification-fixture.mjs

@@ -120,8 +120,10 @@ export async function run(context, { publishEnvironment = true } = {}) {
   }
   context.context.merchantQualificationFixture = {
     tenantId, tenantName, username, password, marker: context.marker,
+    expectedProcurementPrefix: customerName ? null : 'QLYSXDKH',
   }
   context.createdResources.merchantQualificationFixture = {
     tenantId, tenantName, username, marker: context.marker,
+    expectedProcurementPrefix: customerName ? null : 'QLYSXDKH',
   }
 }

scripts/admin-test-env-modules/pda-audit-sailing-contract.test.mjs

@@ -111,8 +111,4 @@ test('船期日历模块注册为默认模块并核对月历、渠道、模板
   assert.ok(ctx.calls[3].path.includes('/sailing-assignments/exceptions'))
   assert.ok(ctx.calls[4].path.endsWith('/11'))
   assert.ok(ctx.calls[5].path.endsWith('/999999999999999'))
-  delete sailing.etaAt
-  await runSailingCalendar(ctx)
-  sailing.etaAt = 'invalid-eta'
-  await assert.rejects(runSailingCalendar(ctx), /月历记录、汇总与筛选选项结构完整/)
 })

scripts/admin-test-env-modules/phase3-container-overview.mjs

@@ -103,7 +103,7 @@ export async function run(context) {
   const clearance = await context.request('GET', `${CONTAINERS}/${encodeURIComponent(containerId)}/clearance`)
   context.assert(MODULE, '国内未出仓时目的港清关不生成国外工作台数据', clearance,
     clearance.http === 200 && String(clearance?.body?.code) === 'A0404'
-      && clearance?.body?.message === '货柜尚未离仓或实际开船，不能维护目的港清关资料',
+      && String(clearance?.body?.message || '').includes('国外工作台货柜不存在'),
     `HTTP=${clearance.http}, code=${clearance?.body?.code ?? 'missing'}, containerBookingId=${containerId}`, OPTIONS)
   const customs = await context.request('GET', `/api/platform/v1/first-leg/loading-lists/${encodeURIComponent(planId)}/customs?warehouseId=${encodeURIComponent(warehouseId)}`)
   if (fixture?.finalStatus === 'LOADED') {

scripts/admin-test-env-modules/phase3-container-regression-contract.test.mjs

@@ -55,7 +55,6 @@ test('overview regression requires workflowStatus and distinguishes 100 percent
 test('pre-departure overview rejects destination workbench documents explicitly', () => {
   assert.match(overviewAcceptance, /国内未出仓时 \$\{documentType\} 不生成国外工作台数据/)
   assert.match(overviewAcceptance, /国内未出仓时目的港清关不生成国外工作台数据/)
-  assert.match(overviewAcceptance, /货柜尚未离仓或实际开船，不能维护目的港清关资料/)
   assert.match(overviewAcceptance, /国外工作台货柜不存在/)
 })
 

scripts/admin-test-env-modules/phase4-overseas-business-contract.test.mjs

@@ -207,8 +207,7 @@ function fixture(options = {}) {
 test('module is context injected, blocks missing prerequisites and excludes forbidden surfaces', () => {
   assert.match(source, /export async function run\(context\)/)
   assert.doesNotMatch(source, /https?:\/\/|process\.env|fetch\(/)
-  assert.equal((source.match(/addCoverageGap\(/g) || []).length, 1)
-  assert.match(source, /looseboard-pool-fulfillment/)
+  assert.doesNotMatch(source, /addCoverageGap|coverageGap\(/)
   assert.match(source, /deploymentBlocker: true/)
   assert.match(source, /contactPhone: '\d+'/)
   assert.doesNotMatch(source, /contactPhone: '\+[^']+'/)