Read frozen dispatch driver license through its exact driver owner

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

@@ -25,11 +25,11 @@ public interface DispatchSourceMapper {
     @Options(useCache=false,flushCache=Options.FlushCachePolicy.TRUE)
     List<ItemPicked> pickedItems(@Param("dispatch")long dispatch);
 
-    /** 组成查询不按占用可选性筛掉本草稿或隐藏客户的真实成员。 */
+    /** 组成查询保留完整客户成员；仓ID两侧同转有界字符，避免列与连接字符集排序规则冲突。 */
     @Select("<script>SELECT DISTINCT p.id AS planPalletId,ip.customer_id AS customerId FROM ll_inbound_plan_pallet p "
         + "JOIN ll_inbound_plan ip ON ip.id=p.plan_id AND ip.customer_id=p.customer_id "
         + "JOIN ll_inventory_position s ON s.pallet_id=p.warehouse_pallet_id AND s.customer_id=ip.customer_id "
-        + "AND s.overseas_warehouse_id=CAST(ip.overseas_warehouse_id AS CHAR) "
+        + "AND CAST(s.overseas_warehouse_id AS CHAR(128))=CAST(ip.overseas_warehouse_id AS CHAR(128)) "
         + "WHERE s.overseas_warehouse_id=#{warehouse} AND p.warehouse_pallet_id IN <foreach collection='ids' item='id' open='(' separator=',' close=')'>#{id}</foreach> ORDER BY ip.customer_id,p.id</script>")
     @Options(useCache=false,flushCache=Options.FlushCachePolicy.TRUE)
     List<PlanReference> physicalPlans(@Param("warehouse")String warehouse,@Param("ids")List<Long> ids);

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

@@ -223,14 +223,37 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         requirePlatform(actor);var row=required(actor,number,false);requireEditing(row,row.getRecordVersion());
         return evidence.upload(row.getId(),kind,actor.operatorId(),file);
     }
-    /** 列表权限含详情只读，但文件仍限当前整车复合归属。 */
+    /** 列表权限含详情只读；仅冻结MASTER证照走司机归属，其余保持本车附件复合归属。 */
     public com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.File evidenceMetadata(Actor actor,String number,
         com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind kind,long fileId) {
-        requirePlatform(actor);var row=required(actor,number,false);if(fileId<=0)throw bad("文件引用无效");return evidence.metadata(row.getId(),kind,fileId);
+        requirePlatform(actor);var row=required(actor,number,false);if(fileId<=0)throw bad("文件引用无效");
+        var driverId=masterEvidenceDriverId(row,kind,fileId);
+        if(driverId!=null)return driverEvidenceMetadata(fleet.dispatchDriverLicense(driverId,fileId).metadata(),fileId);
+        return evidence.metadata(row.getId(),kind,fileId);
     }
-    /** 内容仅经服务端鉴权代理，不返回匿名存储URL。 */
+    /** 内容沿同一次确定的归属代理读取，不尝试类别回退，不返回匿名存储URL。 */
     public byte[] evidenceContent(Actor actor,String number,com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind kind,long fileId) {
-        requirePlatform(actor);var row=required(actor,number,false);if(fileId<=0)throw bad("文件引用无效");return evidence.download(row.getId(),kind,fileId);
+        requirePlatform(actor);var row=required(actor,number,false);if(fileId<=0)throw bad("文件引用无效");
+        var driverId=masterEvidenceDriverId(row,kind,fileId);
+        if(driverId!=null) {
+            var file=fleet.dispatchDriverLicense(driverId,fileId);driverEvidenceMetadata(file.metadata(),fileId);return file.content();
+        }
+        return evidence.download(row.getId(),kind,fileId);
+    }
+    /** 未命中冻结MASTER引用的文件仅可按原排车归属读取，保留编辑中尚未保存的本车外配上传。 */
+    private Long masterEvidenceDriverId(DispatchAggregate row,com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind kind,long fileId) {
+        if(kind!=com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER)return null;
+        var resources=read(row.getResourcesJson(),Resources.class);var driver=resources==null?null:resources.driver();
+        if(driver==null || driver.mode()!=ResourceMode.MASTER || driver.evidence()==null || driver.evidence().fileIds()==null
+            || !driver.evidence().fileIds().contains(fileId))return null;
+        if(driver.driverId()==null || driver.driverId()<=0)throw bad("排车冻结司机档案身份无效，不能读取证照");
+        return driver.driverId();
+    }
+    /** 司机域已执行当前/历史关联及File四元组校验，转换元数据时仍保留请求文件身份。 */
+    private static com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.File driverEvidenceMetadata(
+        com.baiyue.lastleg.fleet.driver.DriverModels.File file,long fileId) {
+        if(file==null || !Long.toString(fileId).equals(file.fileId()))throw bad("司机证照回执文件身份不一致");
+        return new com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.File(fileId,file.fileName(),file.contentType(),file.sizeBytes());
     }
 
     /** 空单或同仓多客户选货一次建车，与资源关系、来源锁和账本同事务。 */

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

