Unify dispatch operations with matched published transfer fixture

feat(appointments): expose destination warehouse options
2026-10-20 00:29:25 +08:00 · 2026-10-19 17:02:25 +08:00
28 changed files with 86 additions and 536 deletions
@@ -35,28 +35,6 @@ public class PlatformDropshipPalletizationController {
    @Resource private DropshipPalletizationService service;
    @Resource private InboundCartonLabelPrintService printService;

-    /** 跨票识别箱码只读预览，清点仍按原任务领取并提交。 */
-    @GetMapping("/cartons/resolve")
-    @PreAuthorize("hasAuthority('platform:firstleg:pda:view')")
-    public ApiResponse<DropshipPalletizationDtos.ScanContext> resolveWorkspaceCarton(
-        @AuthenticationPrincipal AuthenticatedUser user,
-        @RequestParam @Positive long warehouseId,
-        @RequestParam @jakarta.validation.constraints.NotBlank @Size(max = 80) String boxCode) {
-        FirstlegScopeGuard.platform(user);
-        return ApiResponse.success(service.resolveWorkspaceCarton(warehouseId, boxCode, user.userId()));
-    }
-
-    /** 获取当前实物托盘及客户组成，不要求托盘已与当前票绑定。 */
-    @GetMapping("/pallets/resolve")
-    @PreAuthorize("hasAuthority('platform:firstleg:pda:view')")
-    public ApiResponse<DropshipPalletizationDtos.PalletWorkspace> workspacePallet(
-        @AuthenticationPrincipal AuthenticatedUser user,
-        @RequestParam @Positive long warehouseId,
-        @RequestParam @jakarta.validation.constraints.Pattern(regexp = "DP-[0-9]{6}-[0-9]{4}") String palletNo) {
-        FirstlegScopeGuard.platform(user);
-        return ApiResponse.success(service.workspacePallet(warehouseId, palletNo));
-    }
-
    @GetMapping("/tasks/pending")
    @PreAuthorize("hasAuthority('platform:firstleg:pda:view')")
    public ApiResponse<List<DropshipPalletizationDtos.PendingTask>> pending(
@@ -18,15 +18,6 @@ public final class DropshipPalletizationDtos {

    public record ClaimRequest(@Positive long warehouseId) {}

-    /** 跨票只读识别结果；确认清点前仍须领取对应任务。 */
-    public record ScanContext(Task task, Carton carton) {}
-
-    /** 当前实物托盘及逐客户、逐票组成。 */
-    public record PalletWorkspace(Pallet pallet, List<PalletMember> members) {}
-
-    public record PalletMember(Long taskId, Long inboundId, String inboundCode,
-                               Long customerId, String customerName, Integer cartonCount) {}
-
    public enum DiscrepancyAction { MATCH, ACCEPT_VARIANCE }

    public record CountCartonRequest(@Positive long warehouseId,
@@ -15,45 +15,6 @@ import java.util.List;
 /** 一件代发逐箱清点、待绑托与封托事实。 */
@Mapper
 public interface DropshipPalletizationMapper {
- /** 在指定仓库按稳定箱码识别任务，多个匹配由业务层拒绝。 */
- @Select("""
-  SELECT DISTINCT t.id FROM fl_dropship_pallet_task t
-  JOIN fl_inbound_order o ON o.id=t.inbound_id AND o.tenant_id=t.tenant_id AND o.deleted=0
-  JOIN fl_inbound_carton_label l ON l.inbound_id=t.inbound_id AND l.tenant_id=t.tenant_id
-  WHERE t.warehouse_id=#{warehouseId} AND l.box_code=#{boxCode} AND l.batch_status='ACTIVE'
-    AND o.fulfillment_type='ONE_CLICK_DROPSHIP'
-  """)
- List<Long> workspaceTaskIds(@Param("warehouseId") long warehouseId,@Param("boxCode") String boxCode);
-
- /** 扫码预览为只读查询，不能把未知或已封托托盘默认成开放。 */
- @Select("SELECT * FROM fl_dropship_pallet WHERE warehouse_id=#{warehouseId} AND pallet_no=#{palletNo}")
- PalletRow workspacePallet(@Param("warehouseId") long warehouseId,@Param("palletNo") String palletNo);
-
- /** 按实际成员汇总客户与票，空的预生成托盘不虚构成员。 */
- @Select("""
-  SELECT c.task_id,c.inbound_id,o.inbound_code,c.tenant_id customer_id,o.customer_name,COUNT(*) carton_count
-  FROM fl_dropship_pallet_carton c
-  JOIN fl_inbound_order o ON o.id=c.inbound_id AND o.tenant_id=c.tenant_id
-  WHERE c.pallet_id=#{palletId}
-  GROUP BY c.task_id,c.inbound_id,o.inbound_code,c.tenant_id,o.customer_name
-  ORDER BY o.inbound_code,c.task_id
-  """)
- List<com.baiyue.firstleg.dto.DropshipPalletizationDtos.PalletMember> workspaceMembers(@Param("palletId") long palletId);
-
- /** 混托成员必须与当前票同渠道、同目的仓，客户可以不同。 */
- @Select("""
-  SELECT COUNT(*) FROM fl_dropship_pallet_carton c
-  JOIN fl_inbound_order o ON o.id=c.inbound_id AND o.tenant_id=c.tenant_id
-  JOIN fl_dropship_pallet_task t ON t.id=#{taskId}
-  JOIN fl_inbound_order target ON target.id=t.inbound_id AND target.tenant_id=t.tenant_id
-  WHERE c.pallet_id=#{palletId} AND (
-    NOT (o.channel_code <=> target.channel_code)
-    OR NOT (o.destination_type <=> target.destination_type)
-    OR NOT (o.destination_warehouse_id <=> target.destination_warehouse_id)
-    OR NOT (o.destination_code <=> target.destination_code))
-  """)
- int workspaceIncompatibleMembers(@Param("taskId") long taskId,@Param("palletId") long palletId);
-
 @Insert("""
  INSERT IGNORE INTO fl_dropship_pallet_task
  (id,tenant_id,inbound_id,warehouse_id,task_status,total_cartons,counted_cartons,allocated_cartons,discrepancy_cartons,version,created_at,updated_at)
@@ -1,39 +0,0 @@
-package com.baiyue.firstleg.repository;
-
-import com.baiyue.firstleg.dto.DropshipPalletizationDtos.PalletMember;
-import com.baiyue.firstleg.mapper.DropshipPalletizationMapper;
-import com.baiyue.firstleg.mapper.DropshipPalletizationMapper.PalletRow;
-import jakarta.annotation.Resource;
-import org.springframework.stereotype.Repository;
-import java.util.List;
-
-/** 仓内跨票扫码与实物托盘组成查询，客户归属始终从箱唛事实取得。 */
-@Repository
-public class DropshipWorkspaceRepository {
-    @Resource private DropshipPalletizationMapper mapper;
-
-    /** 按仓库和稳定箱码查找作业任务，不接受客户端指定客户归属。 */
-    public List<Long> taskIdsForBox(long warehouseId, String boxCode) {
-        return mapper.workspaceTaskIds(warehouseId, boxCode);
-    }
-
-    /** 只读查询托盘，不因扫描托盘产生绑定或状态变化。 */
-    public PalletRow pallet(long warehouseId, String palletNo) {
-        return mapper.workspacePallet(warehouseId, palletNo);
-    }
-
-    /** 保留每票客户与任务身份，供混托核对和按原任务移箱。 */
-    public List<PalletMember> members(long palletId) {
-        return mapper.workspaceMembers(palletId);
-    }
-
-    /** 归托前锁定实物托盘，与封托互斥。 */
-    public PalletRow lockPallet(String palletNo) {
-        return mapper.palletByNo(palletNo);
-    }
-
-    /** 按原始入仓快照检查运输兼容性，不接受客户端声明。 */
-    public boolean compatible(long taskId, long palletId) {
-        return mapper.workspaceIncompatibleMembers(taskId, palletId) == 0;
-    }
-}
@@ -21,34 +21,6 @@ import java.util.*;
 public class DropshipPalletizationService {
 @Resource private DropshipPalletizationMapper mapper;
 @Resource private FirstlegDocumentNumberGenerator documentNumbers;
- @Resource private com.baiyue.firstleg.repository.DropshipWorkspaceRepository workspaceRepository;
-
- /** 只读识别其他客户的箱码；不自动领取、清点或绑定托盘。 */
- public ScanContext resolveWorkspaceCarton(long warehouseId,String boxCode,long operatorId){
-  String code=normalize(boxCode);
-  if(code==null) throw invalid("箱码不能为空");
-  List<Long> ids=workspaceRepository.taskIdsForBox(warehouseId,code);
-  if(ids.isEmpty()) throw new BizException(ResultCode.NOT_FOUND,"当前仓库未找到该一件代发箱码");
-  if(ids.size()!=1) throw conflict("箱码匹配多个任务，请联系后台核对");
-  Task target=task(ids.get(0),warehouseId,operatorId);
-  Carton carton=resolveCarton(target.taskId(),warehouseId,code,operatorId);
-  // 未领取任务仅允许预览，员工确认后由正式领取与清点接口再次检查权限和状态。
-  if("PENDING".equals(target.taskStatus()) && Boolean.TRUE.equals(target.palletSetupReady())
-     && "请先领取任务".equals(carton.blockReason())){
-   carton=new Carton(carton.cartonId(),carton.boxCode(),carton.inboundId(),carton.inboundCode(),
-    carton.skuLines(),carton.countStatus(),carton.palletId(),carton.palletNo(),true,null);
-  }
-  return new ScanContext(target,carton);
- }
-
- /** 按仓库返回真实托盘状态及全部成员，跨客户不改变每箱的原归属。 */
- public PalletWorkspace workspacePallet(long warehouseId,String palletNo){
-  String code=normalize(palletNo);
-  if(code==null) throw invalid("托盘码不能为空");
-  PalletRow row=workspaceRepository.pallet(warehouseId,code);
-  if(row==null) throw new BizException(ResultCode.NOT_FOUND,"当前仓库未找到该托盘码");
-  return new PalletWorkspace(palletView(row,null),workspaceRepository.members(row.getId()));
- }

 @Transactional
 public void createTask(InboundOrderEntity inbound,long operatorId,String operatorName) {
@@ -223,13 +195,11 @@ public class DropshipPalletizationService {
   .map(p->palletView(p,task.getInboundCode())).toList();
 }

- /** 跨客户归托仍须同仓、同渠道、同目的仓，并锁定开放托盘。 */
 private PalletRow requireAssignablePallet(TaskRow task,String palletNo){
-  PalletRow existing=workspaceRepository.lockPallet(palletNo);
+  PalletRow existing=mapper.palletByNo(palletNo);
  if(existing==null) throw new BizException(ResultCode.NOT_FOUND,"托盘码不存在，请扫描测量审核后生成的 DP 托盘码");
  if(!Objects.equals(existing.getWarehouseId(),task.getWarehouseId())) throw conflict("托盘码不属于当前作业仓库");
  if(!"OPEN".equals(existing.getPalletStatus())) throw conflict("托盘已封托，不能继续绑定箱");
-  if(!workspaceRepository.compatible(task.getId(),existing.getId())) throw conflict("托内货物与当前票的渠道或目的仓不同，不能混托");
  return existing;
 }

@@ -4,26 +4,6 @@ info:
  version: 3.0.0
  description: 测量环节录入预计托数，审核通过后预生成全部 DP 托盘码并可合并打印。PDA 支持先扫箱或先扫托，同一国内作业仓可跨票共用开放托盘，实物装满后再封托。
 paths:
-  /api/platform/v1/first-leg/pda-dropship/cartons/resolve:
-    get:
-      summary: 同仓跨客户识别箱码并预览原任务
-      description: 只读，不领取或清点；返回 task 与 carton，确认时仍须领取原任务后按原 taskId 清点。拒绝其他作业员已领取任务及箱码歧义。
-      x-required-authority: platform:firstleg:pda:view
-      parameters:
-        - {$ref: '#/components/parameters/WarehouseId'}
-        - {name: boxCode, in: query, required: true, schema: {type: string, minLength: 1, maxLength: 80}}
-      responses:
-        '200': {description: 原任务和箱内 SKU 预览}
-  /api/platform/v1/first-leg/pda-dropship/pallets/resolve:
-    get:
-      summary: 查询当前仓库真实托盘状态与逐客户逐票组成
-      description: 扫描不产生归托；返回 pallet 与 members，成员保留 taskId、inboundId、inboundCode、customerId、customerName、cartonCount。不存在或跨仓的托盘拒绝，已封托返回真实状态。
-      x-required-authority: platform:firstleg:pda:view
-      parameters:
-        - {$ref: '#/components/parameters/WarehouseId'}
-        - {name: palletNo, in: query, required: true, schema: {type: string, pattern: 'DP-[0-9]{6}-[0-9]{4}'}}
-      responses:
-        '200': {description: 实物托盘状态和成员汇总}
  /api/platform/v1/first-leg/pda-dropship/tasks/pending:
    get:
      summary: 查询待领取或本人已领取任务
@@ -24,56 +24,7 @@ class DropshipPalletizationServiceTest {
 private final FirstlegDocumentNumberGenerator numbers=mock(FirstlegDocumentNumberGenerator.class);
 private final DropshipPalletizationMapper mapper=mock(DropshipPalletizationMapper.class);
 private final DropshipPalletizationService service=new DropshipPalletizationService();
- private final com.baiyue.firstleg.repository.DropshipWorkspaceRepository workspace=mock(com.baiyue.firstleg.repository.DropshipWorkspaceRepository.class);
- /** 使用正式仓储入口的等价锁定查询，保留既有扫码测试的事实准备。 */
- DropshipPalletizationServiceTest(){ ReflectionTestUtils.setField(service,"mapper",mapper); ReflectionTestUtils.setField(service,"documentNumbers",numbers); ReflectionTestUtils.setField(service,"workspaceRepository",workspace); when(workspace.lockPallet(anyString())).thenAnswer(call -> mapper.palletByNo(call.getArgument(0))); when(workspace.compatible(anyLong(),anyLong())).thenReturn(true); when(mapper.labelSkus(anyLong(),anyLong())).thenAnswer(call -> java.util.List.of(labelSku())); when(mapper.cartonSkus(anyLong())).thenAnswer(call -> java.util.List.of(cartonSku())); }
-
- /** 跨客户预览不领取任务，不写入清点事实。 */
- @Test void workspaceResolvesPendingCustomerWithoutMutating(){
-  ReflectionTestUtils.setField(service,"workspaceRepository",workspace);
-  TaskRow other=task(); other.setTenantId(2L); other.setTaskStatus("PENDING"); other.setAssigneeId(null);
-  when(workspace.taskIdsForBox(100L,"BOX-1")).thenReturn(java.util.List.of(10L));
-  when(mapper.task(10L,100L)).thenReturn(other);
-  when(mapper.label(10L,"BOX-1")).thenReturn(label());
-  when(mapper.palletCountByInbound(2L,30L)).thenReturn(other.getExpectedPalletCount());
-  var result=service.resolveWorkspaceCarton(100L," BOX-1 ",7L);
-  assertThat(result.task().tenantId()).isEqualTo(2L);
-  assertThat(result.carton().canCount()).isTrue();
-  verify(mapper,never()).claim(anyLong(),anyLong(),anyLong(),anyString());
-  verify(mapper,never()).addCounted(anyLong(),anyLong(),anyInt(),anyInt());
- }
-
- /** 不允许从跨票扫码接管其他作业员的任务。 */
- @Test void workspaceRejectsOtherOperatorsTaskAndAmbiguousBox(){
-  ReflectionTestUtils.setField(service,"workspaceRepository",workspace);
-  when(workspace.taskIdsForBox(100L,"BOX-1")).thenReturn(java.util.List.of(10L));
-  TaskRow other=task(); other.setAssigneeId(9L); when(mapper.task(10L,100L)).thenReturn(other);
-  assertThatThrownBy(()->service.resolveWorkspaceCarton(100L,"BOX-1",7L)).isInstanceOf(BizException.class).hasMessageContaining("其他人员");
-  when(workspace.taskIdsForBox(100L,"BOX-1")).thenReturn(java.util.List.of(10L,11L));
-  assertThatThrownBy(()->service.resolveWorkspaceCarton(100L,"BOX-1",7L)).isInstanceOf(BizException.class).hasMessageContaining("多个任务");
- }
-
- /** 托盘预览必须返回已封托的真实状态，跨仓不存在时拒绝。 */
- @Test void workspacePalletNeverInventsOpenState(){
-  ReflectionTestUtils.setField(service,"workspaceRepository",workspace);
-  when(workspace.pallet(100L,"DP-260911-0001")).thenReturn(sealedPallet());
-  when(workspace.members(20L)).thenReturn(java.util.List.of());
-  when(mapper.cartons(20L)).thenReturn(java.util.List.of());
-  assertThat(service.workspacePallet(100L,"DP-260911-0001").pallet().status()).isEqualTo("SEALED");
-  assertThatThrownBy(()->service.workspacePallet(101L,"DP-260911-0001")).isInstanceOf(BizException.class).hasMessageContaining("未找到");
- }
-
- /** 即使不同客户允许混托，运输渠道或目的仓不同仍须拒绝。 */
- @Test void incompatibleDestinationCannotBeMixed(){
-  when(mapper.task(10L,100L)).thenReturn(task());
-  when(mapper.palletCountByInbound(1L,30L)).thenReturn(2);
-  when(mapper.label(10L,"BOX-1")).thenReturn(label());
-  when(mapper.palletByNo("DP-260911-0001")).thenReturn(pallet());
-  when(workspace.compatible(10L,20L)).thenReturn(false);
-  assertThatThrownBy(()->service.countCarton(10L,new CountCartonRequest(100L,"BOX-1",java.util.List.of(new CountSkuLine(40L,"SKU-1",12,DiscrepancyAction.MATCH,null)),"DP-260911-0001","wrong-destination"),7L,"张三"))
-   .isInstanceOf(BizException.class).hasMessageContaining("渠道或目的仓不同");
-  verify(mapper,never()).addCounted(anyLong(),anyLong(),anyInt(),anyInt());
- }
+ DropshipPalletizationServiceTest(){ ReflectionTestUtils.setField(service,"mapper",mapper); ReflectionTestUtils.setField(service,"documentNumbers",numbers); when(mapper.labelSkus(anyLong(),anyLong())).thenAnswer(call -> java.util.List.of(labelSku())); when(mapper.cartonSkus(anyLong())).thenAnswer(call -> java.util.List.of(cartonSku())); }

 @Test void sharedPalletCountsDistinctSkuCodesWithoutMergingInboundDetails(){
  when(mapper.inboundCode(1L,30L)).thenReturn("IN-1");
@@ -34,7 +34,7 @@
                <executions>
                    <execution>
                        <id>default-test</id>
-                        <configuration><excludes><exclude>**/*SqlSemanticTest.java</exclude></excludes></configuration>
+                        <configuration><reuseForks>false</reuseForks><excludes><exclude>**/*SqlSemanticTest.java</exclude></excludes></configuration>
                    </execution>
                    <!-- H2复杂查询规划与普通单测分进程，仍沿用父级1GB上限并执行全部断言。 -->
                    <execution>
@@ -35,6 +35,11 @@ public class AppointmentCargoService {
        return new PageResult<>(rows, page, size, total, (total + size - 1) / size);
    }

+    /** 查询下拉框与货物分页共用权威目录范围，不从当前页猜测目的仓。 */
+    public List<String> destinations() {
+        return scope().destinations().stream().distinct().sorted().toList();
+    }
+
    private record Scope(List<String> origins, List<String> destinations) { }
    private Scope scope() {
        final List<AppointmentWarehouseClient.Warehouse> catalog;
@@ -53,6 +53,14 @@ public class AppointmentPlanningController {
        return ApiResponse.success(new Resolved(source,result.get(0)));
    }

+    /** 目的仓选项沿用货物查询权限，只返回同范围的美国FBA仓码。 */
+    @GetMapping("/cargo/destinations")
+    @PreAuthorize("hasAuthority('platform:appointment:list') and hasAuthority('platform:overseas-warehouse:last-mile-order:list')")
+    public ApiResponse<java.util.List<String>> destinations(@AuthenticationPrincipal AuthenticatedUser user) {
+        requirePlatform(user);
+        return ApiResponse.success(service.destinations());
+    }
+
    @GetMapping("/cargo")
    @PreAuthorize("hasAuthority('platform:appointment:list') and hasAuthority('platform:overseas-warehouse:last-mile-order:list')")
    public ApiResponse<PageResult<AppointmentCargo>> cargo(@AuthenticationPrincipal AuthenticatedUser user,
@@ -1,30 +0,0 @@
-package com.baiyue.lastleg.delivery.repository;
-
-import com.baiyue.lastleg.delivery.entity.OutboundOrder;
-import com.baiyue.lastleg.delivery.mapper.OutboundPalletItemMapper;
-import jakarta.annotation.Resource;
-import org.springframework.stereotype.Repository;
-import java.util.HashSet;
-
-/** 出库查询按实物箱汇总，退货混装 SKU 不重复计箱。 */
-@Repository
-public class OutboundQuantityRepository {
-    @Resource private OutboundPalletItemMapper pallets;
-
-    /** 废弃退货来源依据已冻结箱唛计数，读取已有单据也不会把件数当箱数。 */
-    public Integer boxes(OutboundOrder outbound) {
-        if (!"DISCARD_OUTBOUND".equals(outbound.getOutboundType())) return outbound.getPackageCount();
-        var lines = pallets.findByOutbound(outbound.getCustomerId(), outbound.getId());
-        if (lines.isEmpty()) return outbound.getPackageCount();
-        var returnBoxes = new HashSet<String>();
-        int count = 0;
-        for (var line : lines) {
-            if (line.getReturnSkuQuantity() != null && line.getCartonMarks() != null && !line.getCartonMarks().isBlank()) {
-                returnBoxes.add(line.getInboundCode() + ":" + line.getCartonMarks());
-            } else {
-                count = Math.addExact(count, java.util.Objects.requireNonNullElse(line.getPackageCount(), 0));
-            }
-        }
-        return Math.addExact(count, returnBoxes.size());
-    }
-}
@@ -1,26 +0,0 @@
-package com.baiyue.lastleg.discard.model;
-
-import com.baiyue.lastleg.discard.entity.CargoDiscardItem;
-import java.util.HashSet;
-import java.util.List;
-
-/** 废弃单汇总使用物理箱数，退货明细的数量仍保留为 SKU 件数。 */
-public final class CargoDiscardQuantities {
-    /** 数量规则不需要实例化。 */
-    private CargoDiscardQuantities() { }
-
-    /** 退货混装箱按箱 ID 去重，其余来源累加已选择的物理箱数。 */
-    public static int boxes(List<CargoDiscardItem> lines, boolean actual) {
-        var returnBoxes = new HashSet<Long>();
-        int total = 0;
-        for (var line : lines) {
-            int quantity = actual ? java.util.Objects.requireNonNullElse(line.getActualDiscardPackages(), 0) : line.getDiscardPackages();
-            if (line.getReturnCartonId() != null) {
-                if (quantity > 0) returnBoxes.add(line.getReturnCartonId());
-            } else {
-                total = Math.addExact(total, quantity);
-            }
-        }
-        return Math.addExact(total, returnBoxes.size());
-    }
-}
@@ -19,9 +19,8 @@ public final class PdaCargoDiscardDtos {
                          List<@NotBlank String> scannedCartonMarks, Boolean confirmAllCartons) {
        public Confirm(List<ActualLine> lines, List<Long> photoFileIds) { this(lines, photoFileIds, null, false); }
    }
-    /** 明细数量按来源标识单位：退货库存为件，其余箱级库存为箱。 */
    public record Sku(Long itemId, String skuCode, String productName, int plannedPackages,
-                      Integer actualPackages, String status, String quantityUnit) { }
+                      Integer actualPackages, String status) { }
    public record PalletTask(String discardNo, String customerId, String overseasWarehouseId,
                             String palletNo, Long profileId, String status, List<Sku> skus, String outboundNo,
                             String scanMode, List<String> cartonMarks) { }
@@ -117,8 +117,8 @@ public class PdaCargoDiscardService {
            .forEach(cartonId -> adjustments.finishReturnCarton(application.getCustomerId(), cartonId));
        if (items.listApplication(application.getCustomerId(), application.getId()).stream()
            .allMatch(i -> "COMPLETED".equals(i.getPdaStatus()))) {
-            int actualTotal = com.baiyue.lastleg.discard.model.CargoDiscardQuantities.boxes(
-                items.listApplication(application.getCustomerId(), application.getId()), true);
+            int actualTotal = items.listApplication(application.getCustomerId(), application.getId()).stream()
+                .mapToInt(i -> i.getActualDiscardPackages() == null ? 0 : i.getActualDiscardPackages()).sum();
            application.setTotalPackages(actualTotal);
            application.setTotalFee(application.getFeePerPackage().multiply(java.math.BigDecimal.valueOf(actualTotal)));
            discardService.updateLinkedStatus(application.getCustomerId(), application, CargoDiscardService.APPROVED,
@@ -160,20 +160,16 @@ public class PdaCargoDiscardService {
    }

    private static final String LOOSE = "散箱";
-    /** 按实托汇总本单所选箱唛，退货件数与物理箱数分别呈现。 */
    private List<PdaCargoDiscardDtos.PalletTask> palletTasks(CargoDiscardApplication application) {
        var allItems = items.listApplication(application.getCustomerId(), application.getId());
        var grouped = allItems.stream().collect(Collectors.groupingBy(i -> physicalCode(application, i), LinkedHashMap::new, Collectors.toList()));
        return grouped.entrySet().stream().map(entry -> {
            CargoDiscardItem first = entry.getValue().get(0);
            var skus = entry.getValue().stream().map(i -> new PdaCargoDiscardDtos.Sku(i.getId(), i.getSkuCode(), i.getProductName(),
-                i.getDiscardPackages(), i.getActualDiscardPackages(), i.getPdaStatus() == null ? "PENDING" : i.getPdaStatus(),
-                isReturnItem(i) ? "件" : "箱")).toList();
+                i.getDiscardPackages(), i.getActualDiscardPackages(), i.getPdaStatus() == null ? "PENDING" : i.getPdaStatus())).toList();
            String status = skus.stream().allMatch(i -> "COMPLETED".equals(i.status())) ? "COMPLETED" : "PENDING";
            var marks = entry.getValue().stream().flatMap(i -> cartonMarks(application, i).stream()).distinct().sorted().toList();
-            // 退货箱只代表本单选择的箱子，不能因为有托盘号就当成整托废弃。
-            boolean cartonScan = LOOSE.equals(entry.getKey()) || entry.getValue().stream()
-                .anyMatch(i -> isReturnItem(i) || Boolean.TRUE.equals(i.getCartonScanRequired()));
+            boolean cartonScan = LOOSE.equals(entry.getKey()) || entry.getValue().stream().anyMatch(i -> Boolean.TRUE.equals(i.getCartonScanRequired()));
            if (cartonScan && marks.isEmpty()) throw conflict("散箱废弃任务缺少箱唛");
            return new PdaCargoDiscardDtos.PalletTask(application.getDiscardNo(), application.getCustomerId(), application.getOverseasWarehouseId(),
                entry.getKey(), first.getInventoryPositionId() != null ? first.getInventoryPositionId() : isReturnItem(first) ? first.getReturnCartonId() : first.getProfileId(),
@@ -1,19 +0,0 @@
-package com.baiyue.lastleg.discard.repository;
-
-import com.baiyue.lastleg.discard.entity.CargoDiscardApplication;
-import com.baiyue.lastleg.discard.mapper.CargoDiscardItemMapper;
-import com.baiyue.lastleg.discard.model.CargoDiscardQuantities;
-import jakarta.annotation.Resource;
-import org.springframework.stereotype.Repository;
-
-/** 从申请明细读取物理箱汇总，不修改历史库存或件数。 */
-@Repository
-public class CargoDiscardQuantityRepository {
-    @Resource private CargoDiscardItemMapper items;
-
-    /** 列表和详情均按所选实物箱展示；空明细保留申请自身快照。 */
-    public int boxes(CargoDiscardApplication application) {
-        var lines = items.listApplication(application.getCustomerId(), application.getId());
-        return lines.isEmpty() ? application.getTotalPackages() : CargoDiscardQuantities.boxes(lines, false);
-    }
-}
@@ -39,7 +39,7 @@ public class CargoDiscardOutboundService {
        return outbound == null ? null : outbound.getOutboundNo();
    }

-    /** 审核事务持有申请锁时创建出库投影，汇总箱数与退货件数分开保存。 */
+    // The caller holds the application lock and owns the approval transaction.
    public void create(CargoDiscardApplication application, String operatorId) {
        if (outbounds.findByIdempotency(application.getCustomerId(), key(application)) != null) return;
        var lines = items.listApplication(application.getCustomerId(), application.getId());
@@ -51,13 +51,12 @@ public class CargoDiscardOutboundService {
        outbound.setOutboundNo(orderNoGenerator.next("OUTBOUND", application.getOverseasWarehouseId(), outbound.getId()));
        outbound.setOverseasWarehouseId(application.getOverseasWarehouseId()); outbound.setOutboundType(TYPE);
        outbound.setLxCodes(null); outbound.setRecipientInfo("废弃单 " + application.getDiscardNo());
-        outbound.setStatus("WAIT_PICK"); outbound.setPackageCount(com.baiyue.lastleg.discard.model.CargoDiscardQuantities.boxes(lines, false));
+        outbound.setStatus("WAIT_PICK"); outbound.setPackageCount(application.getTotalPackages());
        outbound.setIdempotencyKey(key(application)); outbound.setRequestHash(key(application));
        outbound.setVolumeWeightKg(BigDecimal.ZERO); outbound.setVolumeCbm(BigDecimal.ZERO);
        outbound.setCreatedBy(operatorId); outbound.setCreatedAt(at); outbound.setUpdatedAt(at);
        var snapshots = new java.util.ArrayList<OutboundPalletItem>();
        var palletCodes = new java.util.HashSet<String>();
-        var returnBoxIds = new java.util.HashSet<Long>();
        for (var line : lines) {
            boolean returned = line.getReturnCartonId() != null || "RETURN_CARTON".equals(line.getSourceType());
            String palletNo;
@@ -84,12 +83,11 @@ public class CargoDiscardOutboundService {
            }
            if (palletNo != null && !palletNo.isBlank()) palletCodes.add(palletNo);
            OutboundPalletItem snapshot = new OutboundPalletItem();
-            // 出库明细与申请明细一一对应，仅作投影，不通过此表扣减库存。
+            // Stable one-to-one projection key in a separate table, never used to deduct stock.
            snapshot.setId(line.getId()); snapshot.setCustomerId(application.getCustomerId()); snapshot.setOutboundOrderId(outbound.getId());
            snapshot.setPalletNo(palletNo); snapshot.setSkuCode(line.getSkuCode()); snapshot.setInboundCode(line.getInboundCode());
            snapshot.setOrderRefs(application.getDiscardNo()); snapshot.setCartonMarks(cartonMarks);
-            snapshot.setPackageCount(returned ? (returnBoxIds.add(line.getReturnCartonId()) ? 1 : 0) : line.getDiscardPackages());
-            snapshot.setPickedPackageCount(0); snapshot.setStatus("WAIT_PICK");
+            snapshot.setPackageCount(line.getDiscardPackages()); snapshot.setPickedPackageCount(0); snapshot.setStatus("WAIT_PICK");
            if (returned) snapshot.setReturnSkuQuantity((long) line.getDiscardPackages());
            snapshot.setVolumeWeightKg(BigDecimal.ZERO); snapshot.setVolumeCbm(BigDecimal.ZERO); snapshot.setCreatedAt(at);
            snapshots.add(snapshot);
@@ -98,21 +96,15 @@ public class CargoDiscardOutboundService {
        snapshots.forEach(pallets::insert);
    }

-    /** 同步实物箱的拣货进度，退货 SKU 件数不进入箱数汇总。 */
    public void sync(CargoDiscardApplication application) {
        OutboundOrder outbound = outbounds.lockByIdempotency(application.getCustomerId(), key(application));
        if (outbound == null) throw conflict("废弃出库单不存在，请联系平台核对审核结果");
        var lines = items.listApplication(application.getCustomerId(), application.getId());
-        var returnBoxIds = new java.util.HashSet<Long>();
        for (var snapshot : pallets.findByOutbound(application.getCustomerId(), outbound.getId())) {
            var line = lines.stream().filter(i -> Objects.equals(i.getId(), snapshot.getId())).findFirst()
                .orElseThrow(() -> conflict("废弃出库明细关联失效"));
-            boolean returned = line.getReturnCartonId() != null;
-            int boxes = returned ? (returnBoxIds.add(line.getReturnCartonId()) ? 1 : 0) : line.getDiscardPackages();
-            snapshot.setPackageCount(boxes);
            if ("COMPLETED".equals(line.getPdaStatus())) {
-                snapshot.setPickedPackageCount(returned ? (Objects.requireNonNullElse(line.getActualDiscardPackages(), 0) > 0 ? boxes : 0)
-                    : Objects.requireNonNullElse(line.getActualDiscardPackages(), 0));
+                snapshot.setPickedPackageCount(Objects.requireNonNullElse(line.getActualDiscardPackages(), 0));
                snapshot.setStatus("PICKED");
            }
            if (CargoDiscardService.CANCELLED.equals(application.getStatus())) snapshot.setStatus("CANCELLED");
@@ -125,7 +117,7 @@ public class CargoDiscardOutboundService {
        };
        outbound.setStatus(status);
        outbound.setLxCodes(null);
-        outbound.setPackageCount(com.baiyue.lastleg.discard.model.CargoDiscardQuantities.boxes(lines, "OUTBOUNDED".equals(status)));
+        if ("OUTBOUNDED".equals(status)) outbound.setPackageCount(application.getTotalPackages());
        outbound.setUpdatedAt(LocalDateTime.now()); outbounds.updateById(outbound);
    }
    private static ResponseStatusException conflict(String message) { return new ResponseStatusException(HttpStatus.CONFLICT, message); }
@@ -50,7 +50,6 @@ import java.util.Set;

@Service
 public class CargoDiscardService {
-    @Resource private com.baiyue.lastleg.discard.repository.CargoDiscardQuantityRepository quantities;
    @Resource private com.baiyue.lastleg.service.LastlegOrderNoGenerator orderNoGenerator;
    public static final String APPROVAL_PERMISSION = "platform:overseas-warehouse:discard:approve";
    public static final String PENDING_REVIEW = "PENDING_REVIEW";
@@ -139,7 +138,6 @@ public class CargoDiscardService {
            supported ? null : "当前库存缺少完整箱唛，可按全部库存废弃");
    }

-    /** 校验并预留所选库存，物理箱汇总与退货 SKU 件数分别保留。 */
    @Transactional
    public CargoDiscardResponses.Detail create(String customerId, String operatorId,
                                               CargoDiscardRequests.Create request) {
@@ -200,8 +198,7 @@ public class CargoDiscardService {
            } else if (!warehouseId.equals(itemWarehouseId)) {
                throw conflict("One cargo discard application cannot span operating warehouses");
            }
-            // 退货明细为件数，整箱只在全部 SKU 校验完成后按箱 ID 计一次。
-            if (!returnSource) total = Math.addExact(total, input.discardPackages());
+            total = Math.addExact(total, input.discardPackages());
        }

        for (Long cartonId : returnCartonCache.keySet()) {
@@ -212,7 +209,6 @@ public class CargoDiscardService {
                .map(i -> i.skuCode().trim()).collect(java.util.stream.Collectors.toSet());
            if (!availableSkus.equals(requestedSkus)) throw conflict("目前不支持部分废弃，必须选择退货箱内全部 SKU 库存");
        }
-        total = Math.addExact(total, returnCartonCache.size());
        LocalDateTime now = LocalDateTime.now();
        if (!StringUtils.hasText(warehouseName)) warehouseName = warehouseNames().get(warehouseId);
        CargoDiscardApplication application = new CargoDiscardApplication();
@@ -510,12 +506,10 @@ public class CargoDiscardService {
        return names;
    }

-    /** 废弃列表与详情按物理箱汇总，并按每箱单价计算应展示费用。 */
    private CargoDiscardResponses.Summary summary(CargoDiscardApplication value, Map<String, String> names) {
-        int boxes = quantities.boxes(value);
        return new CargoDiscardResponses.Summary(value.getId(), value.getCustomerId(), value.getDiscardNo(), value.getInboundCodes(),
-            value.getOverseasWarehouseId(), StringUtils.hasText(value.getOverseasWarehouseName()) ? value.getOverseasWarehouseName() : names.get(value.getOverseasWarehouseId()), boxes,
-            value.getFeePerPackage() == null ? value.getTotalFee() : value.getFeePerPackage().multiply(BigDecimal.valueOf(boxes)), value.getCurrency(), value.getStatus(), value.getCreatedBy(), value.getCreatedAt(),
+            value.getOverseasWarehouseId(), StringUtils.hasText(value.getOverseasWarehouseName()) ? value.getOverseasWarehouseName() : names.get(value.getOverseasWarehouseId()), value.getTotalPackages(),
+            value.getTotalFee(), value.getCurrency(), value.getStatus(), value.getCreatedBy(), value.getCreatedAt(),
            value.getReviewedAt(), outboundService.outboundNo(value), value.getCustomerConfirmedAt());
    }

@@ -190,9 +190,7 @@ public class WarehouseTransferService {
    private List<WarehouseTransferResponses.SourceCarton> unreservedSourceCartons(String customerId,
            String warehouseId, String source, List<WarehouseTransferResponses.SourceCarton> cartons) {
        if (inventorySources == null) return cartons;
-        var occupiedMarks = inventorySources.occupiedMarks(customerId, warehouseId, source);
-        if (occupiedMarks == null || occupiedMarks.isEmpty()) return cartons;
-        Set<String> occupied = occupiedMarks.stream()
+        Set<String> occupied = inventorySources.occupiedMarks(customerId, warehouseId, source).stream()
            .filter(StringUtils::hasText).map(mark -> mark.trim().toUpperCase(java.util.Locale.ROOT))
            .collect(Collectors.toSet());
        return cartons.stream().filter(box -> !occupied.contains(box.cartonMark().trim()
@@ -485,6 +483,7 @@ public class WarehouseTransferService {
            // 所有同源提交锁定同一入仓记录；取锁后按最新可用箱校验并保存逐箱占用快照。
            if (inventorySources != null && inventorySources.lockSource(customerId, transfer.getInboundOrderId()) == null)
                throw conflict("库存来源已失效，请重新选择来源单");
+            if (inventorySources != null) reserveSourceCartons(customerId, transfer);
        }

        if (Boolean.TRUE.equals(transfer.getNeedRelabel())) {
@@ -500,11 +499,6 @@ public class WarehouseTransferService {
            }
        }

-        // 来源箱归属校验通过后再写入占用快照，保证错误箱号返回明确提示。
-        if (!transfer.getTransferNo().equals(transfer.getInboundCode()) && inventorySources != null) {
-            reserveSourceCartons(customerId, transfer);
-        }
-
        LastlegOrder order = requireTailOrder(customerId, transfer);
        LocalDateTime now = LocalDateTime.now();
        transfer.setStatus(PENDING_REVIEW);
@@ -6,6 +6,26 @@ info:
 security:
  - bearerAuth: []
 paths:
+  /api/platform/v1/last-leg/appointment-planning/cargo/destinations:
+    get:
+      operationId: listAppointmentCargoDestinations
+      summary: 读取预约货物查询的目的FBA仓选项
+      description: >-
+        仅平台；同时要求platform:appointment:list与platform:overseas-warehouse:last-mile-order:list。
+        与货物分页共用权威启用美国FBA目录，返回去重、按仓码排序的完整选项，不受货物当前分页或关键词限制。
+        不增加仓库主档读取权限；目录失败返回503，不当作空选项。
+      responses:
+        '200':
+          description: 业务响应；data为目的FBA仓码数组
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  code: {type: string}
+                  data: {type: array, items: {type: string}, example: [ABE4, ONT8]}
+        '403': {description: 非平台或缺少任一读取权限}
+        '503': {description: 权威目录不可用}
  /api/platform/v1/last-leg/appointment-planning/sources/resolve-order:
    get:
      operationId: resolveOrderAppointmentSource
@@ -8,6 +8,21 @@ import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.Mockito.*;

 class AppointmentCargoServiceTest {
+    /** 选项取完整权威美国FBA目录，不依赖当前页货物或新增仓库主档权限。 */
+    @Test void destinationOptionsUseTheSameAmericanFbaScopeWithoutQueryingCargoRows() {
+        var mapper = mock(AppointmentCargoMapper.class);
+        var warehouses = mock(AppointmentWarehouseClient.class);
+        when(warehouses.catalog("token")).thenReturn(ApiResponse.success(List.of(
+            new AppointmentWarehouseClient.Warehouse(1L,"US-WH","美国仓","OVERSEAS","US"),
+            new AppointmentWarehouseClient.Warehouse(2L,"ONT8","ONT8","FBA","US"),
+            new AppointmentWarehouseClient.Warehouse(3L,"ABE4","ABE4","FBA","US"),
+            new AppointmentWarehouseClient.Warehouse(4L,"YYZ1","YYZ1","FBA","CA"),
+            new AppointmentWarehouseClient.Warehouse(5L,"ONT8","ONT8","FBA","US"))));
+        assertEquals(List.of("ABE4","ONT8"),new AppointmentCargoService(mapper,warehouses,"token").destinations());
+        verifyNoInteractions(mapper);
+        when(warehouses.catalog("token")).thenThrow(new IllegalStateException("offline"));
+        assertEquals(503,assertThrows(ResponseStatusException.class,()->new AppointmentCargoService(mapper,warehouses,"token").destinations()).getStatusCode().value());
+    }
    @Test void authenticUsDirectoryScopesTheDatabaseQueryAndPreservesServerPagination() {
        var mapper = mock(AppointmentCargoMapper.class);
        var warehouses = mock(AppointmentWarehouseClient.class);
@@ -17,6 +17,20 @@ import static org.mockito.Mockito.*;

 class AppointmentPlanningAuthorizationTest {
    private static final String LIST="platform:appointment:list", CARGO="platform:overseas-warehouse:last-mile-order:list", WRITE="platform:appointment:followup";
+    /** 目的仓选项不要求仓库管理权限，但保留原两项读取权限和平台身份边界。 */
+    @Test void destinationOptionsRequireTheExistingCargoReadPermissionsAndPlatformIdentity() {
+        try(var context=new AnnotationConfigApplicationContext(Config.class)) {
+            var controller=context.getBean(AppointmentPlanningController.class);
+            var service=context.getBean(AppointmentCargoService.class);
+            login(LIST);assertThrows(AccessDeniedException.class,()->controller.destinations(user(0L,"PLATFORM")));
+            login(CARGO);assertThrows(AccessDeniedException.class,()->controller.destinations(user(0L,"PLATFORM")));
+            login(LIST,CARGO);
+            assertThrows(ResponseStatusException.class,()->controller.destinations(user(1L,"CLIENT")));
+            verifyNoInteractions(service);
+            when(service.destinations()).thenReturn(List.of("ABE4","ONT8"));
+            assertEquals(List.of("ABE4","ONT8"),controller.destinations(user(0L,"PLATFORM")).data());
+        } finally { SecurityContextHolder.clearContext(); }
+    }
    @Test void orderLookupUsesCanonicalBookingSourceAndEnforcesCustomerAndReadPermissions() {
        try(var context=new AnnotationConfigApplicationContext(Config.class)) {
            var controller=context.getBean(AppointmentPlanningController.class);
@@ -189,28 +189,6 @@ class PdaCargoDiscardServiceTest {
        verify(photoService).confirm(same(application), eq("散箱"), eq(List.of(101L)), eq(false));
    }

-    /** 退货一箱五件按指定箱作业，不得按五箱或整托处理。 */
-    @Test void returnCartonUsesPieceUnitAndRequiresSelectedCartonEvenWhenBoundToPallet() {
-        item.setSourceType("RETURN_CARTON"); item.setReturnCartonId(31L); item.setDiscardPackages(5);
-        var carton = new com.baiyue.lastleg.returnreceipt.entity.ReturnInventoryCarton();
-        carton.setCustomerId("CUSTOMER"); carton.setPalletCode("PALLET-1"); carton.setCartonMark("RETURN-BOX-1");
-        when(returnCartons.selectById(31L)).thenReturn(carton);
-        when(applications.selectList(any())).thenReturn(List.of(application));
-        var task = service.resolve(identity, "PALLET-1", "CD-1");
-        assertEquals("CARTON", task.scanMode());
-        assertEquals(List.of("RETURN-BOX-1"), task.cartonMarks());
-        assertEquals(5, task.skus().get(0).plannedPackages());
-        assertEquals("件", task.skus().get(0).quantityUnit());
-        assertThrows(ResponseStatusException.class, () -> service.confirm(identity, "CD-1", "PALLET-1", request(5)));
-        verifyNoInteractions(adjustments);
-        var confirm = new PdaCargoDiscardDtos.Confirm(List.of(new PdaCargoDiscardDtos.ActualLine(11L, 5)),
-            List.of(101L), List.of("RETURN-BOX-1"), false);
-        service.confirm(identity, "CD-1", "PALLET-1", confirm);
-        assertEquals(1, application.getTotalPackages());
-        assertEquals(new BigDecimal("5.00"), application.getTotalFee());
-        verify(adjustments).discardPalletItem(eq("CUSTOMER"), same(application), same(item), anyList(), eq(5), eq("OP"), any());
-    }
-
    @Test void partialBoundPalletOnlyExposesSelectedBoxesAndRequiresTheirScan() {
        looseTask(); item.setCartonScanRequired(true);
        var stockService = (com.baiyue.lastleg.discard.service.CargoDiscardStockService) ReflectionTestUtils.getField(service, "stockService");
@@ -104,23 +104,4 @@ class CargoDiscardOutboundServiceTest {
        assertThrows(ResponseStatusException.class, () -> service.create(application, "OP"));
        verify(outbounds, never()).insert(any(OutboundOrder.class)); verify(pallets, never()).insert(any(OutboundPalletItem.class));
    }
-
-    /** 同一退货箱含多个 SKU 时箱数只记一次，件数仍逐 SKU 保留。 */
-    @Test void returnCartonProjectionSeparatesOneBoxFromFivePiecesAndSyncsCompletion() {
-        first.setReturnCartonId(31L); first.setSourceType("RETURN_CARTON"); first.setDiscardPackages(2);
-        second.setReturnCartonId(31L); second.setSourceType("RETURN_CARTON"); second.setDiscardPackages(3);
-        var carton = new ReturnInventoryCarton(); carton.setCustomerId("C1"); carton.setOverseasWarehouseId("99");
-        carton.setCartonMark("BOX-31"); carton.setPalletCode("PALLET-1");
-        when(returnCartons.selectById(31L)).thenReturn(carton);
-        service.create(application, "OP");
-        assertEquals(1, document.getPackageCount());
-        assertEquals(1, snapshots.stream().mapToInt(OutboundPalletItem::getPackageCount).sum());
-        assertEquals(5, snapshots.stream().mapToLong(OutboundPalletItem::getReturnSkuQuantity).sum());
-        first.setPdaStatus("COMPLETED"); first.setActualDiscardPackages(2);
-        second.setPdaStatus("COMPLETED"); second.setActualDiscardPackages(3);
-        application.setStatus("PDA_COMPLETED");
-        service.sync(application);
-        assertEquals(1, document.getPackageCount());
-        assertEquals(1, snapshots.stream().mapToInt(OutboundPalletItem::getPickedPackageCount).sum());
-    }
 }
@@ -99,9 +99,6 @@ class CargoDiscardServiceTest {
    @BeforeEach
    void setUp() {
        service = new CargoDiscardService();
-        var quantities = new com.baiyue.lastleg.discard.repository.CargoDiscardQuantityRepository();
-        ReflectionTestUtils.setField(quantities, "items", items);
-        ReflectionTestUtils.setField(service, "quantities", quantities);
        ReflectionTestUtils.setField(service, "warehouseDirectory", warehouseDirectory);
        lenient().when(warehouseDirectory.receivingWarehouses(any())).thenReturn(com.baiyue.common.core.api.ApiResponse.success(List.of(
            new com.baiyue.lastleg.client.DomesticWarehouseDirectoryClient.ReceivingWarehouse(99L, "LAX", "洛杉矶仓", "US", "ACTIVE"))));
@@ -230,32 +227,6 @@ class CargoDiscardServiceTest {
        assertEquals("SKU-RETURN", result.get(0).skus().get(0).skuCode());
    }

-    /** 创建和已有单据查询均按退货箱去重，五件不可计为五箱。 */
-    @Test void returnMixedSkuCartonCreatesOneBoxAndExistingSummaryReadsOneBox() {
-        var carton = new ReturnInventoryCarton(); carton.setId(901L); carton.setCustomerId("100");
-        carton.setOverseasWarehouseId("99"); carton.setSourceReturnNo("RT-1"); carton.setCartonMark("BOX-1");
-        carton.setStatus("AVAILABLE");
-        var skuA = new ReturnInventoryCartonItem(); skuA.setSkuCode("A"); skuA.setQuantity(2L);
-        var skuB = new ReturnInventoryCartonItem(); skuB.setSkuCode("B"); skuB.setQuantity(3L);
-        when(returnCartons.lockId(901L)).thenReturn(carton);
-        when(returnCartons.selectById(901L)).thenReturn(carton);
-        when(returnCartonItems.lockSku(901L, "A")).thenReturn(skuA);
-        when(returnCartonItems.lockSku(901L, "B")).thenReturn(skuB);
-        when(returnCartonItems.lockCarton(901L)).thenReturn(List.of(skuA, skuB));
-        when(returnCartons.markDiscardPending(901L, "100")).thenReturn(1);
-        var detail = service.create("100", "OP", new CargoDiscardRequests.Create(List.of(
-            new CargoDiscardRequests.Item(null, 901L, "A", 2),
-            new CargoDiscardRequests.Item(null, 901L, "B", 3)), "return-five-pieces", null));
-        assertEquals(1, storedApplication.get().getTotalPackages());
-        assertEquals(new BigDecimal("5.00"), storedApplication.get().getTotalFee());
-        assertEquals(1, detail.summary().totalPackages());
-        assertEquals(5, storedItems.stream().mapToInt(CargoDiscardItem::getDiscardPackages).sum());
-        storedApplication.get().setTotalPackages(5); storedApplication.get().setTotalFee(new BigDecimal("25.00"));
-        var existing = service.detail("100", storedApplication.get().getDiscardNo());
-        assertEquals(1, existing.summary().totalPackages());
-        assertEquals(new BigDecimal("5.00"), existing.summary().totalFee());
-    }
-
    @Test
    void approvalPushesToPdaWithoutDeductingInventory() {
        CargoDiscardApplication application = pendingApplication();
@@ -513,7 +513,7 @@ class WarehouseTransferServiceTest {
        verifyNoInteractions(transfers);
    }

-    /** 先按原订单来源快照拒绝外部换标箱，不进入后续选箱占用。 */
+    /** 来源箱快照先通过占用校验，再单独拒绝草稿中的外部换标箱。 */
    @Test
    void submittingOldDraftRechecksRelabelCartonOwnership() {
        var transfer = transfer(WarehouseTransferService.DRAFT);
@@ -521,6 +521,9 @@ class WarehouseTransferServiceTest {
        transfer.setInboundCode("IN-1");
        transfer.setNeedRelabel(true);
        transfer.setPackageCount(1);
+        var selected = new WarehouseTransferCarton();
+        selected.setId(51L); selected.setCustomerCartonMark("CURRENT-BOX");
+        when(transferCartons.listOrder("TENANT-A", transfer.getId())).thenReturn(List.of(selected));
        when(inboundSnapshots.sourceCartons("TENANT-A", "WH-1", "IN-1"))
            .thenReturn(List.of(new InboundSnapshotMapper.SourceCarton("CURRENT-BOX", "SKU-1", null, null, null, null, null)));
        when(transfers.lockNo("TENANT-A", "WTR-1")).thenReturn(transfer);
@@ -11,7 +11,7 @@ const OPTIONAL_MODULES = ['phase5-root-fulfillment', 'phase4-overseas-return-fol
  'manual-pda-ready-fixture', 'manual-pda-ready-verify',
  'manual-pda-batch-fixture', 'manual-pda-batch-verify',
  'manual-loading-complete-fixture', 'manual-loading-complete-verify',
-  'coload-groups', 'dropship-pallet-matrix', 'dropship-mixed-palletization', 'dropship-physical-carton-chain', 'dropship-browser-fixture', 'mixed-container-receiving', 'pda-loading-link-regression', 'fleet-vehicle-care', 'fleet-driver-qualification']
+  'coload-groups', 'dropship-pallet-matrix', 'dropship-physical-carton-chain', 'dropship-browser-fixture', 'mixed-container-receiving', 'pda-loading-link-regression', 'fleet-vehicle-care', 'fleet-driver-qualification']
 const AVAILABLE_MODULES = new Set([...CONFIGURED_MODULES, ...OPTIONAL_MODULES])
 const A0_LOCATION_PAGE_SIZE = 200
 const A0_MAX_LOCATION_MUTATIONS = 8
@@ -61,7 +61,6 @@ const MODULE_DEPENDENCIES = new Map([
  ['pda-loading-link-regression', ['merchant-qualification-fixture']],
  ['phase4-overseas-return-followups', ['phase4-overseas-return-receipt']],
  ['dropship-pallet-matrix', ['merchant-qualification-fixture']],
-  ['dropship-mixed-palletization', ['merchant-qualification-fixture']],
  ['dropship-physical-carton-chain', ['merchant-qualification-fixture']],
  ['dropship-browser-fixture', ['merchant-qualification-fixture']],
  ['mixed-container-receiving', ['merchant-qualification-fixture']],
@@ -172,8 +172,6 @@ export async function run(context) {

 `dropship-browser-fixture.mjs` 通过总入口 `--modules dropship-browser-fixture` 执行，自动依赖客户资质准备；复用矩阵生产者创建一票四箱两托，完成国内装柜、船节点和按柜生成海外入库计划，明确停在 `READY_FOR_BROWSER_RECEIVING`。只准备新测试数据，不调用海外 PDA 收货或出库、不创建海外操作员；后续由浏览器页面验收。报告仍保存于 `createdResources.dropshipPalletMatrix`，准备通过不代表全流程通过，不自动删除数据。

-`dropship-mixed-palletization.mjs` 通过总入口 `--modules dropship-mixed-palletization` 执行，自动依赖客户资质准备。经正式 HTTP 创建两客户三票一件代发（2/3/1 个物理箱，每箱两个 SKU），完成下单审核和测量，交替调用跨客户箱码预览、领取、清点、先箱后托批绑、移回/归回、六箱混托封托、解封和重新封托。核对客户/入仓单/SKU/数量守恒、只读识别无写入、同键重放、未知码/跨仓拒绝及逐票待分柜；结果保存在 `createdResources.dropshipMixedPalletization`。使用显式目标环境文件，开发机获授权时 Gateway 必须显式指向本机。会创建并保留客户、订单、测量与托盘数据，不自动清理；失败必须检查报告，重跑创建新批次。终点为 `MIXED_PALLET_SEALED_VERIFIED`，不代表装柜、海外履约或 Android 真机验收通过。
-
 `dropship-pallet-matrix.mjs` 验证下述四场景整托手工加入、整托移除、智能推荐、独立订舱与文件放舱、真实柜号关联、预装确认、PDA 整托拣货和五类证据上传；异步装柜完成必须等到任务 `COMPLETED` 并逐票回查 `LOADED`。智能装柜的托盘汇总与装柜详情逐票组成分别核对，不能把共托汇总行的首票编号当作全托归属。随后经正式报关、国内离仓及人工船节点接口推进至 `PICKUP_READY`，再按柜生成逐票海外入库计划，检查来源托盘完整绑定、共享托盘身份一致和同键重放。海外收货使用本轮创建并绑定接柜仓的 PDA 操作员，上传三类照片、签收、逐实物托盘收货、逐票箱数核平和完成入库，同键重放及同托新键扫码均不得重复入账。随后从本轮逐票库存候选创建一件代发专用出库，携带原始箱唛由 PDA 拣货、完成，核对终态、幂等和可用库存扣减；finally 停用本轮操作员。出库重放按业务身份和数据库毫秒时间精度核对。离线合同为 `dropship-pallet-matrix-contract.test.mjs`；脚本覆盖不等于真实 HTTP 已通过，须检查当轮报告和库存审计。

 `dropship-physical-carton-chain.mjs` 复用同一条正式链路，专门覆盖多 SKU 共用物理箱：20 箱×2 SKU/2 托、5 箱×3 SKU/1 托、7 箱×2 SKU/预计 2 托后合为 1 托。每个场景从新订单、测量、箱唛冻结和 PDA 清点开始，按去重箱唛核对预装、装柜、尾程计划、海外整托收货、库存候选和一件代发出库；每箱必须保留全部 SKU 明细，但任何汇总不得按 SKU 行重复累计箱数。使用 `--modules dropship-physical-carton-chain`，会保留本轮业务数据和 JSON 报告，不自动清理。
@@ -1,134 +0,0 @@
-import { run as createOrder } from './orders.mjs'
-import { run as measure } from './inbound-measurement.mjs'
-import { run as createCustomer } from './merchant-qualification-fixture.mjs'
-
-const MODULE = 'dropship-mixed-palletization'
-const BASE = '/api/platform/v1/first-leg/pda-dropship'
-const OPTIONS = { scenario: MODULE, deploymentBlocker: true }
-
-// 正式下单和测量产生两客户三票，再用 PDA 公网接口逐箱混托并保留全部证据。
-export async function run(context) {
-  const originalMarker = context.marker
-  const savedContext = { ...context.context }
-  const originalManualCount = context.options.prepareDropshipManualCount
-  const records = []
-  const result = { marker: originalMarker, stage: 'PREPARING', records, fullFlowVerified: false }
-  context.createdResources.dropshipMixedPalletization = result
-  function check(name, response, passed, details = '') {
-    context.assert(MODULE, name, response, passed, details, OPTIONS)
-    if (!passed) throw new Error(name)
-  }
-  async function command(name, method, path, body, headers = {}) {
-    const response = await context.request(method, path, body, undefined, headers)
-    const value = context.apiSuccess(MODULE, name, response, '', OPTIONS)
-    if (String(response?.body?.code) !== '200') throw new Error(`${name}: ${response?.body?.code}: ${response?.body?.message}`)
-    return value
-  }
-  async function rejected(name, method, path, body) {
-    const response = await context.request(method, path, body)
-    check(name, response, response.http === 200 && ['A0404', 'A0409'].includes(String(response.body?.code)), response.body?.message)
-  }
-  async function readTask(record) {
-    return command(`${record.label}回查任务`, 'GET', `${BASE}/tasks/${record.source.taskId}?warehouseId=${record.source.warehouseId}`)
-  }
-  try {
-    check('存在本轮已审核客户', null, Boolean(context.context.merchantQualificationFixture?.tenantId))
-    for (const [index, count] of [2, 3, 1].entries()) {
-      const label = ['A-2BOX', 'B-3BOX', 'B-1BOX'][index]
-      context.marker = `${originalMarker}-${label}`
-      if (index === 1) await createCustomer(context, { publishEnvironment: false })
-      for (const key of ['orders', 'inboundMeasurement', 'dropshipManualCount']) delete context.createdResources[key]
-      for (const key of ['inboundWeightOcr', 'ocrInbound', 'testInbound', 'createdInbound']) delete context.context[key]
-      context.context.orderDestinationType = 'OVERSEAS'
-      context.context.orderFulfillmentType = 'ONE_CLICK_DROPSHIP'
-      context.context.orderProfile = { taxMode: 'BUY_DECLARATION', pickupMethod: 'SELF_EXPRESS', containerMode: 'LCL' }
-      context.context.waitSplitVariant = { skuCount: 2, packageCountPerSku: count, packageCounts: [count, count],
-        totalPackageCount: count, palletCount: 1, skuCodes: [`MIX-SAME-${originalMarker}`.slice(-60), `MIX-SECOND-${originalMarker}`.slice(-60)] }
-      if (records.length) context.context.waitSplitRoute = { originWarehouseName: records[0].order.receivingWarehouseName,
-        channelCode: records[0].order.channelCode, destinationIndex: 0 }
-      context.options.prepareDropshipManualCount = true
-      const start = context.steps.length
-      await createOrder(context)
-      await measure(context)
-      const source = context.createdResources.dropshipManualCount
-      check(`${label}真实下单审核测量全部通过`, null, Boolean(source?.taskId)
-        && !context.steps.slice(start).some((step) => !step.passed))
-      records.push({ label, order: { ...context.createdResources.orders }, measurement: { ...context.createdResources.inboundMeasurement }, source: { ...source } })
-      check(`${label}实测物理箱数正确`, null, source.totalCartons === count)
-    }
-    check('两客户三票保持独立归属', null, records.length === 3 && new Set(records.map((r) => r.order.tenantId)).size === 2)
-    check('三票同仓同渠道同目的仓', null, records.every((r) => r.source.warehouseId === records[0].source.warehouseId
-      && r.order.channelCode === records[0].order.channelCode && r.order.destinationWarehouseId === records[0].order.destinationWarehouseId))
-    context.marker = originalMarker
-    const warehouseId = records[0].source.warehouseId
-    const query = `warehouseId=${warehouseId}`
-    const generated = await command('读取第一票预生成托盘', 'GET', `${BASE}/inbound-orders/${records[0].source.inboundId}/pallets?accountId=${records[0].order.tenantId}`)
-    const palletNo = generated?.[0]?.palletNo
-    check('取得空的预生成DP托盘', null, Boolean(palletNo) && generated[0].status === 'OPEN' && generated[0].cartonCount === 0)
-    result.palletNo = palletNo; result.warehouseId = warehouseId
-    const palletPath = `${BASE}/pallets/resolve?${query}&palletNo=${encodeURIComponent(palletNo)}`
-    const initial = await command('先扫空托盘只读识别', 'GET', palletPath)
-    check('空托盘不会虚构客户组成', null, initial.pallet.cartonCount === 0 && initial.members.length === 0)
-    await rejected('无效托盘码被拒绝', 'GET', `${BASE}/pallets/resolve?${query}&palletNo=DP-000000-0000`)
-    await rejected('跨仓托盘码被拒绝', 'GET', `${BASE}/pallets/resolve?warehouseId=1&palletNo=${encodeURIComponent(palletNo)}`)
-    await rejected('无效箱码被拒绝', 'GET', `${BASE}/cartons/resolve?${query}&boxCode=NO-SUCH-${originalMarker}`)
-    result.stage = 'COUNTING'
-    const counted = []
-    // 交替扫描客户 A/B，证明页面无需先手工切换入仓单。
-    const scans = records.flatMap((record) => Array.from({ length: record.source.totalCartons }, (_, index) => ({ record, boxCode: `${record.source.inboundCode}#${record.source.totalCartons}-${index + 1}` })))
-    scans.sort((a, b) => Number(a.boxCode.split('-').at(-1)) - Number(b.boxCode.split('-').at(-1)))
-    for (const [index, { record, boxCode }] of scans.entries()) {
-      const resolved = await command('跨客户只读扫码预览', 'GET', `${BASE}/cartons/resolve?${query}&boxCode=${encodeURIComponent(boxCode)}`)
-      check('箱码返回原客户和原入仓任务', null, String(resolved.task.taskId) === record.source.taskId
-        && String(resolved.task.tenantId) === record.order.tenantId && resolved.carton.skuLines.length === 2)
-      const before = await readTask(record)
-      check('读取箱码未改变清点和归托事实', null, before.countedCartons === counted.filter((x) => x.taskId === record.source.taskId).length)
-      if (before.taskStatus === 'PENDING') await command('确认时领取原任务', 'POST', `${BASE}/tasks/${record.source.taskId}/claim`, { warehouseId })
-      const body = { warehouseId, boxCode, palletNo: index === 0 ? null : palletNo,
-        skuLines: resolved.carton.skuLines.map((line) => ({ inboundDetailId: line.inboundDetailId, skuCode: line.skuCode,
-          actualQuantity: line.expectedQuantity, discrepancyAction: 'MATCH' })), operationId: `${originalMarker}-count-${index}` }
-      const submitted = await command('按原任务确认逐箱实收', 'POST', `${BASE}/tasks/${record.source.taskId}/cartons/count`, body)
-      const replayed = await command('清点同键重放不重复入账', 'POST', `${BASE}/tasks/${record.source.taskId}/cartons/count`, body)
-      check('重放保持箱身份和清点数量', null, submitted.carton.cartonId === replayed.carton.cartonId && submitted.countedCartons === replayed.countedCartons)
-      counted.push({ taskId: record.source.taskId, boxCode, cartonId: submitted.carton.cartonId, inboundId: record.source.inboundId, skuLines: body.skuLines })
-      if (index === 0) await command('先扫箱再扫托盘批量归托', 'POST', `${BASE}/tasks/${record.source.taskId}/pallets/bind-pending`, { warehouseId, palletNo, operationId: `${originalMarker}-bind` })
-    }
-    const beforeSeal = await command('封托前逐客户汇总核对', 'GET', palletPath)
-    check('六个实物箱两客户三票汇总守恒', null, beforeSeal.pallet.cartonCount === 6 && beforeSeal.members.length === 3
-      && new Set(beforeSeal.members.map((m) => String(m.customerId))).size === 2
-      && beforeSeal.members.every((m) => m.cartonCount === records.find((r) => r.source.taskId === String(m.taskId))?.source.totalCartons))
-    const moved = counted.find((item) => item.taskId === records[1].source.taskId)
-    await command('按客户B原任务移回待绑托', 'POST', `${BASE}/tasks/${moved.taskId}/cartons/${moved.cartonId}/move`, { warehouseId, targetPalletNo: null, operationId: `${originalMarker}-move-out` })
-    const movedTask = await readTask(records[1])
-    check('只改变原票归托数量', null, movedTask.unboundCartons === 1 && movedTask.countedCartons === 3)
-    await command('客户B已点箱归回当前混托', 'POST', `${BASE}/tasks/${moved.taskId}/cartons/${moved.cartonId}/move`, { warehouseId, targetPalletNo: palletNo, operationId: `${originalMarker}-move-back` })
-    const open = await command('归回后读取权威托盘', 'GET', palletPath)
-    const sealPath = `${BASE}/tasks/${records[0].source.taskId}/pallets/${open.pallet.palletId}/seal`
-    await command('混托整托封托', 'POST', sealPath, { warehouseId, expectedVersion: open.pallet.version, operationId: `${originalMarker}-seal` })
-    let sealed = await command('回查已封托状态', 'GET', palletPath)
-    check('托盘已封托且六箱完整', null, sealed.pallet.status === 'SEALED' && sealed.pallet.cartonCount === 6)
-    for (const record of records) {
-      record.task = await readTask(record)
-      const inbound = await command('封托后回查原票待分柜', 'GET', `/api/platform/inbounds/${record.source.inboundId}?tenantId=${record.order.tenantId}`)
-      check('参与票全部完成且进入待分柜', null, record.task.taskStatus === 'COMPLETED' && inbound.summary.processStatus === 'WAIT_SPLIT')
-    }
-    const actual = sealed.pallet.cartons
-    check('每箱客户归属和双SKU实收未合并', null, actual.length === counted.length && actual.every((carton) => {
-      const source = counted.find((item) => item.boxCode === carton.boxCode)
-      return source && String(carton.inboundId) === source.inboundId && carton.skuLines.length === 2
-        && carton.skuLines.every((line) => source.skuLines.some((expected) => String(line.inboundDetailId) === String(expected.inboundDetailId) && line.actualQuantity === expected.actualQuantity))
-    }))
-    await rejected('已封托禁止移箱', 'POST', `${BASE}/tasks/${moved.taskId}/cartons/${moved.cartonId}/move`, { warehouseId, targetPalletNo: null, operationId: `${originalMarker}-sealed-move` })
-    await command('未入装柜计划允许解除封托', 'POST', `${BASE}/tasks/${records[0].source.taskId}/pallets/${sealed.pallet.palletId}/unseal`, { warehouseId, expectedVersion: sealed.pallet.version, operationId: `${originalMarker}-unseal` })
-    for (const record of records) check('解封同步恢复所有参与任务', null, (await readTask(record)).taskStatus === 'CLAIMED')
-    const reopened = await command('回查解封后开放状态', 'GET', palletPath)
-    await command('核对后重新封托', 'POST', sealPath, { warehouseId, expectedVersion: reopened.pallet.version, operationId: `${originalMarker}-reseal` })
-    sealed = await command('最终托盘事实', 'GET', palletPath)
-    result.pallet = sealed.pallet; result.members = sealed.members; result.counted = counted
-    result.stage = 'MIXED_PALLET_SEALED_VERIFIED'
-    for (const record of records) record.task = await readTask(record)
-  } finally {
-    context.marker = originalMarker; context.context = savedContext
-    context.options.prepareDropshipManualCount = originalManualCount
-  }
-}
Author	SHA1	Message	Date
ouyangxq	d7616899d8	Unify dispatch operations with matched published transfer fixture	2026-10-20 00:29:25 +08:00
ouyangxq	a563f63857	feat(appointments): expose destination warehouse options	2026-10-19 17:02:25 +08:00