@@ -337,6 +337,12 @@ public class DispatchService {
     /** 执行沿用全车申请/订单→共同实托串行顺序；库存变化不重新解释原冻结贡献。 */
     @Transactional(propagation=org.springframework.transaction.annotation.Propagation.MANDATORY)
     public RelabelDispatchSourcePort.Snapshot lockExecutionSources(String warehouse,List<DispatchItem> items) {
+        // 合法空车没有来源或实托可锁；非空明细即使尚未关联实托，仍必须经过原严格校验。
+        if(items.isEmpty()) {
+            if(warehouse==null || warehouse.isBlank())throw new IllegalArgumentException("空排车仍须明确起运仓库");
+            return new RelabelDispatchSourcePort.Snapshot(List.of(),List.of(),List.of(),
+                wholeHashes.source(Map.of("warehouseId",warehouse,"items",List.of())),true,List.of());
+        }
         var pallets=items.stream().map(DispatchItem::getWarehousePalletId).filter(Objects::nonNull).collect(Collectors.toCollection(TreeSet::new));
         var initial=relabelSources.snapshot(warehouse,List.copyOf(pallets));var applications=new TreeSet<String>();
         initial.applications().forEach(a->applications.add(a.relabelNo()));

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

@@ -34,6 +34,11 @@ public class FleetTripExecutionService {
     private final ObjectMapper json;
     private final FleetBookingReservations bookingReservations;
 
+    /** 排车域先核对冻结司机及附件引用；本域继续校验该司机当前或历史证照归属。 */
+    public DriverModels.Download dispatchDriverLicense(long driverId,long fileId) {
+        return drivers.download(driverId,fileId);
+    }
+
     public FleetTripExecutionService(FleetTripMapper trips, FleetTripDispatchMapper bindings, FleetResourceMapper resources,
                                      FleetDispatchGateway dispatches, FleetTripService history, DriverService drivers,
                                      VehicleRepository vehicles, ObjectMapper json, FleetBookingReservations bookingReservations) {

lastleg-service/src/test/java/com/baiyue/lastleg/dispatch/mapper/DispatchSourceMapperWarehouseBindingTest.java

@@ -0,0 +1,110 @@
+package com.baiyue.lastleg.dispatch.mapper;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.mybatis.spring.SqlSessionTemplate;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.datasource.DriverManagerDataSource;
+
+import java.util.List;
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/** 实际Mapper查询仓/客户/实托交集；MySQL不同排序规则另由只读真实库探针验证。 */
+class DispatchSourceMapperWarehouseBindingTest {
+    private static final long WAREHOUSE = 193000000000200003L;
+    private static final long PHYSICAL_PALLET = 2112349761578209281L;
+    private static final long PLAN = 2112349764502786049L;
+    private static final long PLAN_PALLET = 2112349764502786050L;
+    private static final String CUSTOMER = "2112349740878327809";
+    private static final String SECOND_CUSTOMER = "2112349740878327810";
+    private JdbcTemplate db;
+    private DispatchSourceMapper mapper;
+
+    @BeforeEach
+    void setUp() throws Exception {
+        var data = new DriverManagerDataSource("jdbc:h2:mem:" + UUID.randomUUID()
+            + ";MODE=MySQL;DB_CLOSE_DELAY=-1", "sa", "");
+        db = new JdbcTemplate(data);
+        // 仅保留本查询所需列，类型/长度与lastleg.sql一致：计划仓BIGINT，库存仓VARCHAR(128)。
+        db.execute("CREATE TABLE ll_inbound_plan(id BIGINT PRIMARY KEY,customer_id VARCHAR(128),overseas_warehouse_id BIGINT)");
+        db.execute("CREATE TABLE ll_inbound_plan_pallet(id BIGINT PRIMARY KEY,plan_id BIGINT,customer_id VARCHAR(128),warehouse_pallet_id BIGINT)");
+        db.execute("CREATE TABLE ll_inventory_position(id BIGINT PRIMARY KEY,customer_id VARCHAR(128),overseas_warehouse_id VARCHAR(128),pallet_id BIGINT)");
+        plan(PLAN, PLAN_PALLET, CUSTOMER, CUSTOMER, WAREHOUSE, PHYSICAL_PALLET);
+        position(1, CUSTOMER, Long.toString(WAREHOUSE), PHYSICAL_PALLET);
+        var config = new MybatisConfiguration();
+        config.addMapper(DispatchSourceMapper.class);
+        var factory = new MybatisSqlSessionFactoryBean();
+        factory.setDataSource(data);
+        factory.setConfiguration(config);
+        mapper = new SqlSessionTemplate(factory.getObject()).getMapper(DispatchSourceMapper.class);
+    }
+
+    @Test
+    void longStringStockWarehouseMatchesTheSameNumericPlanWarehouseWithoutLosingIdentity() {
+        assertThat(mapper.physicalPlans(Long.toString(WAREHOUSE), List.of(PHYSICAL_PALLET)))
+            .containsExactly(new DispatchSourceMapper.PlanReference(PLAN_PALLET, CUSTOMER));
+    }
+
+    @Test
+    void requestedWarehouseMustMatchTheRealStockPosition() {
+        assertThat(mapper.physicalPlans(Long.toString(WAREHOUSE + 1), List.of(PHYSICAL_PALLET))).isEmpty();
+    }
+
+    @Test
+    void matchingRequestedStockWarehouseDoesNotAuthorizeAPlanInAnotherWarehouse() {
+        db.update("UPDATE ll_inbound_plan SET overseas_warehouse_id=? WHERE id=?", WAREHOUSE + 1, PLAN);
+        assertThat(mapper.physicalPlans(Long.toString(WAREHOUSE), List.of(PHYSICAL_PALLET))).isEmpty();
+    }
+
+    @Test
+    void samePhysicalPalletCannotBorrowAnotherCustomersInventoryPosition() {
+        db.update("UPDATE ll_inventory_position SET customer_id=? WHERE id=1", SECOND_CUSTOMER);
+        assertThat(mapper.physicalPlans(Long.toString(WAREHOUSE), List.of(PHYSICAL_PALLET))).isEmpty();
+    }
+
+    @Test
+    void matchingHeaderAndPositionCannotBypassThePlanPalletCustomer() {
+        db.update("UPDATE ll_inbound_plan_pallet SET customer_id=? WHERE id=?", SECOND_CUSTOMER, PLAN_PALLET);
+        assertThat(mapper.physicalPlans(Long.toString(WAREHOUSE), List.of(PHYSICAL_PALLET))).isEmpty();
+    }
+
+    @Test
+    void completeSharedPalletCompositionRetainsBothSeparatelyOwnedCustomerPlans() {
+        plan(PLAN + 10, PLAN_PALLET + 10, SECOND_CUSTOMER, SECOND_CUSTOMER, WAREHOUSE, PHYSICAL_PALLET);
+        position(2, SECOND_CUSTOMER, Long.toString(WAREHOUSE), PHYSICAL_PALLET);
+        // 无本仓库存的第三份计划不能混入当前组成。
+        plan(PLAN + 20, PLAN_PALLET + 20, "2112349740878327811", "2112349740878327811", WAREHOUSE, PHYSICAL_PALLET);
+        assertThat(mapper.physicalPlans(Long.toString(WAREHOUSE), List.of(PHYSICAL_PALLET)))
+            .containsExactly(new DispatchSourceMapper.PlanReference(PLAN_PALLET, CUSTOMER),
+                new DispatchSourceMapper.PlanReference(PLAN_PALLET + 10, SECOND_CUSTOMER));
+    }
+
+    @Test
+    void aMatchingWarehouseAndCustomerCannotBypassTheRequestedPhysicalPalletSet() {
+        assertThat(mapper.physicalPlans(Long.toString(WAREHOUSE), List.of(PHYSICAL_PALLET + 1))).isEmpty();
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"0193000000000200003", "193000000000200003x", "193000000000200003.0"})
+    void pseudoWarehouseIdentifiersAreNotAcceptedThroughNumericCoercion(String pseudoWarehouse) {
+        db.update("UPDATE ll_inventory_position SET overseas_warehouse_id=? WHERE id=1", pseudoWarehouse);
+        // 请求与库存字符串确实相同；必须仍因不等于计划仓的完整字符身份而拒绝。
+        assertThat(mapper.physicalPlans(pseudoWarehouse, List.of(PHYSICAL_PALLET))).isEmpty();
+    }
+
+    private void plan(long planId, long planPalletId, String headerCustomer, String palletCustomer,
+                      long warehouse, long physicalPallet) {
+        db.update("INSERT INTO ll_inbound_plan VALUES(?,?,?)", planId, headerCustomer, warehouse);
+        db.update("INSERT INTO ll_inbound_plan_pallet VALUES(?,?,?,?)", planPalletId, planId, palletCustomer, physicalPallet);
+    }
+
+    private void position(long positionId, String customer, String warehouse, long pallet) {
+        db.update("INSERT INTO ll_inventory_position VALUES(?,?,?,?)", positionId, customer, warehouse, pallet);
+    }
+}

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

@@ -35,6 +35,166 @@ import static com.baiyue.lastleg.dispatch.port.DispatchTypes.*;
 
 /** 主单/资源/占用/账本真实SQL回归；外部目录与选货权威提供者使用受控输入。 */
 public class DispatchAggregatePersistenceTest {
+    /** 正式司机附件从排车冻结引用选出真实司机，再复用司机域及File的读取边界。 */
+    @Test void masterDriverEvidenceUsesFrozenDriverOwnerForMetadataAndContent() throws Exception {
+        var e=new DriverEvidenceFixture();var number=e.dispatch(ResourceMode.MASTER,71L,List.of(81L));
+        e.allowFile(81L);var before=e.f.db.queryForMap("SELECT resources_json,record_version FROM ll_dispatch_order WHERE dispatch_no=?",number);
+        assertThat(e.f.service.evidenceMetadata(e.f.actor,number,com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER,81L).fileId()).isEqualTo(81L);
+        assertThat(e.f.service.evidenceContent(e.f.actor,number,com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER,81L)).containsExactly(1,2,3);
+        verify(e.files,times(2)).metadata(71L,81L);verify(e.files,times(2)).download(71L,81L);verifyNoInteractions(e.dispatchFiles);
+        assertThat(e.f.db.queryForMap("SELECT resources_json,record_version FROM ll_dispatch_order WHERE dispatch_no=?",number)).isEqualTo(before);
+    }
+
+    /** 主档后来换证不改写本车冻结证照；旧附件必须仍满足该司机的历史关联规则。 */
+    @Test void frozenHistoricalDriverLicenseRemainsReadableAfterMasterReplacement() throws Exception {
+        var e=new DriverEvidenceFixture();var number=e.dispatch(ResourceMode.MASTER,71L,List.of(81L));
+        e.driver.setLicenseFileId(82L);when(e.history.selectCount(any())).thenReturn(1L);e.allowFile(81L);
+        assertThat(e.f.service.evidenceMetadata(e.f.actor,number,com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER,81L).fileId()).isEqualTo(81L);
+        assertThat(e.f.service.evidenceContent(e.f.actor,number,com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER,81L)).containsExactly(1,2,3);
+        verify(e.history,times(2)).selectCount(any());verify(e.files,times(2)).metadata(71L,81L);verifyNoInteractions(e.dispatchFiles);
+    }
+
+    /** 外配附件仍限本车证据；不能因为共用DRIVER展示类型而改走正式司机档案。 */
+    @Test void externalDriverEvidenceRetainsExactDispatchOwnerForBothReads() throws Exception {
+        var e=new DriverEvidenceFixture();var number=e.dispatch(ResourceMode.EXTERNAL,null,List.of(81L));
+        var dispatch=e.f.repository.find(number).getId();var kind=com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER;
+        var metadata=new com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.File(81L,"external.pdf","application/pdf",3L);
+        when(e.dispatchFiles.metadata(dispatch,kind,81L)).thenReturn(metadata);when(e.dispatchFiles.download(dispatch,kind,81L)).thenReturn(new byte[]{4,5,6});
+        assertThat(e.f.service.evidenceMetadata(e.f.actor,number,kind,81L)).isEqualTo(metadata);
+        assertThat(e.f.service.evidenceContent(e.f.actor,number,kind,81L)).containsExactly(4,5,6);
+        verify(e.dispatchFiles).metadata(dispatch,kind,81L);verify(e.dispatchFiles).download(dispatch,kind,81L);
+        verifyNoInteractions(e.driverRows,e.history,e.files);
+    }
+
+    /** 冻结引用不绕过司机当前或历史关联，提供者明确拒绝后不得尝试排车类别。 */
+    @Test void unlinkedFrozenMasterFileCannotFallBackToDispatchEvidence() throws Exception {
+        var e=new DriverEvidenceFixture();var number=e.dispatch(ResourceMode.MASTER,71L,List.of(81L));
+        e.driver.setLicenseFileId(82L);when(e.history.selectCount(any())).thenReturn(0L);
+        var kind=com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER;
+        assertThatThrownBy(()->e.f.service.evidenceMetadata(e.f.actor,number,kind,81L)).hasMessageContaining("未关联");
+        assertThatThrownBy(()->e.f.service.evidenceContent(e.f.actor,number,kind,81L)).hasMessageContaining("未关联");
+        verifyNoInteractions(e.files,e.dispatchFiles);
+    }
+
+    /** File拒绝主档四元组时直接失败，不以另一业务类别或其他司机重新读取。 */
+    @Test void masterFileProviderRejectionCannotFallBackToAnotherCategory() throws Exception {
+        var e=new DriverEvidenceFixture();var number=e.dispatch(ResourceMode.MASTER,71L,List.of(81L));
+        when(e.files.metadata(71L,81L)).thenThrow(new BizException(com.baiyue.common.core.api.ResultCode.NOT_FOUND,"业务附件不存在或归属不匹配"));
+        var kind=com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER;
+        assertThatThrownBy(()->e.f.service.evidenceMetadata(e.f.actor,number,kind,81L)).hasMessageContaining("归属不匹配");
+        assertThatThrownBy(()->e.f.service.evidenceContent(e.f.actor,number,kind,81L)).hasMessageContaining("归属不匹配");
+        verify(e.files,never()).download(anyLong(),anyLong());verifyNoInteractions(e.dispatchFiles);
+    }
+
+    /** MASTER改外配的编辑尚未保存时，新上传文件只走本车归属，不误借旧司机白名单。 */
+    @Test void unsavedExternalUploadOnMasterDispatchRetainsOriginalDispatchFileReads() throws Exception {
+        var e=new DriverEvidenceFixture();var number=e.dispatch(ResourceMode.MASTER,71L,List.of(81L));
+        var dispatch=e.f.repository.find(number).getId();var kind=com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER;
+        var metadata=new com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.File(91L,"new-external.pdf","application/pdf",3L);
+        when(e.dispatchFiles.metadata(dispatch,kind,91L)).thenReturn(metadata);when(e.dispatchFiles.download(dispatch,kind,91L)).thenReturn(new byte[]{4,5,6});
+        assertThat(e.f.service.evidenceMetadata(e.f.actor,number,kind,91L)).isEqualTo(metadata);
+        assertThat(e.f.service.evidenceContent(e.f.actor,number,kind,91L)).containsExactly(4,5,6);
+        verifyNoInteractions(e.driverRows,e.history,e.files);
+        assertThat(e.f.db.queryForObject("SELECT resources_json FROM ll_dispatch_order WHERE dispatch_no=?",String.class,number)).contains("MASTER").doesNotContain("91");
+    }
+
+    /** 未列入MASTER冻结集合或声明为外配的档案文件只能接受本车四元组核验，失败后不转司机域。 */
+    @Test void foreignOrWrongModeMasterFilesNeverGainDriverDomainAccess() throws Exception {
+        for(var mode:List.of(ResourceMode.MASTER,ResourceMode.EXTERNAL)) {
+            var e=new DriverEvidenceFixture();var number=e.dispatch(mode,71L,mode==ResourceMode.MASTER?List.of(81L):List.of(91L));
+            var dispatch=e.f.repository.find(number).getId();var kind=com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER;
+            when(e.dispatchFiles.metadata(dispatch,kind,91L)).thenThrow(new BizException(com.baiyue.common.core.api.ResultCode.NOT_FOUND,"业务附件不存在或归属不匹配"));
+            when(e.dispatchFiles.download(dispatch,kind,91L)).thenThrow(new BizException(com.baiyue.common.core.api.ResultCode.NOT_FOUND,"业务附件不存在或归属不匹配"));
+            assertThatThrownBy(()->e.f.service.evidenceMetadata(e.f.actor,number,kind,91L)).hasMessageContaining("归属不匹配");
+            assertThatThrownBy(()->e.f.service.evidenceContent(e.f.actor,number,kind,91L)).hasMessageContaining("归属不匹配");
+            verifyNoInteractions(e.driverRows,e.history,e.files);
+        }
+    }
+
+    /** 命中冻结文件集合仍须有本车真实正数司机身份，不能拿车号或其他司机替代。 */
+    @Test void masterFileWithMissingOrInvalidDriverIdentityFailsBeforeAnyFileProvider() throws Exception {
+        for(Long driverId:Arrays.asList(null,0L,-1L)) {
+            var e=new DriverEvidenceFixture();var number=e.dispatch(ResourceMode.MASTER,driverId,List.of(81L));
+            var kind=com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER;
+            assertThatThrownBy(()->e.f.service.evidenceMetadata(e.f.actor,number,kind,81L)).hasMessageContaining("身份无效");
+            assertThatThrownBy(()->e.f.service.evidenceContent(e.f.actor,number,kind,81L)).hasMessageContaining("身份无效");
+            verifyNoInteractions(e.driverRows,e.history,e.files,e.dispatchFiles);
+        }
+    }
+
+    /** 无法解释的资源模式不选择任何文件域，防止异常快照放宽读取。 */
+    @Test void unknownDriverModeFailsBeforeEitherFileProvider() throws Exception {
+        var e=new DriverEvidenceFixture();var number=e.dispatch(ResourceMode.MASTER,71L,List.of(81L));
+        e.f.db.update("UPDATE ll_dispatch_order SET resources_json=REPLACE(resources_json,'MASTER','UNKNOWN') WHERE dispatch_no=?",number);
+        var kind=com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER;
+        assertThatThrownBy(()->e.f.service.evidenceMetadata(e.f.actor,number,kind,81L)).hasMessageContaining("快照读取失败");
+        assertThatThrownBy(()->e.f.service.evidenceContent(e.f.actor,number,kind,81L)).hasMessageContaining("快照读取失败");
+        verifyNoInteractions(e.driverRows,e.history,e.files,e.dispatchFiles);
+    }
+
+    /** 使用真实排车Mapper/资源JSON及司机Service，只替代外部文件内容和主档持久提供者。 */
+    private static final class DriverEvidenceFixture {
+        final Fixture f;final DriverMapper driverRows=mock(DriverMapper.class);final DriverHistoryMapper history=mock(DriverHistoryMapper.class);
+        final DriverFileGateway files=mock(DriverFileGateway.class);final DriverEntity driver=new DriverEntity();
+        final com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway dispatchFiles;
+        /** 真实司机Service继续执行当前/历史附件关联检查，不由排车测试替身伪装通过。 */
+        DriverEvidenceFixture() throws Exception {
+            f=new Fixture();driver.setId(71L);driver.setLicenseFileId(81L);when(driverRows.selectById(71L)).thenReturn(driver);
+            var drivers=new DriverService(driverRows,history,files,f.json,mock(FleetWarehouseDirectory.class));
+            org.springframework.test.util.ReflectionTestUtils.setField(f.fleet,"drivers",drivers);
+            dispatchFiles=(com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway)org.springframework.test.util.ReflectionTestUtils.getField(f.service,"evidence");
+        }
+        /** 在真实主单保存服务端资源快照，HTTP请求本身不能指定司机、模式或允许文件集合。 */
+        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"))));
+            f.db.update("UPDATE ll_dispatch_order SET resources_json=? WHERE dispatch_no=?",f.json.writeValueAsString(resource),created.dispatchNo());return created.dispatchNo();
+        }
+        /** File内容固定为离线测试字节；真实复合归属由既有两个HTTP网关合同分别覆盖。 */
+        void allowFile(long fileId) {
+            var metadata=new DriverModels.File(Long.toString(fileId),"driver.pdf","application/pdf",3L);
+            when(files.metadata(71L,fileId)).thenReturn(metadata);when(files.download(71L,fileId)).thenReturn(new byte[]{1,2,3});
+        }
+    }
+    /** 空单零版本取消使用真实来源规则，成功及原键重放均不制造来源、库存或重复命令。 */
+    @Test void emptyVersionZeroCancellationUsesRealSourceRuleAndPreservesOriginalReplay() throws Exception {
+        var f=new Fixture();var created=f.tx.execute(t->f.service.create(f.actor,f.create("empty-real-cancel",List.of())));
+        var rules=new DispatchService();var facts=mock(com.baiyue.lastleg.relabel.port.RelabelDispatchSourcePort.class);
+        var sources=mock(DispatchSourceRepository.class);var serial=mock(com.baiyue.lastleg.inventory.port.PhysicalPalletSerialPort.class);
+        org.springframework.test.util.ReflectionTestUtils.setField(rules,"wholeHashes",new DispatchCommandHasher(f.json));
+        org.springframework.test.util.ReflectionTestUtils.setField(rules,"relabelSources",facts);
+        org.springframework.test.util.ReflectionTestUtils.setField(rules,"wholeSources",sources);
+        org.springframework.test.util.ReflectionTestUtils.setField(rules,"palletSerial",serial);
+        when(facts.snapshot(anyString(),anyList())).thenThrow(new IllegalArgumentException("仓库和实托集合不能为空"));
+        org.springframework.test.util.ReflectionTestUtils.setField(f.service,"sourceRules",rules);
+        assertThat(created.recordVersion()).isZero();
+        var request=new DispatchCommands.ReasonCommand(0L,"empty-cancel-original","取消尚未添加货物的空车");
+        var cancelled=f.tx.execute(t->f.service.cancel(f.actor,created.dispatchNo(),request));
+        assertThat(cancelled.status()).isEqualTo(Status.CANCELLED);assertThat(cancelled.stage()).isEqualTo(Stage.BEFORE_LOADING);
+        assertThat(f.tx.execute(t->f.service.cancel(f.actor,created.dispatchNo(),request)).replayed()).isTrue();
+        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_command WHERE idempotency_key='empty-cancel-original'",Long.class)).isOne();
+        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_item",Long.class)).isZero();
+        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_pallet_lock",Long.class)).isZero();
+        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_physical_pallet_lock",Long.class)).isZero();
+        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_inventory_ledger",Long.class)).isZero();
+        assertThat(f.db.queryForObject("SELECT status FROM ll_fleet_trip",String.class)).isEqualTo("CANCELLED");
+        verifyNoInteractions(facts,sources,serial);
+    }
+
+    /** 空单编辑保留零货量与版本命令，不借编辑隐式制造可装车来源。 */
+    @Test void emptyShellEditPreservesZeroCargoAndVersionedReplay() throws Exception {
+        var f=new Fixture();var created=f.tx.execute(t->f.service.create(f.actor,f.create("empty-edit",List.of())));
+        var request=new DispatchCommands.Update(0L,"empty-edit-original",null,null,null,null,"空单补充备注");
+        var saved=f.tx.execute(t->f.service.update(f.actor,created.dispatchNo(),request));
+        assertThat(saved.stage()).isEqualTo(Stage.BEFORE_LOADING);assertThat(saved.counts().packageCount()).isZero();
+        assertThat(saved.recordVersion()).isGreaterThan(created.recordVersion());
+        assertThat(f.tx.execute(t->f.service.update(f.actor,created.dispatchNo(),request)).replayed()).isTrue();
+        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_item",Long.class)).isZero();
+        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_command WHERE idempotency_key='empty-edit-original'",Long.class)).isOne();
+        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_inventory_ledger",Long.class)).isZero();
+    }
+
     /** 移货、取消只释放本车原占用；重排后旧键恢复不得释放新车的活动实托键。 */
     @Test void removalCancellationAndOldCommandRecoveryNeverReleaseNewTruckClaims() throws Exception {
         var f=new Fixture();var a=f.source(1,"101",501,"ONT8",3);var b=f.source(2,"202",502,"LAX9",5);

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

@@ -18,15 +18,44 @@ class DispatchServiceTest {
     final DispatchDraftMapper drafts=mock(DispatchDraftMapper.class);
     final RelabelApplicationMapper relabels=mock(RelabelApplicationMapper.class);
     final RelabelPalletMeasurementService measurements=mock(RelabelPalletMeasurementService.class);
+    final com.baiyue.lastleg.relabel.port.RelabelDispatchSourcePort facts=mock(com.baiyue.lastleg.relabel.port.RelabelDispatchSourcePort.class);
+    final com.baiyue.lastleg.inventory.port.PhysicalPalletSerialPort palletSerial=mock(com.baiyue.lastleg.inventory.port.PhysicalPalletSerialPort.class);
     @BeforeEach void setup(){
         ReflectionTestUtils.setField(service,"wholeSources",sources);ReflectionTestUtils.setField(service,"wholeHashes",new DispatchCommandHasher(new com.fasterxml.jackson.databind.ObjectMapper()));
         ReflectionTestUtils.setField(service,"candidates",candidates);ReflectionTestUtils.setField(service,"drafts",drafts);
         ReflectionTestUtils.setField(service,"relabelApplications",relabels);ReflectionTestUtils.setField(service,"relabelMeasurements",measurements);
         ReflectionTestUtils.setField(service,"relabelBindingGuard",mock(RelabelBindingGuard.class));ReflectionTestUtils.setField(service,"returnRelabelStock",mock(ReturnRelabelDispatchStock.class));
-        var facts=mock(com.baiyue.lastleg.relabel.port.RelabelDispatchSourcePort.class);
         // 本用例只验证完整选择的早期拒绝；实际贡献/HOLD由持久化主链覆盖。
         when(facts.snapshot(anyString(),anyList())).thenReturn(new com.baiyue.lastleg.relabel.port.RelabelDispatchSourcePort.Snapshot(List.of(),List.of(),List.of(),"CONTROLLED",true,List.of()));
         ReflectionTestUtils.setField(service,"relabelSources",facts);
+        ReflectionTestUtils.setField(service,"palletSerial",palletSerial);
+    }
+    /** 空车返回仓范围内的确定空快照，不对不存在的申请、来源或实托取得锁。 */
+    @Test void emptyExecutionSourcesHaveWarehouseScopedSnapshotWithoutAnySourceLocks(){
+        var empty=service.lockExecutionSources("9",List.of());
+        assertThat(empty.complete()).isTrue();assertThat(empty.applications()).isEmpty();assertThat(empty.sources()).isEmpty();
+        assertThat(empty.positions()).isEmpty();assertThat(empty.blockReasons()).isEmpty();
+        assertThat(empty.compositionVersion()).matches("[0-9a-f]{64}");
+        assertThat(service.lockExecutionSources("9",List.of()).compositionVersion()).isEqualTo(empty.compositionVersion());
+        assertThat(service.lockExecutionSources("10",List.of()).compositionVersion()).isNotEqualTo(empty.compositionVersion());
+        verifyNoInteractions(facts,sources,palletSerial,relabels,measurements);
+    }
+    /** 空车也不能缺失起运仓，不能把无范围请求解释成合法空来源。 */
+    @Test void emptyExecutionSourcesStillRequireWarehouse(){
+        for(String warehouse:Arrays.asList(null,""," "))assertThatThrownBy(()->service.lockExecutionSources(warehouse,List.of()))
+            .isInstanceOf(IllegalArgumentException.class).hasMessageContaining("起运仓库");
+        verifyNoInteractions(facts,sources,palletSerial);
+    }
+    /** 非空货物缺实托或提供者拒绝时保留原错误，不能借空车分支绕过闭包。 */
+    @Test void nonemptyExecutionSourcesRetainStrictProviderValidation(){
+        var item=new com.baiyue.lastleg.dispatch.entity.DispatchItem();
+        when(facts.snapshot(eq("9"),eq(List.of()))).thenThrow(new IllegalArgumentException("仓库和实托集合不能为空"));
+        assertThatThrownBy(()->service.lockExecutionSources("9",List.of(item))).hasMessageContaining("实托集合不能为空");
+        verify(facts).snapshot("9",List.of());
+        item.setWarehousePalletId(501L);
+        when(facts.snapshot("9",List.of(501L))).thenThrow(new IllegalStateException("完整实托来源已变化"));
+        assertThatThrownBy(()->service.lockExecutionSources("9",List.of(item))).hasMessageContaining("完整实托来源已变化");
+        verify(facts).snapshot("9",List.of(501L));verifyNoInteractions(sources,palletSerial);
     }
     @Test void anotherOperatorsDraftIsRejectedBeforeAnyCandidateRead(){
         assertThatThrownBy(()->service.wholeCandidates("operator",new DispatchPlanningModels.CandidateQuery("9",null,null,null,"PLAN","foreign"))).hasMessageContaining("草稿");verifyNoInteractions(sources);