提交

lastleg-service/src/main/java/com/baiyue/lastleg/controller/LastlegOrderController.java

@@ -91,6 +91,15 @@ public class LastlegOrderController {
         return ApiResponse.success(orderService.page(platformScope(user, customerId), query, relabelNo));
     }
 
+    /** 按主列表完整筛选读取仓储转运数量，保持同一平台客户边界和列表权限。 */
+    @GetMapping("/api/platform/v1/last-leg/orders/warehouse-transfer-quantities")
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.LAST_MILE_ORDER_LIST + "')")
+    public ApiResponse<com.baiyue.lastleg.transfer.dto.TransferQuantityTotals> transferQuantities(
+        @AuthenticationPrincipal AuthenticatedUser user, @RequestParam(required=false) String customerId,
+        @RequestParam(required=false) String relabelNo, @Valid LastlegOrderRequests.Query query) {
+        return ApiResponse.success(orderService.transferQuantityTotals(platformScope(user,customerId),query,relabelNo));
+    }
+
     /** Compatibility overload used by non-Spring callers and existing contract tests. */
     public ApiResponse<PageResult<LastlegOrderSummary>> list(
         AuthenticatedUser user, String customerId, LastlegOrderRequests.Query query) {

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/service/DeliveryTransferService.java

@@ -597,12 +597,19 @@ public class DeliveryTransferService {
             if (application == null || !RelabelApplicationService.READY_FOR_OUTBOUND.equals(application.getStatus())) {
                 throw conflict("换标单尚未完成客户确认或已不可出库");
             }
+            if (relabelSnapshotMarks(item, selectedPosition.getId(), application.getRelabelNo()).isEmpty())
+                throw conflict("换标出库指定位置或箱唛快照不完整，请核对原申请");
             List<RelabelItem> sourceItems = relabelItems.selectList(new LambdaQueryWrapper<RelabelItem>()
                 .eq(RelabelItem::getApplicationId, application.getId())
                 .eq(RelabelItem::getCustomerId, customerId)
                 .eq(RelabelItem::getSourceInventoryPositionId, request.inventoryPositionId()));
             long sourcePackages = sourceItems.stream().mapToLong(source -> value(source.getNotifiedPackageCount())).sum();
-            if (sourcePackages != request.packages()) throw conflict("换标出库来源库存快照与任务箱数不一致");
+            List<String> sourceMarks = sourceItems.stream().map(RelabelItem::getCartonMark)
+                .filter(StringUtils::hasText).distinct().sorted().toList();
+            Set<String> sourceIds = sourceItems.stream().map(source -> String.valueOf(source.getId())).collect(Collectors.toSet());
+            if (sourcePackages != request.packages() || !sourceMarks.equals(expectedMarks)
+                || !sourceIds.equals(relabelSnapshotItemIds(item)))
+                throw conflict("换标出库来源库存快照与任务箱数或箱唛不一致");
             int releaseIndex = 0;
             for (RelabelItem source : sourceItems) {
                 inventoryCommands.release(customerId, operatorId, new InventoryCommandRequests.Move(
@@ -720,6 +727,7 @@ public class DeliveryTransferService {
         return taskResult(outbound, task);
     }
 
+    /** 扫描整托前核平全部指定来源，任一不足时不执行部分拣货。 */
     @Transactional
     public DeliveryResponses.PdaTask pdaPickPallet(String warehouseId, String operatorId, String taskNo,
                                                     String palletNo, DeliveryRequests.PdaPalletPick request) {
@@ -769,7 +777,7 @@ public class DeliveryTransferService {
             long remaining = value(item.getPackageCount()) - value(item.getPickedPackageCount());
             if (remaining <= 0) continue;
             Map<Long, List<DeliveryResponses.PdaPickPosition>> positionsById = pdaPickPositions(
-                task.getCustomerId(), boundWarehouseId, item).stream().collect(Collectors.groupingBy(
+                task.getCustomerId(), boundWarehouseId, item, outbound.getOutboundType()).stream().collect(Collectors.groupingBy(
                     DeliveryResponses.PdaPickPosition::inventoryPositionId, LinkedHashMap::new, Collectors.toList()));
             for (Map.Entry<Long, List<DeliveryResponses.PdaPickPosition>> entry : positionsById.entrySet()) {
                 if (remaining <= 0) break;
@@ -1049,6 +1057,7 @@ public class DeliveryTransferService {
             .map(task -> taskResult(requireOutboundInWarehouse(task, boundWarehouseId), task)).toList();
     }
 
+    /** PDA明细展示与整托拣货使用相同的客户、仓库及来源投影。 */
     public DeliveryResponses.PdaTaskDetail pdaTaskDetail(String warehouseId, String taskNo) {
         String boundWarehouseId = required(warehouseId, "PDA warehouse binding is required");
         OutboundPdaTask task = pdaTasks.findByNoAndWarehouse(required(taskNo, "PDA task number is required"),
@@ -1061,7 +1070,7 @@ public class DeliveryTransferService {
                 value(item.getPickedPackageCount()), item.getStatus(),
                 ("RETURN_OUTBOUND".equals(outbound.getOutboundType())
                     || ("RELABEL_OUTBOUND".equals(outbound.getOutboundType()) && item.getWarehousePalletId() == null)) ? returnPickPositions(outbound, task, item)
-                    : pdaPickPositions(task.getCustomerId(), boundWarehouseId, item), item.getReturnSkuQuantity())).toList();
+                    : pdaPickPositions(task.getCustomerId(), boundWarehouseId, item, outbound.getOutboundType()), item.getReturnSkuQuantity())).toList();
         return new DeliveryResponses.PdaTaskDetail(taskResult(outbound, task), items);
     }
 
@@ -1119,13 +1128,28 @@ public class DeliveryTransferService {
                 && value(item.getPickedPackageCount()) == 0 && "OUTBOUND_PENDING".equals(carton.getStatus()) ? 1 : 0, value(item.getPickedPackageCount())));
     }
 
+    /** 换标使用指定实物箱及仍归本单的冻结库存；普通出库继续按可用库存和SKU匹配。 */
     private List<DeliveryResponses.PdaPickPosition> pdaPickPositions(String customerId, String warehouseId,
-                                                                      OutboundPalletItem item) {
+                                                                      OutboundPalletItem item, String outboundType) {
         if (item.getWarehousePalletId() == null) return List.of();
         List<DeliveryResponses.PdaPickPosition> result = new ArrayList<>();
         Set<String> frozenMarks = new HashSet<>(Arrays.asList(
             Optional.ofNullable(item.getCartonMarks()).orElse("").split(",")));
         for (InventoryPosition position : inventoryPositions.listPallet(customerId, item.getWarehousePalletId())) {
+            if ("RELABEL_OUTBOUND".equals(outboundType)) {
+                List<String> marks = relabelSnapshotMarks(item, position.getId(), null);
+                InventoryBalance balance = inventoryBalances.selectById(position.getBalanceId());
+                if (marks.isEmpty() || !customerId.equals(position.getCustomerId())
+                    || !warehouseId.equals(position.getOverseasWarehouseId())
+                    || !Objects.equals(item.getWarehousePalletId(), position.getPalletId())
+                    || balance == null || !customerId.equals(balance.getCustomerId())
+                    || !warehouseId.equals(balance.getOverseasWarehouseId())
+                    || !Objects.equals(item.getInboundCode(), balance.getInboundCode())
+                    || value(position.getHoldPackages()) < marks.size()) continue;
+                // 本单冻结箱先在写路径校验原申请和来源任务，再释放、分配、拣货、出库；不把其他可用箱混入。
+                for (String mark : marks) result.add(pdaPosition(position, item, balance, mark, 1, 0));
+                continue;
+            }
             long available = value(position.getAvailablePackages());
             if (available <= 0 || !warehouseId.equals(position.getOverseasWarehouseId())) continue;
             InventoryBalance balance = inventoryBalances.selectById(position.getBalanceId());
@@ -1147,6 +1171,37 @@ public class DeliveryTransferService {
         return result;
     }
 
+    /** 仅接受完整的换标出库快照；空SKU不是通配符，必须精确匹配返工后冻结的位置和全部箱唛。 */
+    private List<String> relabelSnapshotMarks(OutboundPalletItem item, Long positionId, String expectedRelabelNo) {
+        try {
+            var refs = objectMapper.readTree(item.getOrderRefs());
+            if (!"RELABEL_ORDER".equals(refs.path("sourceType").asText())
+                || !StringUtils.hasText(refs.path("relabelNo").asText())
+                || expectedRelabelNo != null && !expectedRelabelNo.equals(refs.path("relabelNo").asText())
+                || positionId == null || !String.valueOf(positionId).equals(refs.path("sourceInventoryPositionId").asText())
+                || !refs.path("items").isArray()) return List.of();
+            var marks = new TreeSet<String>(); var ids = new HashSet<String>(); long packages = 0;
+            for (var line : refs.path("items")) {
+                String mark = line.path("cartonMark").asText().trim(), id = line.path("itemId").asText();
+                long count = line.path("packages").asLong();
+                if (!StringUtils.hasText(mark) || !StringUtils.hasText(id) || !ids.add(id) || !marks.add(mark) || count != 1) return List.of();
+                packages += count;
+            }
+            var frozen = Arrays.stream(Objects.toString(item.getCartonMarks(), "").split(","))
+                .map(String::trim).filter(StringUtils::hasText).collect(Collectors.toCollection(TreeSet::new));
+            return packages == value(item.getPackageCount()) && marks.equals(frozen) ? List.copyOf(marks) : List.of();
+        } catch (Exception ignored) { return List.of(); }
+    }
+
+    /** 释放冻结前核对快照任务主键与本申请当前位置的真实任务集合完全相同。 */
+    private Set<String> relabelSnapshotItemIds(OutboundPalletItem item) {
+        try {
+            var ids = new HashSet<String>();
+            for (var line : objectMapper.readTree(item.getOrderRefs()).path("items")) ids.add(line.path("itemId").asText());
+            return ids;
+        } catch (Exception ignored) { return Set.of(); }
+    }
+
     private DeliveryResponses.PdaPickPosition pdaPosition(InventoryPosition position, OutboundPalletItem item,
                                                             InventoryBalance balance, String cartonMark,
                                                             long available, long picked) {

lastleg-service/src/main/java/com/baiyue/lastleg/discard/dto/CargoDiscardResponses.java

@@ -29,12 +29,16 @@ public final class CargoDiscardResponses {
         }
     }
     public record Box(Long cartonId, String cartonMark, String palletNo, List<CandidateSku> skus) {}
-    public record CandidateSku(String skuCode, String productName, long availablePackages) {}
+    public record CandidateSku(String skuCode, String productName, long availablePackages, Long availablePieces) {
+        /** 无件数事实时保留未知，不按箱规推算。 */
+        public CandidateSku(String skuCode, String productName, long availablePackages) { this(skuCode, productName, availablePackages, null); }
+    }
 
     public record Summary(Long id, String customerId, String discardNo, String inboundCodes,
                           String overseasWarehouseId, String overseasWarehouseName,
                           int totalPackages, BigDecimal totalFee, String currency, String status,
-                          String createdBy, LocalDateTime createdAt, LocalDateTime reviewedAt, String outboundNo, LocalDateTime customerConfirmedAt) {}
+                          String createdBy, LocalDateTime createdAt, LocalDateTime reviewedAt, String outboundNo, LocalDateTime customerConfirmedAt,
+                          List<String> skuCodes, int skuCount, int requestedPackages, Integer actualPackages) {}
 
     public record Item(Long id, Long orderId, String inboundCode, String skuCode,
                        String productName, int availablePackagesSnapshot, int discardPackages, List<String> cartonMarks,

lastleg-service/src/main/java/com/baiyue/lastleg/discard/mapper/CargoDiscardDimensionMapper.java

@@ -19,4 +19,15 @@ public interface CargoDiscardDimensionMapper {
          WHERE i.customer_id=#{customerId} AND i.application_id=#{applicationId}
         """)
     List<String> palletNos(@Param("customerId") String customerId, @Param("applicationId") Long applicationId);
+
+    /** 仅读取所选转运实收箱的真实件数，其他来源保留未知。 */
+    @Select("""
+        SELECT CASE WHEN l.source_type='TRANSFER' THEN c.sku_items_json ELSE NULL END
+          FROM ll_cargo_discard_item i
+          JOIN ll_cargo_discard_carton l ON l.customer_id=i.customer_id AND l.application_id=i.application_id
+           AND (l.item_id=i.id OR (i.source_type='INVENTORY' AND JSON_CONTAINS(i.carton_marks_json,JSON_QUOTE(l.carton_mark))))
+          LEFT JOIN ll_warehouse_transfer_carton c ON c.id=l.carton_id AND c.customer_id=l.customer_id
+         WHERE i.customer_id=#{customerId} AND i.id=#{itemId}
+        """)
+    List<String> selectedCartonPieces(@Param("customerId") String customerId, @Param("itemId") Long itemId);
 }

lastleg-service/src/main/java/com/baiyue/lastleg/discard/mapper/CargoDiscardInventoryMapper.java

@@ -25,16 +25,16 @@ public interface CargoDiscardInventoryMapper {
     @Select("SELECT p.* FROM ll_inventory_position p WHERE p.customer_id=#{customerId} AND p.id=#{positionId} FOR UPDATE")
     com.baiyue.lastleg.inventory.entity.InventoryPosition lockGenericPosition(@Param("customerId") String customerId, @Param("positionId") Long positionId);
 
-    /** 按实收托盘及 SKU 关联已清点箱，避免漏箱或混入其他托盘的箱号。 */
+    /** 按实收托盘关联已清点箱；混装物理余额允许箱内不同 SKU，仍严格限定客户、批次、仓和托盘。 */
     @Select("""
-        SELECT c.id,c.carton_mark,c.sku_code,'INBOUND' source_type
+        SELECT c.id,c.carton_mark,c.sku_code,'INBOUND' source_type,NULL sku_items_json
           FROM ll_inbound_plan_carton c
           JOIN ll_inventory_balance b ON b.customer_id=c.customer_id AND b.inbound_order_id=c.order_id
           JOIN ll_inventory_position p ON p.customer_id=b.customer_id AND p.balance_id=b.id AND p.pallet_id=c.warehouse_pallet_id
          WHERE p.customer_id=#{customerId} AND p.id=#{positionId} AND c.status='AVAILABLE' AND c.received_at IS NOT NULL
            AND COALESCE(b.destination_warehouse_code,'')=COALESCE(c.destination_warehouse_code,'')
         UNION ALL
-        SELECT c.id,c.carton_mark,i.sku_code,'TRANSFER' source_type
+        SELECT c.id,c.carton_mark,i.sku_code,'TRANSFER' source_type,c.sku_items_json
           FROM ll_inventory_position p
           JOIN ll_inventory_balance b ON b.customer_id=p.customer_id AND b.id=p.balance_id
           JOIN ll_warehouse_transfer_order t ON t.customer_id=p.customer_id AND t.inbound_order_id=b.inbound_order_id
@@ -44,7 +44,7 @@ public interface CargoDiscardInventoryMapper {
           JOIN ll_warehouse_transfer_carton c ON c.customer_id=t.customer_id AND c.transfer_order_id=t.id
              AND c.transfer_pallet_id=tp.id AND c.status='COUNTED'
           JOIN ll_warehouse_transfer_item i ON i.customer_id=c.customer_id AND i.id=c.transfer_item_id
-             AND i.transfer_order_id=t.id AND COALESCE(i.sku_code,'')=COALESCE(b.sku_code,'')
+             AND i.transfer_order_id=t.id AND (b.sku_code='MIXED' OR COALESCE(i.sku_code,'')=COALESCE(b.sku_code,''))
          WHERE p.customer_id=#{customerId} AND p.id=#{positionId}
          ORDER BY id
         """)

lastleg-service/src/main/java/com/baiyue/lastleg/discard/model/CargoDiscardQuantities.java

@@ -12,15 +12,22 @@ public final class CargoDiscardQuantities {
     /** 退货混装箱按箱 ID 去重，其余来源累加已选择的物理箱数。 */
     public static int boxes(List<CargoDiscardItem> lines, boolean actual) {
         var returnBoxes = new HashSet<Long>();
+        var inventoryBoxes = new HashSet<String>();
         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 if ("INVENTORY".equals(line.getSourceType()) && line.getCartonMarksJson() != null && quantity > 0) {
+                try {
+                    var marks = new com.fasterxml.jackson.databind.ObjectMapper().readTree(line.getCartonMarksJson());
+                    if (!marks.isArray() || marks.size() != quantity) throw new IllegalStateException("废弃箱唛快照与数量不一致");
+                    for (var mark : marks) inventoryBoxes.add(line.getInboundCode() + ":" + mark.asText());
+                } catch (com.fasterxml.jackson.core.JsonProcessingException e) { throw new IllegalStateException("废弃箱唛快照无法读取", e); }
             } else {
                 total = Math.addExact(total, quantity);
             }
         }
-        return Math.addExact(total, returnBoxes.size());
+        return Math.addExact(Math.addExact(total, returnBoxes.size()), inventoryBoxes.size());
     }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/discard/model/CargoDiscardStockCartonRow.java

@@ -9,4 +9,5 @@ public class CargoDiscardStockCartonRow {
     private String cartonMark;
     private String skuCode;
     private String sourceType;
+    private String skuItemsJson;
 }

lastleg-service/src/main/java/com/baiyue/lastleg/discard/pda/dto/PdaCargoDiscardDtos.java

@@ -21,7 +21,8 @@ public final class PdaCargoDiscardDtos {
     }
     /** 明细数量按来源标识单位：退货库存为件，其余箱级库存为箱。 */
     public record Sku(Long itemId, String skuCode, String productName, int plannedPackages,
-                      Integer actualPackages, String status, String quantityUnit) { }
+                      Integer actualPackages, String status, String quantityUnit,
+                      boolean actualQuantityEditable) { }
     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) { }

lastleg-service/src/main/java/com/baiyue/lastleg/discard/pda/service/PdaCargoDiscardService.java

@@ -1,17 +1,11 @@
 package com.baiyue.lastleg.discard.pda.service;
 
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baiyue.lastleg.discard.dto.CargoDiscardResponses;
 import com.baiyue.lastleg.discard.entity.*;
-import com.baiyue.lastleg.discard.mapper.*;
 import com.baiyue.lastleg.discard.pda.dto.PdaCargoDiscardDtos;
 import com.baiyue.lastleg.discard.service.CargoDiscardInventoryAdjustmentService;
 import com.baiyue.lastleg.discard.service.CargoDiscardService;
-import com.baiyue.lastleg.dropship.entity.DropshipOrderProfile;
-import com.baiyue.lastleg.dropship.mapper.DropshipOrderProfileMapper;
 import com.baiyue.lastleg.pda.security.PdaWarehouseIdentity;
-import com.baiyue.lastleg.returnreceipt.entity.ReturnInventoryCarton;
-import com.baiyue.lastleg.returnreceipt.mapper.ReturnInventoryCartonMapper;
 import jakarta.annotation.Resource;
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
@@ -24,28 +18,24 @@ import java.util.stream.Collectors;
 @Service
 public class PdaCargoDiscardService {
     @Resource private com.baiyue.lastleg.discard.service.CargoDiscardPhotoService photoService;
-    @Resource private CargoDiscardApplicationMapper applications;
+    @Resource private com.baiyue.lastleg.discard.repository.CargoDiscardPdaRepository repository;
     @Resource private com.baiyue.lastleg.discard.service.CargoDiscardOutboundService outboundService;
-    @Resource private CargoDiscardItemMapper items;
-    @Resource private CargoDiscardCartonMapper cartons;
-    @Resource private DropshipOrderProfileMapper profiles;
     @Resource private CargoDiscardInventoryAdjustmentService adjustments;
     @Resource private CargoDiscardService discardService;
-    @Resource private ReturnInventoryCartonMapper returnCartons;
     @Resource private com.baiyue.lastleg.discard.service.CargoDiscardStockService stockService;
 
+    /** 只读取绑定仓已审核申请的实际托盘任务。 */
     public List<PdaCargoDiscardDtos.PalletTask> tasks(PdaWarehouseIdentity identity) {
-        return applications.selectList(new LambdaQueryWrapper<CargoDiscardApplication>()
-                .eq(CargoDiscardApplication::getOverseasWarehouseId, String.valueOf(identity.overseasWarehouseId()))
-                .eq(CargoDiscardApplication::getStatus, CargoDiscardService.APPROVED)
-                .orderByAsc(CargoDiscardApplication::getCreatedAt))
+        return repository.approved(String.valueOf(identity.overseasWarehouseId()))
             .stream().flatMap(a -> palletTasks(a).stream()).toList();
     }
 
+    /** 扫码读取当前仓库唯一可操作任务。 */
     public PdaCargoDiscardDtos.PalletTask resolve(PdaWarehouseIdentity identity, String palletNo) {
         return resolve(identity, palletNo, null);
     }
 
+    /** 扫码时限定已选择申请，防止同托盘多任务误操作。 */
     public PdaCargoDiscardDtos.PalletTask resolve(PdaWarehouseIdentity identity, String palletNo, String discardNo) {
         var matches = tasks(identity).stream().filter(t -> t.palletNo().equals(palletNo.trim()) || t.cartonMarks().contains(palletNo.trim()))
             .filter(t -> discardNo == null || discardNo.isBlank() || t.discardNo().equals(discardNo.trim())).toList();
@@ -54,10 +44,11 @@ public class PdaCargoDiscardService {
             .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "该仓库没有此托盘的待废弃任务"));
     }
 
+    /** 仓库按无箱唛对应任务的实点数结算，其余任务继续核平所选箱。 */
     @Transactional
     public PdaCargoDiscardDtos.PalletTask confirm(PdaWarehouseIdentity identity, String discardNo,
                                                    String palletNo, PdaCargoDiscardDtos.Confirm request) {
-        CargoDiscardApplication application = applications.findNoByWarehouse(discardNo,
+        CargoDiscardApplication application = repository.lockApplication(discardNo,
             String.valueOf(identity.overseasWarehouseId()));
         if (application == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "废弃任务不存在或不属于当前仓库");
         boolean terminal = CargoDiscardService.PDA_COMPLETED.equals(application.getStatus())
@@ -71,8 +62,12 @@ public class PdaCargoDiscardService {
         if (!actuals.keySet().equals(task.skus().stream().map(PdaCargoDiscardDtos.Sku::itemId).collect(Collectors.toSet()))) {
             throw conflict("必须提交该托盘全部 SKU 的实际废弃数量");
         }
-        if (task.skus().stream().anyMatch(line -> !Objects.equals(actuals.get(line.itemId()), line.plannedPackages())))
-            throw conflict("必须完成本次废弃单所选全部箱子，不能漏出");
+        for (var line : task.skus()) {
+            int actual = actuals.get(line.itemId());
+            if (actual < 0 || actual > line.plannedPackages()) throw conflict("实际废弃数量不能超过申请预留数量");
+            if (!line.actualQuantityEditable() && actual != line.plannedPackages())
+                throw conflict("必须完成本次废弃单所选全部箱子，不能漏出");
+        }
         if ("CARTON".equals(task.scanMode()) && !Boolean.TRUE.equals(request.confirmAllCartons())) {
             var scanned = request.scannedCartonMarks() == null ? List.<String>of() : request.scannedCartonMarks();
             if (scanned.size() != task.cartonMarks().size() || !new HashSet<>(scanned).equals(new HashSet<>(task.cartonMarks())))
@@ -80,7 +75,7 @@ public class PdaCargoDiscardService {
         }
         List<CargoDiscardItem> palletItems = new ArrayList<>();
         for (PdaCargoDiscardDtos.Sku line : task.skus()) {
-            CargoDiscardItem item = items.selectById(line.itemId());
+            CargoDiscardItem item = repository.item(line.itemId());
             if (item == null || !application.getCustomerId().equals(item.getCustomerId())
                 || !Objects.equals(application.getId(), item.getApplicationId())
                 || !physicalCode(application, item).equals(task.palletNo()))
@@ -90,14 +85,14 @@ public class PdaCargoDiscardService {
                 throw conflict("已完成托盘的实际数量不能修改");
             palletItems.add(item);
         }
-        if (terminal && items.listApplication(application.getCustomerId(), application.getId()).stream()
+        if (terminal && repository.items(application.getCustomerId(), application.getId()).stream()
             .anyMatch(item -> !"COMPLETED".equals(item.getPdaStatus())
                 || !application.getCustomerId().equals(item.getCustomerId())
                 || !Objects.equals(application.getId(), item.getApplicationId())))
             throw conflict("废弃申请终态存在未完成明细，不能恢复作业结果");
         photoService.confirm(application, task.palletNo(), request.photoFileIds(),
             palletItems.stream().allMatch(item -> "COMPLETED".equals(item.getPdaStatus())));
-        // A completed pallet is an immutable result, including the final pallet after application completion.
+        // 已完成托盘保持原始实点结果，终态重放不得再次扣减或释放库存。
         if (palletItems.stream().allMatch(item -> "COMPLETED".equals(item.getPdaStatus()))) return task;
         if (terminal) throw conflict("废弃终态不能执行未完成托盘");
         LocalDateTime now = LocalDateTime.now();
@@ -105,20 +100,25 @@ public class PdaCargoDiscardService {
             if ("COMPLETED".equals(item.getPdaStatus())) {
                 continue;
             }
-            List<CargoDiscardCarton> links = cartons.listApplication(application.getCustomerId(), application.getId()).stream()
+            List<CargoDiscardCarton> links = repository.cartons(application.getCustomerId(), application.getId()).stream()
                 .filter(c -> c.getItemId().equals(item.getId())).toList();
-            adjustments.discardPalletItem(application.getCustomerId(), application, item, links,
-                actuals.get(item.getId()), identity.operatorKey(), now);
+            // 未知箱唛对应关系时只按当前仓位冻结桶结算，不猜测被废弃的具体箱唛。
+            if ("INVENTORY".equals(item.getSourceType()) && stockService.actualQuantityEditable(item)) {
+                stockService.discard(application.getCustomerId(), identity.operatorKey(), application, item, actuals.get(item.getId()));
+            } else {
+                adjustments.discardPalletItem(application.getCustomerId(), application, item, links,
+                    actuals.get(item.getId()), identity.operatorKey(), now);
+            }
             item.setActualDiscardPackages(actuals.get(item.getId())); item.setPdaStatus("COMPLETED");
-            item.setPdaOperatorId(identity.operatorKey()); item.setPdaCompletedAt(now); items.updateById(item);
+            item.setPdaOperatorId(identity.operatorKey()); item.setPdaCompletedAt(now); repository.saveItem(item);
         }
-        task.skus().stream().map(PdaCargoDiscardDtos.Sku::itemId).map(items::selectById)
+        task.skus().stream().map(PdaCargoDiscardDtos.Sku::itemId).map(repository::item)
             .filter(this::isReturnItem).map(CargoDiscardItem::getReturnCartonId).filter(Objects::nonNull).distinct()
             .forEach(cartonId -> adjustments.finishReturnCarton(application.getCustomerId(), cartonId));
-        if (items.listApplication(application.getCustomerId(), application.getId()).stream()
+        if (repository.items(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);
+                repository.items(application.getCustomerId(), application.getId()), true);
             application.setTotalPackages(actualTotal);
             application.setTotalFee(application.getFeePerPackage().multiply(java.math.BigDecimal.valueOf(actualTotal)));
             discardService.updateLinkedStatus(application.getCustomerId(), application, CargoDiscardService.APPROVED,
@@ -130,6 +130,7 @@ public class PdaCargoDiscardService {
     }
 
     @Transactional
+    /** 当前申请行锁内保存现场照片，已完成托盘禁止补写。 */
     public CargoDiscardResponses.Photo uploadPhoto(PdaWarehouseIdentity identity, String discardNo, String palletNo,
                                                    long operatorUserId, org.springframework.web.multipart.MultipartFile file) {
         CargoDiscardApplication application = photoApplication(identity, discardNo, palletNo, true);
@@ -140,19 +141,22 @@ public class PdaCargoDiscardService {
     }
 
     @Transactional(readOnly = true)
+    /** 读取绑定仓当前托盘的照片。 */
     public List<CargoDiscardResponses.Photo> photos(PdaWarehouseIdentity identity, String discardNo, String palletNo) {
         return photoService.list(photoApplication(identity, discardNo, palletNo, false), palletNo.trim(), false);
     }
 
     @Transactional(readOnly = true)
+    /** 下载当前申请和托盘拥有的照片。 */
     public com.baiyue.lastleg.discard.gateway.CargoDiscardPhotoFileGateway.DownloadedFile downloadPhoto(
         PdaWarehouseIdentity identity, String discardNo, String palletNo, long fileId) {
         return photoService.download(photoApplication(identity, discardNo, palletNo, false), palletNo.trim(), fileId, false);
     }
 
+    /** 照片访问必须同时满足绑定仓和申请托盘范围。 */
     private CargoDiscardApplication photoApplication(PdaWarehouseIdentity identity, String discardNo, String palletNo, boolean lock) {
         var warehouseId = String.valueOf(identity.overseasWarehouseId());
-        var application = lock ? applications.findNoByWarehouse(discardNo, warehouseId) : applications.readNoByWarehouse(discardNo, warehouseId);
+        var application = lock ? repository.lockApplication(discardNo, warehouseId) : repository.readApplication(discardNo, warehouseId);
         if (application == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "废弃任务不存在或不属于当前仓库");
         if (palletTasks(application).stream().noneMatch(t -> t.palletNo().equals(palletNo.trim())))
             throw new ResponseStatusException(HttpStatus.NOT_FOUND, "托盘不属于该废弃单");
@@ -162,13 +166,13 @@ public class PdaCargoDiscardService {
     private static final String LOOSE = "散箱";
     /** 按实托汇总本单所选箱唛，退货件数与物理箱数分别呈现。 */
     private List<PdaCargoDiscardDtos.PalletTask> palletTasks(CargoDiscardApplication application) {
-        var allItems = items.listApplication(application.getCustomerId(), application.getId());
+        var allItems = repository.items(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();
+                isReturnItem(i) ? "件" : "箱", "INVENTORY".equals(i.getSourceType()) && stockService.actualQuantityEditable(i))).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();
             // 退货箱只代表本单选择的箱子，不能因为有托盘号就当成整托废弃。
@@ -180,6 +184,7 @@ public class PdaCargoDiscardService {
                 status, skus, outboundService.outboundNo(application), cartonScan ? "CARTON" : "PALLET", marks);
         }).toList();
     }
+    /** 相关托盘只从客户库存事实读取，不从请求推断。 */
     private String physicalCode(CargoDiscardApplication application, CargoDiscardItem item) {
         String code;
         if ("INVENTORY".equals(item.getSourceType())) {
@@ -187,31 +192,35 @@ public class PdaCargoDiscardService {
             if (!application.getOverseasWarehouseId().equals(position.getOverseasWarehouseId())) throw conflict("废弃库存不属于当前仓库");
             code = position.getPalletNo();
         } else if (isReturnItem(item)) {
-            var carton = returnCartons.selectById(item.getReturnCartonId());
+            var carton = repository.returnCarton(item.getReturnCartonId());
             if (carton == null || !application.getCustomerId().equals(carton.getCustomerId())) throw conflict("废弃明细关联退货箱不存在");
             code = carton.getPalletCode();
         } else {
-            var profile = profiles.selectById(item.getProfileId());
+            var profile = repository.profile(item.getProfileId());
             if (profile == null || !application.getCustomerId().equals(profile.getCustomerId())) throw conflict("废弃明细关联托盘不存在");
             code = profile.getPalletNo();
         }
         return code == null || code.isBlank() ? LOOSE : code.trim();
     }
+    /** 仅返回保存的真实箱唛，未知对应关系不补造箱码。 */
     private List<String> cartonMarks(CargoDiscardApplication application, CargoDiscardItem item) {
         if ("INVENTORY".equals(item.getSourceType())) return stockService.cartonMarks(item);
         if (isReturnItem(item)) {
-            var carton = returnCartons.selectById(item.getReturnCartonId());
+            var carton = repository.returnCarton(item.getReturnCartonId());
             String mark = com.baiyue.lastleg.discard.model.CargoDiscardReturnMark.of(carton);
             return mark == null ? List.of() : List.of(mark);
         }
-        return cartons.listApplication(application.getCustomerId(), application.getId()).stream()
+        return repository.cartons(application.getCustomerId(), application.getId()).stream()
             .filter(c -> Objects.equals(c.getItemId(), item.getId())).map(CargoDiscardCarton::getCartonMark).filter(Objects::nonNull).toList();
     }
+    /** 退货库存沿用独立按件结算规则。 */
     private boolean isReturnItem(CargoDiscardItem item) {
         return "RETURN_CARTON".equals(item.getSourceType()) || item.getReturnCartonId() != null;
     }
+    /** 取首个有效业务展示值。 */
     private static String firstNonBlank(String first, String second) {
         return first != null && !first.isBlank() ? first : second;
     }
+    /** 返回可恢复业务冲突。 */
     private static ResponseStatusException conflict(String message) { return new ResponseStatusException(HttpStatus.CONFLICT, message); }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/discard/repository/CargoDiscardDimensionRepository.java

@@ -12,8 +12,29 @@ import java.util.List;
 public class CargoDiscardDimensionRepository {
     @Resource private CargoDiscardItemMapper items;
     @Resource private CargoDiscardDimensionMapper dimensions;
+    @Resource private com.fasterxml.jackson.databind.ObjectMapper objectMapper;
     /** 读取一票客户隔离明细。 */
     public List<CargoDiscardItem> items(String customer, Long application) { return items.listApplication(customer, application); }
     /** 读取一票托盘身份，保留无事实行。 */
     public List<String> pallets(String customer, Long application) { return dimensions.palletNos(customer, application); }
+    /** 完整箱级事实才可提供件数，缺箱或未知件数不得固定换算。 */
+    public Long pieces(String customer, CargoDiscardItem item) {
+        var values = dimensions.selectedCartonPieces(customer, item.getId());
+        if (values.isEmpty() || values.size() != item.getDiscardPackages()) return null;
+        long total = 0;
+        for (var value : values) {
+            if (value == null || value.isBlank()) return null;
+            try {
+                var contents = objectMapper.readTree(value);
+                if (!contents.isArray()) return null;
+                long selected = 0;
+                for (var content : contents) {
+                    if (item.getSkuCode().equals(content.path("skuCode").asText())) selected += content.path("quantity").asLong();
+                }
+                if (selected <= 0) return null;
+                total += selected;
+            } catch (com.fasterxml.jackson.core.JsonProcessingException e) { return null; }
+        }
+        return total;
+    }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/discard/repository/CargoDiscardPdaRepository.java

@@ -0,0 +1,46 @@
+package com.baiyue.lastleg.discard.repository;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baiyue.lastleg.discard.entity.*;
+import com.baiyue.lastleg.discard.mapper.*;
+import com.baiyue.lastleg.dropship.entity.DropshipOrderProfile;
+import com.baiyue.lastleg.dropship.mapper.DropshipOrderProfileMapper;
+import com.baiyue.lastleg.returnreceipt.entity.ReturnInventoryCarton;
+import com.baiyue.lastleg.returnreceipt.mapper.ReturnInventoryCartonMapper;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Repository;
+import java.util.List;
+
+/** 封装 PDA 废弃任务读取和作业快照持久化，保留绑定仓与申请行锁。 */
+@Repository
+public class CargoDiscardPdaRepository {
+    @Resource private CargoDiscardApplicationMapper applications;
+    @Resource private CargoDiscardItemMapper items;
+    @Resource private CargoDiscardCartonMapper cartons;
+    @Resource private DropshipOrderProfileMapper profiles;
+    @Resource private ReturnInventoryCartonMapper returnCartons;
+
+    /** 按已验证绑定仓读取已审核作业，客户归属由申请事实保留。 */
+    public List<CargoDiscardApplication> approved(String warehouseId) {
+        return applications.selectList(new LambdaQueryWrapper<CargoDiscardApplication>()
+            .eq(CargoDiscardApplication::getOverseasWarehouseId, warehouseId)
+            .eq(CargoDiscardApplication::getStatus, "APPROVED")
+            .orderByAsc(CargoDiscardApplication::getCreatedAt));
+    }
+    /** 写操作按申请串行，保证扣减、释放、实点结果及终态同事务。 */
+    public CargoDiscardApplication lockApplication(String no, String warehouse) { return applications.findNoByWarehouse(no, warehouse); }
+    /** 照片只读入口仍限制绑定仓。 */
+    public CargoDiscardApplication readApplication(String no, String warehouse) { return applications.readNoByWarehouse(no, warehouse); }
+    /** 按申请所属客户读取全部明细。 */
+    public List<CargoDiscardItem> items(String customer, Long application) { return items.listApplication(customer, application); }
+    /** 读取明细后由服务复验客户与申请。 */
+    public CargoDiscardItem item(Long id) { return items.selectById(id); }
+    /** 保存一次实际作业结果。 */
+    public void saveItem(CargoDiscardItem item) { items.updateById(item); }
+    /** 按客户和申请读取已选箱快照。 */
+    public List<CargoDiscardCarton> cartons(String customer, Long application) { return cartons.listApplication(customer, application); }
+    /** 读取原托盘档案供服务核验归属。 */
+    public DropshipOrderProfile profile(Long id) { return profiles.selectById(id); }
+    /** 读取退货箱档案供服务核验归属。 */
+    public ReturnInventoryCarton returnCarton(Long id) { return returnCartons.selectById(id); }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/discard/repository/CargoDiscardQuantityRepository.java

@@ -11,9 +11,10 @@ import org.springframework.stereotype.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);
+        boolean completed = "PDA_COMPLETED".equals(application.getStatus()) || "COMPLETED".equals(application.getStatus());
+        return lines.isEmpty() ? application.getTotalPackages() : CargoDiscardQuantities.boxes(lines, completed);
     }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/discard/repository/CargoDiscardStockRepository.java

@@ -0,0 +1,47 @@
+package com.baiyue.lastleg.discard.repository;
+
+import com.baiyue.lastleg.discard.entity.*;
+import com.baiyue.lastleg.discard.mapper.*;
+import com.baiyue.lastleg.discard.model.CargoDiscardStockCartonRow;
+import com.baiyue.lastleg.inventory.entity.*;
+import com.baiyue.lastleg.inventory.mapper.*;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Repository;
+import java.util.List;
+
+/** 封装普通库存废弃的客户隔离读取、锁箱和申请快照保存。 */
+@Repository
+public class CargoDiscardStockRepository {
+    @Resource private CargoDiscardInventoryMapper stock;
+    @Resource private InventoryPositionMapper positions;
+    @Resource private InventoryBalanceMapper balances;
+    @Resource private CargoDiscardItemMapper items;
+    @Resource private CargoDiscardCartonMapper links;
+
+    /** 读取客户当前可用且没有转运占用的库存仓位。 */
+    public List<InventoryPosition> candidates(String customer, String keyword) { return stock.genericPositions(customer, keyword); }
+    /** 读取余额，服务继续校验其客户与仓库归属。 */
+    public InventoryBalance balance(Long id) { return balances.selectById(id); }
+    /** 读取客户指定仓位。 */
+    public InventoryPosition position(String customer, Long id) { return positions.findTenantPosition(customer, id); }
+    /** 锁定源仓位以串行创建预留。 */
+    public InventoryPosition lockPosition(String customer, Long id) { return stock.lockGenericPosition(customer, id); }
+    /** 读取已有的真实箱唛与托盘对应事实。 */
+    public List<CargoDiscardStockCartonRow> cartons(String customer, Long position) { return stock.genericCartons(customer, position); }
+    /** 排除须走一件代发逐箱预留的仓位。 */
+    public boolean dropshipPosition(String customer, Long position) { return stock.isDropshipPosition(customer, position) > 0; }
+    /** 读取散箱实收流水中的箱码快照。 */
+    public List<String> looseMarks(String customer, Long position) { return stock.looseCartonMarks(customer, position); }
+    /** 保存废弃申请的库存来源明细。 */
+    public void saveItem(CargoDiscardItem item) { items.insert(item); }
+    /** 保存申请所选实物箱快照。 */
+    public void saveCarton(CargoDiscardCarton carton) { links.insert(carton); }
+    /** 读取申请全部所选箱，服务按当前明细筛选。 */
+    public List<CargoDiscardCarton> selectedCartons(String customer, Long application) { return links.listApplication(customer, application); }
+    /** 读取同申请各 SKU 的仓位和箱唛快照，用于按物理仓位消除重复库存命令。 */
+    public List<CargoDiscardItem> applicationItems(String customer, Long application) { return items.listApplication(customer, application); }
+    /** 普通实收箱用原状态条件更新，防止并发占用。 */
+    public int changeInboundCarton(String customer, Long id, String from, String to) { return stock.changeGenericCartonStatus(customer, id, from, to); }
+    /** 转运实收箱保留已清点状态语义。 */
+    public int changeTransferCarton(String customer, Long id, String from, String to) { return stock.changeTransferCartonStatus(customer, id, from, to); }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/discard/service/CargoDiscardOutboundService.java

@@ -58,6 +58,7 @@ public class CargoDiscardOutboundService {
         var snapshots = new java.util.ArrayList<OutboundPalletItem>();
         var palletCodes = new java.util.HashSet<String>();
         var returnBoxIds = new java.util.HashSet<Long>();
+        var inventoryBoxMarks = new java.util.HashSet<String>();
         for (var line : lines) {
             boolean returned = line.getReturnCartonId() != null || "RETURN_CARTON".equals(line.getSourceType());
             String palletNo;
@@ -88,7 +89,7 @@ public class CargoDiscardOutboundService {
             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.setPackageCount(returned ? (returnBoxIds.add(line.getReturnCartonId()) ? 1 : 0) : physicalBoxes(line, inventoryBoxMarks));
             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);
@@ -99,11 +100,13 @@ public class CargoDiscardOutboundService {
     }
 
     /** 同步实物箱的拣货进度，退货 SKU 件数不进入箱数汇总。 */
+    /** 同步废弃实物出库投影，混装 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>();
+        var inventoryBoxMarks = new java.util.HashSet<String>();
         for (var snapshot : pallets.findByOutbound(application.getCustomerId(), outbound.getId())) {
             var line = lines.stream().filter(i -> Objects.equals(i.getId(), snapshot.getId())).findFirst()
                 .orElseThrow(() -> conflict("废弃出库明细关联失效"));
@@ -114,11 +117,11 @@ public class CargoDiscardOutboundService {
                     throw conflict("废弃明细关联退货箱不存在");
                 snapshot.setCartonMarks(com.baiyue.lastleg.discard.model.CargoDiscardReturnMark.of(carton));
             }
-            int boxes = returned ? (returnBoxIds.add(line.getReturnCartonId()) ? 1 : 0) : line.getDiscardPackages();
+            int boxes = returned ? (returnBoxIds.add(line.getReturnCartonId()) ? 1 : 0) : physicalBoxes(line, inventoryBoxMarks);
             snapshot.setPackageCount(boxes);
             if ("COMPLETED".equals(line.getPdaStatus())) {
                 snapshot.setPickedPackageCount(returned ? (Objects.requireNonNullElse(line.getActualDiscardPackages(), 0) > 0 ? boxes : 0)
-                    : Objects.requireNonNullElse(line.getActualDiscardPackages(), 0));
+                    : "INVENTORY".equals(line.getSourceType()) && !stockService.cartonMarks(line).isEmpty() ? boxes : Objects.requireNonNullElse(line.getActualDiscardPackages(), 0));
                 snapshot.setStatus("PICKED");
             }
             if (CargoDiscardService.CANCELLED.equals(application.getStatus())) snapshot.setStatus("CANCELLED");
@@ -134,5 +137,11 @@ public class CargoDiscardOutboundService {
         outbound.setPackageCount(com.baiyue.lastleg.discard.model.CargoDiscardQuantities.boxes(lines, "OUTBOUNDED".equals(status)));
         outbound.setUpdatedAt(LocalDateTime.now()); outbounds.updateById(outbound);
     }
+    /** 保留逐 SKU 来源行，已投影过的同一实箱在后续行记零箱。 */
+    private int physicalBoxes(com.baiyue.lastleg.discard.entity.CargoDiscardItem line, java.util.Set<String> seen) {
+        if (!"INVENTORY".equals(line.getSourceType())) return line.getDiscardPackages();
+        var marks = stockService.cartonMarks(line);
+        return marks.isEmpty() ? line.getDiscardPackages() : (int)marks.stream().filter(mark -> seen.add(line.getInboundCode() + ":" + mark)).count();
+    }
     private static ResponseStatusException conflict(String message) { return new ResponseStatusException(HttpStatus.CONFLICT, message); }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/discard/service/CargoDiscardService.java

@@ -165,7 +165,10 @@ public class CargoDiscardService {
             if (input.cartonIds() != null) {
                 if (input.cartonIds().isEmpty() || input.cartonIds().size() != input.discardPackages()) throw badRequest("请选择具体废弃箱子，箱数须与选择一致");
                 String source = input.inventoryPositionId() != null ? "INVENTORY" : "DROPSHIP";
-                for (Long cartonId : input.cartonIds()) if (!requestedBoxes.add(source + ":" + cartonId)) throw badRequest("同一个箱子不能重复废弃");
+                for (Long cartonId : input.cartonIds()) {
+                    boolean added = requestedBoxes.add(source + ":" + cartonId);
+                    if (!added && input.inventoryPositionId() == null) throw badRequest("同一个箱子不能重复废弃");
+                }
             }
             int sources = (returnSource ? 1 : 0) + (input.orderId() != null ? 1 : 0) + (input.inventoryPositionId() != null ? 1 : 0);
             if (sources != 1) {
@@ -202,7 +205,7 @@ public class CargoDiscardService {
                 throw conflict("One cargo discard application cannot span operating warehouses");
             }
             // 退货明细为件数，整箱只在全部 SKU 校验完成后按箱 ID 计一次。
-            if (!returnSource) total = Math.addExact(total, input.discardPackages());
+            if (!returnSource && input.cartonIds() == null) total = Math.addExact(total, input.discardPackages());
         }
 
         for (Long cartonId : returnCartonCache.keySet()) {
@@ -214,6 +217,7 @@ public class CargoDiscardService {
             if (!availableSkus.equals(requestedSkus)) throw conflict("目前不支持部分废弃，必须选择退货箱内全部 SKU 库存");
         }
         total = Math.addExact(total, returnCartonCache.size());
+        total = Math.addExact(total, requestedBoxes.size());
         LocalDateTime now = LocalDateTime.now();
         if (!StringUtils.hasText(warehouseName)) warehouseName = warehouseNames().get(warehouseId);
         CargoDiscardApplication application = new CargoDiscardApplication();
@@ -236,9 +240,10 @@ public class CargoDiscardService {
         // 废弃申请独立承载废弃流程，不创建尾程订单。
 
         Set<Long> reservedReturnCartons = new LinkedHashSet<>();
+        stockService.reserveAll(customerId, operatorId, application, request.items(), now);
         for (CargoDiscardRequests.Item input : request.items()) {
             if (input.inventoryPositionId() != null) {
-                stockService.reserve(customerId, operatorId, application, input, now);
+                // 普通库存已按完整混装箱批量预留。
             } else if (input.returnCartonId() != null) {
                 reserveReturn(customerId, application, returnCartonCache.get(input.returnCartonId()), input, now,
                     reservedReturnCartons);
@@ -513,10 +518,15 @@ public class CargoDiscardService {
     /** 废弃列表与详情按物理箱汇总，并按每箱单价计算应展示费用。 */
     private CargoDiscardResponses.Summary summary(CargoDiscardApplication value, Map<String, String> names) {
         int boxes = quantities.boxes(value);
+        var lines = items.listApplication(value.getCustomerId(), value.getId());
+        var skuCodes = lines.stream().map(CargoDiscardItem::getSkuCode).filter(s -> s != null && !s.isBlank()).distinct().sorted().toList();
+        int requested = lines.isEmpty() ? value.getTotalPackages() : com.baiyue.lastleg.discard.model.CargoDiscardQuantities.boxes(lines, false);
+        Integer actual = lines.stream().anyMatch(i -> i.getActualDiscardPackages() != null)
+            ? com.baiyue.lastleg.discard.model.CargoDiscardQuantities.boxes(lines, true) : null;
         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.getReviewedAt(), outboundService.outboundNo(value), value.getCustomerConfirmedAt());
+            value.getReviewedAt(), outboundService.outboundNo(value), value.getCustomerConfirmedAt(), skuCodes, skuCodes.size(), requested, actual);
     }
 
     private void history(String customerId, Long applicationId, String from, String to, String operatorId,

lastleg-service/src/main/java/com/baiyue/lastleg/discard/service/CargoDiscardStatisticsService.java

@@ -32,8 +32,14 @@ public class CargoDiscardStatisticsService {
             for (var line : lines) {
                 if (line.getSkuCode() != null && !line.getSkuCode().isBlank()) skus.add(line.getSkuCode());
                 if (line.getReturnCartonId() == null) {
-                    piecesKnown = false;
-                    if (line.getActualDiscardPackages() != null) actualPiecesKnown = false;
+                    var selectedPieces = dimensions.pieces(application.getCustomerId(), line);
+                    if (selectedPieces == null) piecesKnown = false;
+                    else pieces += selectedPieces;
+                    if (line.getActualDiscardPackages() != null) {
+                        if (line.getActualDiscardPackages() == 0) { /* 实际未废弃商品为零，不推测箱规。 */ }
+                        else if (selectedPieces != null && line.getActualDiscardPackages() == line.getDiscardPackages()) actualPieces += selectedPieces;
+                        else actualPiecesKnown = false;
+                    }
                 } else {
                     pieces += line.getDiscardPackages();
                     if (line.getActualDiscardPackages() != null) actualPieces += line.getActualDiscardPackages();

lastleg-service/src/main/java/com/baiyue/lastleg/discard/service/CargoDiscardStockService.java

@@ -2,11 +2,9 @@ package com.baiyue.lastleg.discard.service;
 
 import com.baiyue.lastleg.discard.dto.*;
 import com.baiyue.lastleg.discard.entity.*;
-import com.baiyue.lastleg.discard.mapper.*;
 import com.baiyue.lastleg.inventory.command.dto.InventoryCommandRequests;
 import com.baiyue.lastleg.inventory.command.service.InventoryCommandService;
 import com.baiyue.lastleg.inventory.entity.*;
-import com.baiyue.lastleg.inventory.mapper.*;
 import com.baomidou.mybatisplus.core.toolkit.IdWorker;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import jakarta.annotation.Resource;
@@ -16,129 +14,233 @@ import org.springframework.web.server.ResponseStatusException;
 import java.util.*;
 import java.time.LocalDateTime;
 
-/** Stock eligibility is based on physical available positions, independent of the source document type. */
+/** 根据实际可用仓位校验废弃库存，精确选箱与无对应关系实点分别结算。 */
 @Service
 public class CargoDiscardStockService {
-    @Resource private CargoDiscardInventoryMapper stock;
-    @Resource private InventoryPositionMapper positions;
-    @Resource private InventoryBalanceMapper balances;
+    @Resource private com.baiyue.lastleg.discard.repository.CargoDiscardStockRepository repository;
     @Resource private InventoryCommandService commands;
-    @Resource private CargoDiscardItemMapper items;
-    @Resource private CargoDiscardCartonMapper links;
     @Resource private ObjectMapper objectMapper;
 
+    /** 展示可用库存及相关托盘，箱唛完整时才提供逐箱选择。 */
     public List<CargoDiscardResponses.Candidate> candidates(String customer, String keyword) {
-        return stock.genericPositions(customer, keyword).stream().map(position -> {
-            var balance = balances.selectById(position.getBalanceId());
+        return repository.candidates(customer, keyword).stream().map(position -> {
+            var balance = repository.balance(position.getBalanceId());
             if (balance == null || !customer.equals(balance.getCustomerId())) throw conflict("库存余额不存在");
             long available = Math.min(value(position.getAvailablePackages()), value(balance.getAvailablePackages()));
-            var cartons = stock.genericCartons(customer, position.getId());
-            boolean complete = cartons.size() == available && cartons.stream().allMatch(c -> c.getCartonMark() != null && !c.getCartonMark().isBlank())
-                && cartons.stream().map(c -> c.getCartonMark()).distinct().count() == cartons.size();
+            var cartons = repository.cartons(customer, position.getId());
+            boolean complete = completeCartons(cartons, available);
             var boxes = complete ? cartons.stream().map(c -> new CargoDiscardResponses.Box(c.getId(), c.getCartonMark(), position.getPalletNo(),
-                List.of(new CargoDiscardResponses.CandidateSku(c.getSkuCode(), balance.getProductNameZh(), 1)))).toList() : List.<CargoDiscardResponses.Box>of();
+                contents(c, balance.getProductNameZh()))).toList() : List.<CargoDiscardResponses.Box>of();
             return new CargoDiscardResponses.Candidate(null, "INVENTORY", null, null,
                 balance.getInboundCode(), balance.getInboundOrderNo(), balance.getOverseasWarehouseId(),
                 balance.getOverseasWarehouseName(), position.getCreatedAt(), available,
-                List.of(new CargoDiscardResponses.CandidateSku(sku(balance), balance.getProductNameZh(), available)),
+                complete ? summarizeSkus(cartons, balance) : List.of(new CargoDiscardResponses.CandidateSku(sku(balance), balance.getProductNameZh(), available)),
                 position.getId(), position.getPalletNo(), boxes, complete,
-                complete ? null : "当前库存缺少完整箱唛与托盘对应记录，可按全部库存废弃");
+                complete ? null : "缺少完整箱唛与托盘对应记录，将预留所选库存，由仓库核对相关托盘并填写实际废弃箱数，未废弃部分释放");
         }).filter(c -> c.availablePackages() > 0).toList();
     }
 
+    /** 校验客户、仓库、SKU、预留上限与具体箱子的归属。 */
     public InventoryBalance validate(String customer, CargoDiscardRequests.Item request) {
         var position = position(customer, request.inventoryPositionId());
-        var balance = balances.selectById(position.getBalanceId());
+        var balance = repository.balance(position.getBalanceId());
         if (balance == null || !customer.equals(balance.getCustomerId())
             || !Objects.equals(position.getOverseasWarehouseId(), balance.getOverseasWarehouseId()))
             throw conflict("库存不属于当前客户或仓库");
-        if (!sku(balance).equals(request.skuCode().trim())) throw conflict("SKU 不属于所选库存");
         long available = Math.min(value(position.getAvailablePackages()), value(balance.getAvailablePackages()));
         if (available <= 0 || request.discardPackages() <= 0 || request.discardPackages() > available) throw conflict("所选废弃库存数量不足");
         if (request.cartonIds() != null) {
             if (request.cartonIds().size() != request.discardPackages() || new HashSet<>(request.cartonIds()).size() != request.cartonIds().size())
                 throw conflict("废弃箱子数量与所选箱子不一致或重复");
-            var cartons = stock.genericCartons(customer, position.getId());
+            var cartons = repository.cartons(customer, position.getId());
             var ids = cartons.stream().map(c -> c.getId()).collect(java.util.stream.Collectors.toSet());
             if (cartons.size() != available || cartons.stream().anyMatch(c -> c.getCartonMark() == null || c.getCartonMark().isBlank()) || cartons.stream().map(c -> c.getCartonMark()).distinct().count() != cartons.size() || !ids.containsAll(request.cartonIds())) throw conflict("箱唛库存已变化或不属于所选托盘，请刷新后重选");
-        } else if (request.discardPackages() != available) throw conflict("部分废弃必须选择具体箱子，不能只填写数量");
-        if (stock.isDropshipPosition(customer, position.getId()) > 0) throw conflict("一件代发库存必须按真实箱唛选择，不能绕过箱级预留");
+            if (cartons.stream().filter(c -> request.cartonIds().contains(c.getId())).anyMatch(c -> contents(c, null).stream().noneMatch(s -> request.skuCode().trim().equals(s.skuCode())))) throw conflict("SKU 不属于所选箱子");
+        } else {
+            if (!sku(balance).equals(request.skuCode().trim())) throw conflict("SKU 不属于所选库存");
+            if (request.discardPackages() != available) throw conflict("部分废弃必须选择具体箱子，不能只填写数量");
+        }
+        if (repository.dropshipPosition(customer, position.getId())) throw conflict("一件代发库存必须按真实箱唛选择，不能绕过箱级预留");
         return balance;
     }
 
     /** 预留所选实收箱并保存箱号快照，转运箱从已清点状态进入待废弃。 */
     public void reserve(String customer, String operator, CargoDiscardApplication application, CargoDiscardRequests.Item request, LocalDateTime at) {
-        if (stock.lockGenericPosition(customer, request.inventoryPositionId()) == null) throw conflict("库存仓位不存在");
+        if (repository.lockPosition(customer, request.inventoryPositionId()) == null) throw conflict("库存仓位不存在");
         var balance = validate(customer, request);
+        reserveValidated(customer, operator, application, request, at, balance, repository.cartons(customer, request.inventoryPositionId()), new HashSet<>(), new HashSet<>());
+    }
+
+    /** 整箱混装必须包含全部 SKU 仓位；先锁仓位并校验全部事实，再按实物箱仅锁定一次。 */
+    public void reserveAll(String customer, String operator, CargoDiscardApplication application, List<CargoDiscardRequests.Item> requests, LocalDateTime at) {
+        var stocks = requests.stream().filter(r -> r.inventoryPositionId() != null).toList();
+        stocks.stream().map(CargoDiscardRequests.Item::inventoryPositionId).distinct().sorted().forEach(id -> {
+            if (repository.lockPosition(customer, id) == null) throw conflict("库存仓位不存在");
+        });
+        var balances = new HashMap<Long, InventoryBalance>();
+        var cartons = new HashMap<Long, List<com.baiyue.lastleg.discard.model.CargoDiscardStockCartonRow>>();
+        var selectedSkus = new HashMap<String, Set<String>>();
+        for (var request : stocks) {
+            balances.put(request.inventoryPositionId(), validate(customer, request));
+            var facts = repository.cartons(customer, request.inventoryPositionId());
+            cartons.put(request.inventoryPositionId(), facts);
+            for (var carton : facts) if (request.cartonIds() == null || request.cartonIds().contains(carton.getId()))
+                selectedSkus.computeIfAbsent(carton.getSourceType() + ":" + carton.getId(), k -> new HashSet<>()).add(request.skuCode().trim());
+        }
+        for (var request : stocks) for (var carton : cartons.get(request.inventoryPositionId())) {
+            if (request.cartonIds() != null && !request.cartonIds().contains(carton.getId())) continue;
+            var required = contents(carton, null).stream().map(CargoDiscardResponses.CandidateSku::skuCode).collect(java.util.stream.Collectors.toSet());
+            if (required.size() > 1 && request.cartonIds() == null) throw conflict("混装箱必须选择具体箱子及箱内全部 SKU 库存");
+            if (!selectedSkus.get(carton.getSourceType() + ":" + carton.getId()).containsAll(required)) throw conflict("混装箱必须选择箱内全部 SKU 库存");
+        }
+        var lockedBoxes = new HashSet<String>();
+        var heldBoxes = new HashSet<String>();
+        for (var request : stocks) reserveValidated(customer, operator, application, request, at,
+            balances.get(request.inventoryPositionId()), cartons.get(request.inventoryPositionId()), lockedBoxes, heldBoxes);
+    }
+
+    /** 使用本事务变更箱状态前的完整事实，为每个 SKU 分别预留并保存相同箱唛快照。 */
+    private void reserveValidated(String customer, String operator, CargoDiscardApplication application, CargoDiscardRequests.Item request, LocalDateTime at,
+                                  InventoryBalance balance, List<com.baiyue.lastleg.discard.model.CargoDiscardStockCartonRow> availableCartons, Set<String> lockedBoxes, Set<String> heldBoxes) {
         var position = position(customer, request.inventoryPositionId());
         var line = new CargoDiscardItem(); line.setId(IdWorker.getId()); line.setApplicationId(application.getId());
         line.setCustomerId(customer); line.setSourceType("INVENTORY"); line.setInventoryPositionId(position.getId());
-        line.setInboundCode(balance.getInboundCode()); line.setSkuCode(sku(balance)); line.setProductName(balance.getProductNameZh());
-        line.setAvailablePackagesSnapshot(Math.toIntExact(Math.min(value(position.getAvailablePackages()), value(balance.getAvailablePackages())))); line.setDiscardPackages(request.discardPackages()); line.setCreatedAt(at);
-        var availableCartons = stock.genericCartons(customer, position.getId());
+        line.setInboundCode(balance.getInboundCode()); line.setSkuCode(request.skuCode().trim()); line.setProductName(sku(balance).equals(line.getSkuCode()) ? balance.getProductNameZh() : null);
+        line.setAvailablePackagesSnapshot(availableCartons.isEmpty() ? Math.toIntExact(Math.min(value(position.getAvailablePackages()), value(balance.getAvailablePackages()))) : availableCartons.size()); line.setDiscardPackages(request.discardPackages()); line.setCreatedAt(at);
         var selected = request.cartonIds() == null
-            ? (availableCartons.size() == request.discardPackages() ? availableCartons : List.<com.baiyue.lastleg.discard.model.CargoDiscardStockCartonRow>of())
+            ? (completeCartons(availableCartons, request.discardPackages()) ? availableCartons : List.<com.baiyue.lastleg.discard.model.CargoDiscardStockCartonRow>of())
             : availableCartons.stream().filter(c -> request.cartonIds().contains(c.getId())).toList();
         if (!selected.isEmpty()) {
             for (var carton : selected) {
+                if (!lockedBoxes.add(carton.getSourceType() + ":" + carton.getId())) continue;
                 if (changeBox(customer, carton.getId(), carton.getSourceType(), "TRANSFER".equals(carton.getSourceType()) ? "COUNTED" : "AVAILABLE", "DISCARD_PENDING") != 1) throw conflict("箱子已被其他作业占用，请刷新后重选");
                 var link = new CargoDiscardCarton(); link.setId(IdWorker.getId()); link.setCustomerId(customer); link.setApplicationId(application.getId());
-                link.setItemId(line.getId()); link.setSourceType(carton.getSourceType()); link.setCartonId(carton.getId()); link.setCartonMark(carton.getCartonMark()); link.setCreatedAt(at); links.insert(link);
+                link.setItemId(line.getId()); link.setSourceType(carton.getSourceType()); link.setCartonId(carton.getId()); link.setCartonMark(carton.getCartonMark()); link.setCreatedAt(at); repository.saveCarton(link);
             }
             snapshotMarks(line, selected.stream().map(c -> c.getCartonMark()).toList());
             line.setCartonScanRequired(request.discardPackages() < value(position.getAvailablePackages()) + value(position.getHoldPackages()) + value(position.getAllocatedPackages()) + value(position.getPickedPackages()));
         } else if (position.getPalletNo() == null || position.getPalletNo().isBlank()) {
-            var marks = stock.looseCartonMarks(customer, position.getId());
+            var marks = repository.looseMarks(customer, position.getId());
             if (marks.size() != request.discardPackages() || marks.stream().distinct().count() != marks.size()) throw conflict("散箱库存缺少完整箱唛，请先核对实物箱级入库记录");
             snapshotMarks(line, marks);
         }
-        commands.hold(customer, operator, move(application, line, request.discardPackages(), "HOLD"));
-        items.insert(line);
+        int physical = selected.isEmpty() ? request.discardPackages() : (int)selected.stream().filter(c -> heldBoxes.add(position.getId() + ":" + c.getSourceType() + ":" + c.getId())).count();
+        if (physical > 0) commands.hold(customer, operator, move(application, line, physical, "HOLD"));
+        repository.saveItem(line);
     }
 
+    /** 同一仓位可能承载混装箱，完整 SKU 候选来自实箱而不是库存余额的首 SKU。 */
+    private List<CargoDiscardResponses.CandidateSku> summarizeSkus(List<com.baiyue.lastleg.discard.model.CargoDiscardStockCartonRow> cartons, InventoryBalance balance) {
+        var boxes = new LinkedHashMap<String, Long>(); var pieces = new HashMap<String, Long>(); var unknown = new HashSet<String>();
+        for (var carton : cartons) for (var content : contents(carton, null)) {
+            boxes.merge(content.skuCode(), 1L, Math::addExact);
+            if (content.availablePieces() == null) unknown.add(content.skuCode()); else pieces.merge(content.skuCode(), content.availablePieces(), Math::addExact);
+        }
+        return boxes.entrySet().stream().map(e -> new CargoDiscardResponses.CandidateSku(e.getKey(), sku(balance).equals(e.getKey()) ? balance.getProductNameZh() : null,
+            e.getValue(), unknown.contains(e.getKey()) ? null : pieces.get(e.getKey()))).toList();
+    }
+
+    /** 箱数、箱唛和唯一性均完整时，才允许将库存对应到具体箱子。 */
+    private boolean completeCartons(List<com.baiyue.lastleg.discard.model.CargoDiscardStockCartonRow> cartons, long count) {
+        return cartons.size() == count && cartons.stream().allMatch(c -> c.getCartonMark() != null && !c.getCartonMark().isBlank())
+            && cartons.stream().map(c -> c.getCartonMark()).distinct().count() == cartons.size();
+    }
+    /** 转运实收 JSON 提供完整 SKU 与件数；无 JSON 的单 SKU 来源保留箱数单位。 */
+    private List<CargoDiscardResponses.CandidateSku> contents(com.baiyue.lastleg.discard.model.CargoDiscardStockCartonRow carton, String productName) {
+        if (carton.getSkuItemsJson() == null || carton.getSkuItemsJson().isBlank())
+            return List.of(new CargoDiscardResponses.CandidateSku(carton.getSkuCode(), productName, 1));
+        try {
+            var values = objectMapper.readTree(carton.getSkuItemsJson());
+            if (!values.isArray()) throw conflict("箱内 SKU 事实不完整");
+            var quantities = new LinkedHashMap<String, Long>();
+            for (var value : values) {
+                String code = value.path("skuCode").asText().trim(); long pieces = value.path("quantity").asLong();
+                if (code.isEmpty() || pieces <= 0) throw conflict("箱内 SKU 事实不完整");
+                quantities.merge(code, pieces, Math::addExact);
+            }
+            if (quantities.isEmpty()) throw conflict("箱内 SKU 事实不完整");
+            return quantities.entrySet().stream().map(e -> new CargoDiscardResponses.CandidateSku(e.getKey(), Objects.equals(e.getKey(), carton.getSkuCode()) ? productName : null, 1, e.getValue())).toList();
+        } catch (com.fasterxml.jackson.core.JsonProcessingException e) { throw conflict("箱内 SKU 事实无法读取"); }
+    }
+
+    /** 驳回或取消时恢复所选箱状态并释放本次冻结数量。 */
     public void release(String customer, CargoDiscardApplication application, CargoDiscardItem line) {
         changeSelectedCartons(customer, application, line, "AVAILABLE");
-        commands.release(customer, application.getCreatedBy(), move(application, line, line.getDiscardPackages(), "RELEASE"));
+        int physical = physicalPackages(customer, application, line);
+        if (physical > 0) commands.release(customer, application.getCreatedBy(), move(application, line, physical, "RELEASE"));
     }
 
+    /** 无逐箱对应关系时按仓库实点扣冻结库存，未废弃余量在同一作业事务释放。 */
+    @org.springframework.transaction.annotation.Transactional(propagation = org.springframework.transaction.annotation.Propagation.MANDATORY)
     public void discard(String customer, String operator, CargoDiscardApplication application, CargoDiscardItem line, int actual) {
-        if (actual != line.getDiscardPackages()) throw conflict("必须完成本次申请所选全部箱子，不能漏出");
-        changeSelectedCartons(customer, application, line, "DISCARDED");
-        commands.discardHeld(customer, operator, move(application, line, actual, "DISCARD"));
+        if (actual < 0 || actual > line.getDiscardPackages()) throw conflict("实际废弃箱数不能超过申请预留箱数");
+        if (!actualQuantityEditable(line) && actual != line.getDiscardPackages())
+            throw conflict("必须完成本次申请所选全部箱子，不能漏出");
+        // 已选择具体箱子的作业仍按箱唛结算，不能按数量猜测哪些箱已被废弃。
+        if (!actualQuantityEditable(line)) changeSelectedCartons(customer, application, line, "DISCARDED");
+        int physical = actualQuantityEditable(line) ? actual : physicalPackages(customer, application, line);
+        if (physical > 0) commands.discardHeld(customer, operator, move(application, line, physical, "DISCARD"));
+        int remaining = line.getDiscardPackages() - actual;
+        if (remaining > 0) commands.release(customer, operator, move(application, line, remaining, "ACTUAL_RELEASE"));
     }
 
-    private int changeBox(String customer, Long cartonId, String source, String from, String to) {
-        if ("TRANSFER".equals(source)) return stock.changeTransferCartonStatus(customer, cartonId, from, to);
-        if (!"INBOUND".equals(source)) throw conflict("箱子库存来源不正确");
-        return stock.changeGenericCartonStatus(customer, cartonId, from, to);
+    /** 同仓位同箱只由首个 SKU 明细执行库存命令；其他 SKU 保存件数事实，不重复扣物理箱桶。 */
+    private int physicalPackages(String customer, CargoDiscardApplication application, CargoDiscardItem line) {
+        var marks = cartonMarks(line);
+        if (marks.isEmpty()) return line.getDiscardPackages();
+        var previous = new HashSet<String>();
+        for (var other : repository.applicationItems(customer, application.getId())) {
+            if (Objects.equals(other.getInventoryPositionId(), line.getInventoryPositionId()) && other.getId() != null && line.getId() != null && other.getId() < line.getId()) previous.addAll(cartonMarks(other));
+        }
+        return (int)marks.stream().filter(mark -> !previous.contains(mark)).count();
     }
+
+    /** 只有未保存具体箱唛的普通仓位库存允许仓库按实点箱数完成。 */
+    public boolean actualQuantityEditable(CargoDiscardItem line) {
+        return "INVENTORY".equals(line.getSourceType()) && line.getInventoryPositionId() != null
+            && cartonMarks(line).isEmpty() && !Boolean.TRUE.equals(line.getCartonScanRequired());
+    }
+
+    /** 按箱来源执行带原状态条件的变更。 */
+    private int changeBox(String customer, Long cartonId, String source, String from, String to) {
+        if ("TRANSFER".equals(source)) return repository.changeTransferCarton(customer, cartonId, from, to);
+        if (!"INBOUND".equals(source)) throw conflict("箱子库存来源不正确");
+        return repository.changeInboundCarton(customer, cartonId, from, to);
+    }
+    /** 保存本次选箱事实，后续作业不得按数量猜测箱唛。 */
     private void snapshotMarks(CargoDiscardItem line, List<String> marks) {
         try { line.setCartonMarksJson(objectMapper.writeValueAsString(marks)); }
         catch (Exception e) { throw new IllegalStateException("Cannot snapshot carton marks", e); }
     }
-    /** 按真实箱来源完成废弃或释放，转运箱释放后恢复已清点状态。 */
+    /** 仅变更当前申请明细保存的箱子，转运箱释放后恢复已清点状态。 */
     private void changeSelectedCartons(String customer, CargoDiscardApplication application, CargoDiscardItem line, String status) {
-        for (var link : links.listApplication(customer, application.getId())) {
+        for (var link : repository.selectedCartons(customer, application.getId())) {
             if (Objects.equals(link.getItemId(), line.getId()) && changeBox(customer, link.getCartonId(), link.getSourceType(), "DISCARD_PENDING", "TRANSFER".equals(link.getSourceType()) && "AVAILABLE".equals(status) ? "COUNTED" : status) != 1)
                 throw conflict("预留箱子的库存状态发生变化");
         }
     }
+    /** 库存命令使用申请和明细构成的稳定来源与幂等键。 */
     private InventoryCommandRequests.Move move(CargoDiscardApplication application, CargoDiscardItem line, int count, String action) {
         String cycle = "CARGO_DISCARD:" + application.getId() + ":" + line.getId();
         return new InventoryCommandRequests.Move(line.getInventoryPositionId(), count, application.getDiscardNo(),
             null, cycle, cycle + ":" + action, "货物废弃 " + action);
     }
+    /** 读取并核对客户指定库存仓位。 */
     public InventoryPosition position(String customer, Long id) {
-        var position = positions.findTenantPosition(customer, id);
+        var position = repository.position(customer, id);
         if (position == null) throw conflict("废弃库存仓位不存在或不属于当前客户");
         return position;
     }
+    /** 只解析申请保存的箱唛，缺失对应关系保留为空。 */
     public List<String> cartonMarks(CargoDiscardItem line) {
         if (line.getCartonMarksJson() == null) return List.of();
         try { return objectMapper.readValue(line.getCartonMarksJson(), new com.fasterxml.jackson.core.type.TypeReference<List<String>>() {}); }
         catch (Exception e) { throw new IllegalStateException("Cannot read carton marks", e); }
     }
+    /** 无 SKU 来源保留未指定标记，不猜测商品。 */
     private static String sku(InventoryBalance balance) { return balance.getSkuCode() == null || balance.getSkuCode().isBlank() ? "UNSPECIFIED" : balance.getSkuCode(); }
+    /** 空库存桶按零处理。 */
     private static long value(Long value) { return value == null ? 0 : value; }
+    /** 返回可恢复的业务冲突。 */
     private static ResponseStatusException conflict(String message) { return new ResponseStatusException(HttpStatus.CONFLICT, message); }
 }

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

@@ -5,11 +5,6 @@ import java.util.List;
 /** BOL按真实明细客户逐行读取整车，不依赖已移除的主单客户头。 */
 @Mapper
 public interface DispatchBolMapper {
-    /** 旧客户详情入口沿用整车查询，但只返回该客户自己的BOL明细。 */
-    default List<com.baiyue.lastleg.dispatch.dto.DispatchResponse.BolLine> findByDispatchOrder(String customerId, Long dispatchOrderId) {
-        return findWholeDispatch(dispatchOrderId).stream().filter(line -> java.util.Objects.equals(customerId,line.customerId())).map(line -> new com.baiyue.lastleg.dispatch.dto.DispatchResponse.BolLine(line.containerNo(),line.palletNo(),line.fbaWarehouseCode(),line.destinationWarehouseName(),line.warehouseNo(),line.fbaShipmentId(),line.poReferenceNo(),line.packageCount())).toList();
-    }
-
     @Select("SELECT di.customer_id AS customerId,di.destination_type AS destinationType,di.delivery_address AS deliveryAddress,di.postal_code AS postalCode," +
         "COALESCE(MAX(NULLIF(o.container_no,'')),MAX(NULLIF(ip.container_no,''))) AS containerNo," +
         "MAX(NULLIF(di.pallet_no,'')) AS palletNo," +

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

@@ -20,7 +20,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import com.baiyue.lastleg.dispatch.repository.DispatchItemSourceRepository;
-import com.baiyue.lastleg.dispatch.service.DispatchItemSourceService;
+import com.baiyue.lastleg.dispatch.port.DispatchSourceAllocation;
 
 @Service
 public class DispatchPickOrderAttributionService {
@@ -39,7 +39,7 @@ public class DispatchPickOrderAttributionService {
 
     /** 第四来源分支链接真实冻结贡献，全部归属、履约计数和库存跟随原扫码事务提交。 */
     @org.springframework.transaction.annotation.Transactional(propagation=org.springframework.transaction.annotation.Propagation.MANDATORY)
-    public void attributeRelabel(String customerId,DispatchPdaPick pick,Long orderId,List<DispatchItemSourceService.Allocation> allocations) {
+    public void attributeRelabel(String customerId,DispatchPdaPick pick,Long orderId,List<DispatchSourceAllocation> allocations) {
         long packages=0,quantity=0;var seen=new java.util.HashSet<Long>();
         for(var allocation:allocations) {
             var source=allocation.dispatchItemSourceId()==null?null:relabelSources.find(allocation.dispatchItemSourceId());

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

@@ -0,0 +1,4 @@
+package com.baiyue.lastleg.dispatch.port;
+
+/** 一次真实拣货消费的冻结来源额度；件数未知时保留空，不接受请求伪造来源身份。 */
+public record DispatchSourceAllocation(Long dispatchItemSourceId, long packages, Long productQuantity) { }

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

@@ -6,6 +6,7 @@ import com.baiyue.common.core.exception.BizException;
 import com.baiyue.lastleg.dispatch.entity.*;
 import com.baiyue.lastleg.dispatch.mapper.DispatchSourceMapper;
 import com.baiyue.lastleg.dispatch.repository.DispatchItemSourceRepository;
+import com.baiyue.lastleg.dispatch.port.DispatchSourceAllocation;
 import com.baiyue.lastleg.relabel.port.RelabelDispatchSourcePort;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.springframework.stereotype.Service;
@@ -23,9 +24,6 @@ public class DispatchItemSourceService {
     /** 来源事实经提供者读取，冻结贡献及已消费数经本域仓储读取。 */
     public DispatchItemSourceService(DispatchItemSourceRepository repository,RelabelDispatchSourcePort relabel,ObjectMapper json){this.repository=repository;this.relabel=relabel;this.json=json;}
 
-    /** packages是本次实际消费量，件数未知保留空；不是请求可伪造的来源身份。 */
-    public record Allocation(Long dispatchItemSourceId,long packages,Long productQuantity) { }
-
     /** 主单原事务已锁齐全部来源与库存；所有当前成员一起核对，仅为新增明细追加不可变快照。 */
     @Transactional(propagation=Propagation.MANDATORY)
     public void capture(DispatchAggregate root,List<DispatchItem> all,List<DispatchItem> added,LocalDateTime at) {
@@ -108,7 +106,7 @@ public class DispatchItemSourceService {
 
     /** 本客户本实托的全部剩余贡献必须累计核对HOLD，逐item单独足够不能证明共享position总量足够。 */
     @Transactional(propagation=Propagation.MANDATORY)
-    public List<Allocation> allocate(long dispatch,DispatchItem item,long positionId,long packages,long productQuantity,String cartonMark,List<DispatchSourceMapper.Stock> actualStock) {
+    public List<DispatchSourceAllocation> allocate(long dispatch,DispatchItem item,long positionId,long packages,long productQuantity,String cartonMark,List<DispatchSourceMapper.Stock> actualStock) {
         var all=repository.all(dispatch);var consumed=repository.pickedAll(List.of(dispatch)).stream().collect(Collectors.toMap(p->p.sourceId(),p->p));
         var expected=new HashMap<Long,Long>();
         for(var source:all)if(Objects.equals(item.getCustomerId(),source.getCustomerId()) && Objects.equals(item.getWarehousePalletId(),source.getWarehousePalletId())) {
@@ -127,14 +125,14 @@ public class DispatchItemSourceService {
         for(var row:rows){long left=row.getPackageCount()-(consumed.containsKey(row.getId())?consumed.get(row.getId()).packages():0);remaining.put(row.getId(),left);total=Math.addExact(total,left);}
         if(packages<=0 || packages>total)throw conflict("实际扫码超过本换标来源本位置的剩余箱数");
         if(rows.size()>1 && packages!=total)throw conflict("本位置含多条换标贡献，请扫描具体箱唛后确认部分箱数");
-        var result=new ArrayList<Allocation>();long knownQuantity=0;
+        var result=new ArrayList<DispatchSourceAllocation>();long knownQuantity=0;
         for(var row:rows)if(row.getProductQuantity()!=null){long used=consumed.containsKey(row.getId())?consumed.get(row.getId()).productQuantity():0;long left=row.getProductQuantity()-used;if(left<0)throw conflict("换标实际件数超过来源贡献");knownQuantity=Math.addExact(knownQuantity,left);}
         if(rows.size()>1) {
             if(productQuantity!=knownQuantity)throw conflict("多来源件数不能推算，请扫描明确箱唛并确认实际件数");
-            for(var row:rows){Long quantity=row.getProductQuantity()==null?null:row.getProductQuantity()-(consumed.containsKey(row.getId())?consumed.get(row.getId()).productQuantity():0);result.add(new Allocation(row.getId(),remaining.get(row.getId()),quantity));}
+            for(var row:rows){Long quantity=row.getProductQuantity()==null?null:row.getProductQuantity()-(consumed.containsKey(row.getId())?consumed.get(row.getId()).productQuantity():0);result.add(new DispatchSourceAllocation(row.getId(),remaining.get(row.getId()),quantity));}
         } else {
             var row=rows.get(0);if(row.getProductQuantity()!=null && (productQuantity>knownQuantity || packages==total && productQuantity!=knownQuantity))throw conflict("实际扫码件数与本来源剩余件数不一致");
-            result.add(new Allocation(row.getId(),packages,row.getProductQuantity()==null && productQuantity==0?null:productQuantity));
+            result.add(new DispatchSourceAllocation(row.getId(),packages,row.getProductQuantity()==null && productQuantity==0?null:productQuantity));
         }
         return List.copyOf(result);
     }

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

@@ -65,7 +65,7 @@ public class DispatchPickingService {
         boolean nativeReturn="RETURN_RELABEL".equals(item.getSourceStage());
         if(nativeReturn?request.positionId()!=null:request.positionId()==null)throw bad(nativeReturn?"退货换标请扫描来源箱唛":"普通入仓请选本托实际库存仓位");
         long pickId=IdWorker.getId();Long returnCartonId=null;boolean ordinaryRelabel=!nativeReturn && "RELABEL_ORDER".equals(item.getSourceBusinessType());
-        List<DispatchItemSourceService.Allocation> relabelAllocations=List.of();
+        List<DispatchSourceAllocation> relabelAllocations=List.of();
         if(nativeReturn) {
             attribution.prepareNativeReturn(item.getCustomerId(),item.getOrderId());
             returnCartonId=returns.pick(item,request.cartonMark(),request.packages(),request.productQuantity(),pickId,number).getId();

lastleg-service/src/main/java/com/baiyue/lastleg/dto/LastlegOrderSummary.java

@@ -75,7 +75,9 @@ public record LastlegOrderSummary(
     LocalDateTime updatedAt,
     @Schema(description = "同一主单关联的全部换标子单及各自状态，按创建时间排序")
     List<RelabelSubOrder> relabelApplications,
-    BusinessSource businessSource
+    BusinessSource businessSource,
+    @Schema(description = "仓储转运专属预报、历史实收及当前箱托数量；其他业务为空")
+    com.baiyue.lastleg.transfer.dto.TransferQuantityView warehouseTransferQuantity
 ) {
     @Schema(description = "从正式单据关联读取的商业来源；与履约类型 orderType 独立")
     public record BusinessSource(String businessType, String label, String businessOrderNo, String externalBookingNo) { }

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

@@ -1,13 +1,14 @@
 package com.baiyue.lastleg.fleet.pickup;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baiyue.lastleg.transfer.entity.WarehouseTransferOrder;
 import org.apache.ibatis.annotations.*;
 import java.util.List;
 
 /** 取货持久化只访问 Lastleg 自有库，客户与原业务号始终成对使用。 */
 @Mapper
 public interface FleetPickupMapper extends BaseMapper<FleetPickupTask> {
+    String SOURCE_COLUMNS = "id,customer_id,transfer_no,inbound_code,lastleg_order_no,operating_warehouse_id,"
+        + "delivery_address,pickup_contact_name,pickup_contact_phone,package_count,status,delivery_method";
     String ELIGIBLE = " FROM ll_warehouse_transfer_order w LEFT JOIN ll_fleet_pickup_task p ON p.transfer_order_id=w.id "
         + "WHERE w.delivery_method='WAREHOUSE_PICKUP' AND w.transfer_no=w.inbound_code "
         + "AND w.status='WAIT_PDA_RECEIVING' AND (p.transfer_order_id IS NULL OR p.trip_no IS NULL) "
@@ -21,14 +22,11 @@ public interface FleetPickupMapper extends BaseMapper<FleetPickupTask> {
     @Select("SELECT COUNT(*)" + ELIGIBLE)
     long countCandidates(@Param("keyword") String keyword);
     /** 锁定源订单，串行化补箱、清点与取货任务关联。 */
-    @Select("SELECT * FROM ll_warehouse_transfer_order WHERE customer_id=#{customer} AND transfer_no=#{number} FOR UPDATE")
-    WarehouseTransferOrder lockSource(@Param("customer") String customer,@Param("number") String number);
+    @Select("SELECT " + SOURCE_COLUMNS + " FROM ll_warehouse_transfer_order WHERE customer_id=#{customer} AND transfer_no=#{number} FOR UPDATE")
+    FleetPickupSource lockSource(@Param("customer") String customer,@Param("number") String number);
     /** 读取明确客户下的源订单，不接收来自客户端的客户范围推断。 */
-    @Select("SELECT * FROM ll_warehouse_transfer_order WHERE customer_id=#{customer} AND transfer_no=#{number}")
-    WarehouseTransferOrder source(@Param("customer") String customer,@Param("number") String number);
-    /** PDA 作业仍按已绑定海外仓锁定原单。 */
-    @Select("SELECT * FROM ll_warehouse_transfer_order WHERE operating_warehouse_id=#{warehouse} AND transfer_no=#{number} FOR UPDATE")
-    WarehouseTransferOrder lockPdaSource(@Param("warehouse") String warehouse,@Param("number") String number);
+    @Select("SELECT " + SOURCE_COLUMNS + " FROM ll_warehouse_transfer_order WHERE customer_id=#{customer} AND transfer_no=#{number}")
+    FleetPickupSource source(@Param("customer") String customer,@Param("number") String number);
     /** 读取取货任务，原订单锁负责同票并发互斥。 */
     @Select("SELECT * FROM ll_fleet_pickup_task WHERE transfer_order_id=#{id}")
     FleetPickupTask task(@Param("id") long id);

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

@@ -2,7 +2,6 @@ package com.baiyue.lastleg.fleet.pickup;
 
 import com.baiyue.lastleg.fleet.trip.FleetTripEntity;
 import com.baiyue.lastleg.fleet.trip.FleetTripMapper;
-import com.baiyue.lastleg.transfer.entity.WarehouseTransferOrder;
 import org.springframework.stereotype.Repository;
 import java.util.List;
 
@@ -18,9 +17,7 @@ public class FleetPickupRepository {
     /** 查询匹配需求总数。 */
     public long count(String keyword) { return mapper.countCandidates(keyword); }
     /** 读取或锁定客户原单。 */
-    public WarehouseTransferOrder source(String customer,String number,boolean lock) { return lock?mapper.lockSource(customer,number):mapper.source(customer,number); }
-    /** 按 PDA 仓库范围锁定原单。 */
-    public WarehouseTransferOrder pdaSource(String warehouse,String number) { return mapper.lockPdaSource(warehouse,number); }
+    public FleetPickupSource source(String customer,String number,boolean lock) { return lock?mapper.lockSource(customer,number):mapper.source(customer,number); }
     /** 读取原单唯一取货记录。 */
     public FleetPickupTask task(long id) { return mapper.task(id); }
     /** 读取车次全部取货成员。 */

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

@@ -6,7 +6,6 @@ import com.baiyue.lastleg.fleet.driver.FleetWarehouseDirectory;
 import com.baiyue.lastleg.fleet.reporting.TripOperationsEvidenceGateway;
 import com.baiyue.lastleg.fleet.trip.*;
 import com.baiyue.lastleg.masterdata.vehicle.application.port.out.VehicleRepository;
-import com.baiyue.lastleg.transfer.entity.WarehouseTransferOrder;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.springframework.http.HttpStatus;
@@ -59,7 +58,7 @@ public class FleetPickupService {
         var sources=request.sources().stream().sorted(Comparator.comparing(FleetPickupModels.Source::customerId)
             .thenComparing(FleetPickupModels.Source::transferNo)).toList();
         if(new HashSet<>(sources).size()!=sources.size())throw bad("同一取货单不能重复选择");
-        var orders=new ArrayList<WarehouseTransferOrder>();
+        var orders=new ArrayList<FleetPickupSource>();
         for(var source:sources) {
             var order=source(source.customerId(),source.transferNo(),true);eligible(order);
             // 相同请求并发等待原单锁后，允许返回第一次已经成功的车次。
@@ -107,18 +106,10 @@ public class FleetPickupService {
         if(!"WAREHOUSE_PICKUP".equals(source.getDeliveryMethod()) || !source.getTransferNo().equals(source.getInboundCode()))return null;
         return project(source,repository.task(source.getId()));
     }
-    /** PDA 开始作业前校验已送仓，防止把司机取货冒充仓库实收。 */
-    public WarehouseTransferOrder requireMeasuringSource(String warehouse,String number) {
-        var source=repository.pdaSource(warehouse,number);
-        if(source==null)throw missing("仓储转运单不存在");
-        if(!"WAIT_PDA_RECEIVING".equals(source.getStatus()))throw conflict("当前转运单不允许测量");
-        requireArrived(source);
-        return source;
-    }
     /** 已有原单行锁的清点、照片和完成入口复用相同到仓门禁。 */
-    public void requireArrived(WarehouseTransferOrder source) {
-        if("WAREHOUSE_PICKUP".equals(source.getDeliveryMethod()) && source.getTransferNo().equals(source.getInboundCode())) {
-            var task=repository.task(source.getId());
+    public void requireArrived(Long sourceId,String deliveryMethod,String transferNo,String inboundCode) {
+        if("WAREHOUSE_PICKUP".equals(deliveryMethod) && transferNo.equals(inboundCode)) {
+            var task=repository.task(sourceId);
             if(task==null || !"ARRIVED".equals(task.getStatus()))throw conflict("该单为仓库上门取货，请先完成车辆取货送仓");
         }
     }
@@ -198,7 +189,7 @@ public class FleetPickupService {
         var trip=pickupTrip(task.getTripNo(),false);return files.download(trip.getId(),fileId);
     }
     /** 组装运输进度，车次资源修改后自然回显最新分配。 */
-    private FleetPickupModels.Task project(WarehouseTransferOrder source,FleetPickupTask task) {
+    private FleetPickupModels.Task project(FleetPickupSource source,FleetPickupTask task) {
         var trip=task==null || task.getTripNo()==null?null:repository.trip(task.getTripNo(),false);
         String status=task==null || task.getTripNo()==null?("PENDING_REVIEW".equals(source.getStatus()) || "DRAFT".equals(source.getStatus())?"PENDING_REVIEW":"WAITING"):task.getStatus();
         return new FleetPickupModels.Task(source.getCustomerId(),source.getTransferNo(),source.getLastlegOrderNo(),source.getOperatingWarehouseId(),
@@ -215,11 +206,11 @@ public class FleetPickupService {
         if(task==null || !trip.getTripNo().equals(task.getTripNo()))throw missing("当前车次没有该取货订单");return task;
     }
     /** 按客户与单号读取原订单。 */
-    private WarehouseTransferOrder source(String customer,String number,boolean lock) {
+    private FleetPickupSource source(String customer,String number,boolean lock) {
         var source=repository.source(customer,number,lock);if(source==null)throw missing("仓储转运单不存在");return source;
     }
     /** 原业务资格每次执行复核，禁止未审、自送、库存转运和已完成测量单进入。 */
-    private static void eligible(WarehouseTransferOrder order) {
+    private static void eligible(FleetPickupSource order) {
         if(!"WAREHOUSE_PICKUP".equals(order.getDeliveryMethod()) || !order.getTransferNo().equals(order.getInboundCode())
             || !"WAIT_PDA_RECEIVING".equals(order.getStatus()))throw conflict("该单不是已审核待收货的仓库上门取货单");
         if(blank(order.getDeliveryAddress())==null || blank(order.getPickupContactName())==null || blank(order.getPickupContactPhone())==null)

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

@@ -0,0 +1,20 @@
+package com.baiyue.lastleg.fleet.pickup;
+
+import lombok.Data;
+
+/** 车队只读取货资格和展示所需来源摘要，不共享转运领域实体或写入原订单。 */
+@Data
+public class FleetPickupSource {
+    private Long id;
+    private String customerId;
+    private String transferNo;
+    private String inboundCode;
+    private String lastlegOrderNo;
+    private String operatingWarehouseId;
+    private String deliveryAddress;
+    private String pickupContactName;
+    private String pickupContactPhone;
+    private Integer packageCount;
+    private String status;
+    private String deliveryMethod;
+}

lastleg-service/src/main/java/com/baiyue/lastleg/inventory/query/controller/InventoryQueryController.java

@@ -35,6 +35,16 @@ public class InventoryQueryController {
     private static final String BASE_PATH = "/api/platform/v1/last-leg/inventory";
 
     @Resource private InventoryQueryService service;
+    @Resource private com.baiyue.lastleg.inventory.query.service.InventoryPieceService pieces;
+
+    /** 完整筛选读取当前可用件数、箱内全部SKU及未知箱数，不改变原有箱数契约。 */
+    @GetMapping(BASE_PATH + "/piece-projection")
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.INVENTORY_LIST + "')")
+    public ApiResponse<com.baiyue.lastleg.inventory.query.dto.InventoryPieceProjection> pieceProjection(
+        @AuthenticationPrincipal AuthenticatedUser user,@RequestParam(required=false) String customerId,
+        @Valid InventoryQueryRequests.BalanceQuery query) {
+        return ApiResponse.success(pieces.project(platformScope(user,customerId),query));
+    }
 
     @GetMapping(BASE_PATH + "/summary")
     @PreAuthorize("hasAuthority('" + OverseasPermissions.INVENTORY_LIST + "')")

lastleg-service/src/main/java/com/baiyue/lastleg/inventory/query/dto/InventoryPieceProjection.java

@@ -0,0 +1,14 @@
+package com.baiyue.lastleg.inventory.query.dto;
+import java.util.List;
+/** 当前严格可用件数与完整混箱SKU内容；不完整映射保持未知，不覆盖原有箱数API。 */
+public record InventoryPieceProjection(Long availablePieceCount,long knownAvailablePieceCount,long unknownCartonCount,
+    long availableCartonCount,long availablePalletCount,List<Group> groups) {
+    /** 与通用库存按客户、仓、目的仓、记账SKU分组对齐，箱内SKU不重复累计物理箱。 */
+    public record Group(String customerId,String warehouseId,String destinationCode,String anchorSkuCode,
+        Long availablePieceCount,long knownAvailablePieceCount,long unknownCartonCount,long availableCartonCount,
+        long availablePalletCount,List<Sku> skuContents,List<Carton> cartons) { }
+    /** 箱内实际SKU件数。 */
+    public record Sku(String skuCode,long quantity) { }
+    /** 保留箱唛及所在仓位，混箱SKU共享同一物理箱。 */
+    public record Carton(String cartonMark,Long inventoryPositionId,Long palletId,Long quantity,List<Sku> items) { }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/inventory/query/mapper/InventoryPieceMapper.java

@@ -0,0 +1,73 @@
+package com.baiyue.lastleg.inventory.query.mapper;
+
+import com.baiyue.lastleg.inventory.query.dto.InventoryQueryRequests;
+import org.apache.ibatis.annotations.*;
+import java.util.List;
+
+/** 从原箱清点事实及实际目的仓签收定位箱内SKU，不按首SKU或箱规换算件数。 */
+@Mapper
+public interface InventoryPieceMapper {
+    String POSITION_CTE = "WITH balances AS (SELECT * FROM ll_inventory_balance " + InventoryQueryMapper.BALANCE_FILTER + """
+        ), occupied AS (
+          SELECT DISTINCT t.customer_id,t.operating_warehouse_id warehouse_id,t.inbound_code,
+            COALESCE(NULLIF(c.customer_carton_mark,''),c.carton_mark) carton_mark
+          FROM ll_warehouse_transfer_order t JOIN ll_warehouse_transfer_carton c
+            ON c.transfer_order_id=t.id AND c.customer_id=t.customer_id
+          -- 出库已扣减来源箱，后续签收生成目的仓库存，不再把同一原箱当作待出库预留。
+          WHERE t.transfer_no<>t.inbound_code AND t.status NOT IN
+            ('DRAFT','REJECTED','CANCELLED','OUTBOUNDED','PARTIALLY_RECEIVED','RECEIVED')
+        ), raw_positions AS (SELECT p.* FROM ll_inventory_position p JOIN balances b
+          ON b.id=p.balance_id AND b.customer_id=p.customer_id WHERE p.available_packages>0),
+        located AS (
+          SELECT p.id position_id,c.id carton_id,c.carton_mark,c.counted_quantity,c.sku_items_json
+          FROM raw_positions p JOIN balances b ON b.id=p.balance_id AND b.customer_id=p.customer_id
+          JOIN ll_warehouse_transfer_order t ON t.customer_id=b.customer_id AND t.inbound_order_id=b.inbound_order_id
+            AND t.operating_warehouse_id=b.overseas_warehouse_id AND t.transfer_no=t.inbound_code
+          JOIN ll_warehouse_transfer_pallet tp ON tp.transfer_order_id=t.id AND tp.customer_id=t.customer_id AND tp.warehouse_pallet_id=p.pallet_id
+          JOIN ll_warehouse_transfer_carton c ON c.transfer_order_id=t.id AND c.customer_id=t.customer_id
+            AND c.transfer_pallet_id=tp.id AND c.status='COUNTED'
+          JOIN ll_warehouse_transfer_item i ON i.id=c.transfer_item_id AND i.customer_id=c.customer_id AND (b.sku_code='MIXED' OR i.sku_code=b.sku_code)
+          UNION
+          SELECT p.id,c.id,c.carton_mark,c.counted_quantity,c.sku_items_json
+          FROM raw_positions p JOIN balances b ON b.id=p.balance_id AND b.customer_id=p.customer_id
+          JOIN ll_warehouse_transfer_receipt r ON r.destination_inventory_position_id=p.id AND r.customer_id=p.customer_id
+          JOIN ll_warehouse_transfer_inventory_allocation a ON a.id=r.allocation_id AND a.customer_id=r.customer_id AND a.status='RECEIVED'
+          JOIN ll_inventory_position sp ON sp.id=a.inventory_position_id AND sp.customer_id=a.customer_id
+          JOIN ll_warehouse_transfer_order outgoing ON outgoing.id=a.transfer_order_id AND outgoing.customer_id=a.customer_id
+          JOIN ll_warehouse_transfer_carton chosen ON chosen.transfer_order_id=outgoing.id AND chosen.customer_id=outgoing.customer_id
+          JOIN ll_warehouse_transfer_order origin ON origin.customer_id=outgoing.customer_id AND origin.inbound_code=outgoing.inbound_code
+            AND origin.operating_warehouse_id=outgoing.operating_warehouse_id AND origin.transfer_no=origin.inbound_code
+          JOIN ll_warehouse_transfer_carton c ON c.transfer_order_id=origin.id AND c.customer_id=origin.customer_id
+            AND c.carton_mark=COALESCE(NULLIF(chosen.customer_carton_mark,''),chosen.carton_mark) AND c.status='SHIPPED'
+          JOIN ll_warehouse_transfer_pallet tp ON tp.id=c.transfer_pallet_id AND tp.customer_id=c.customer_id AND tp.warehouse_pallet_id=sp.pallet_id
+          JOIN ll_warehouse_transfer_item i ON i.id=c.transfer_item_id AND i.customer_id=c.customer_id AND (b.sku_code='MIXED' OR i.sku_code=b.sku_code)
+        ), reservations AS (
+          SELECT p.id position_id,COUNT(DISTINCT l.carton_id) reserved_count
+          FROM raw_positions p JOIN balances b ON b.id=p.balance_id AND b.customer_id=p.customer_id
+          JOIN located l ON l.position_id=p.id JOIN occupied o ON o.customer_id=b.customer_id
+            AND o.warehouse_id=b.overseas_warehouse_id AND o.inbound_code=b.inbound_code AND o.carton_mark=l.carton_mark
+          GROUP BY p.id
+        ), positions AS (
+          SELECT p.*,GREATEST(0,p.available_packages-COALESCE(r.reserved_count,0)) free_packages
+          FROM raw_positions p LEFT JOIN reservations r ON r.position_id=p.id
+        )
+        SELECT p.id positionId,p.balance_id balanceId,b.customer_id customerId,b.overseas_warehouse_id warehouseId,
+          b.destination_warehouse_code destinationCode,b.sku_code anchorSkuCode,p.pallet_id palletId,
+          p.free_packages availablePackages,l.carton_id cartonId,l.carton_mark cartonMark,
+          l.counted_quantity countedQuantity,l.sku_items_json skuItemsJson
+        FROM positions p JOIN balances b ON b.id=p.balance_id AND b.customer_id=p.customer_id
+        LEFT JOIN located l ON l.position_id=p.id AND NOT EXISTS (
+          SELECT 1 FROM occupied o WHERE o.customer_id=b.customer_id AND o.warehouse_id=b.overseas_warehouse_id
+            AND o.inbound_code=b.inbound_code AND o.carton_mark=l.carton_mark)
+        WHERE p.free_packages>0
+        ORDER BY p.id,l.carton_id
+        """;
+
+    /** 完整筛选取箱级投影；页码/每页大小不参与查询。 */
+    @Select("<script>" + POSITION_CTE + "</script>")
+    List<PieceRow> rows(@Param("customerId") String customerId,@Param("q") InventoryQueryRequests.BalanceQuery query);
+
+    /** 每个当前可用仓位及其匹配箱事实；未知箱以空cartonId表达。 */
+    record PieceRow(Long positionId,Long balanceId,String customerId,String warehouseId,String destinationCode,
+        String anchorSkuCode,Long palletId,long availablePackages,Long cartonId,String cartonMark,Long countedQuantity,String skuItemsJson) { }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/inventory/query/mapper/InventoryQueryMapper.java

@@ -24,7 +24,7 @@ public interface InventoryQueryMapper {
         "<if test='q.inboundOrderNo != null and q.inboundOrderNo != \"\"'> AND inbound_order_no LIKE CONCAT('%',#{q.inboundOrderNo},'%')</if>" +
         "<if test='q.inboundCode != null and q.inboundCode != \"\"'> AND inbound_code LIKE CONCAT('%',#{q.inboundCode},'%')</if>" +
         "<if test='q.businessOrderNo != null and q.businessOrderNo != \"\"'> AND EXISTS (SELECT 1 FROM ll_inventory_ledger l WHERE l.balance_id=ll_inventory_balance.id AND l.customer_id=ll_inventory_balance.customer_id AND l.business_order_no LIKE CONCAT('%',#{q.businessOrderNo},'%'))</if>" +
-        "<if test='q.skuCode != null and q.skuCode != \"\"'> AND sku_code LIKE CONCAT('%',#{q.skuCode},'%')</if>" +
+        "<if test='q.skuCode != null and q.skuCode != \"\"'> AND (sku_code LIKE CONCAT('%',#{q.skuCode},'%') OR EXISTS (SELECT 1 FROM ll_warehouse_transfer_order tq JOIN ll_warehouse_transfer_carton cq ON cq.transfer_order_id=tq.id AND cq.customer_id=tq.customer_id WHERE tq.customer_id=ll_inventory_balance.customer_id AND tq.inbound_order_id=ll_inventory_balance.inbound_order_id AND tq.operating_warehouse_id=ll_inventory_balance.overseas_warehouse_id AND tq.transfer_no=tq.inbound_code AND cq.status IN ('COUNTED','DISCARD_PENDING') AND EXISTS (SELECT 1 FROM ll_warehouse_transfer_item iq WHERE iq.id=cq.transfer_item_id AND iq.customer_id=cq.customer_id AND (ll_inventory_balance.sku_code='MIXED' OR iq.sku_code=ll_inventory_balance.sku_code)) AND JSON_SEARCH(cq.sku_items_json,'one',CONCAT('%',#{q.skuCode},'%'),NULL,'$[*].skuCode') IS NOT NULL) OR EXISTS (SELECT 1 FROM ll_inventory_position dp JOIN ll_warehouse_transfer_receipt rr ON rr.destination_inventory_position_id=dp.id AND rr.customer_id=dp.customer_id JOIN ll_warehouse_transfer_inventory_allocation aa ON aa.id=rr.allocation_id AND aa.customer_id=rr.customer_id AND aa.status='RECEIVED' JOIN ll_inventory_position sp ON sp.id=aa.inventory_position_id AND sp.customer_id=aa.customer_id JOIN ll_warehouse_transfer_order ot ON ot.id=aa.transfer_order_id AND ot.customer_id=aa.customer_id JOIN ll_warehouse_transfer_carton chosen ON chosen.transfer_order_id=ot.id AND chosen.customer_id=ot.customer_id JOIN ll_warehouse_transfer_order origin ON origin.customer_id=ot.customer_id AND origin.inbound_code=ot.inbound_code AND origin.operating_warehouse_id=ot.operating_warehouse_id AND origin.transfer_no=origin.inbound_code JOIN ll_warehouse_transfer_carton cc ON cc.transfer_order_id=origin.id AND cc.customer_id=origin.customer_id AND cc.carton_mark=COALESCE(NULLIF(chosen.customer_carton_mark,''),chosen.carton_mark) AND cc.status='SHIPPED' JOIN ll_warehouse_transfer_pallet pp ON pp.id=cc.transfer_pallet_id AND pp.customer_id=cc.customer_id AND pp.warehouse_pallet_id=sp.pallet_id JOIN ll_warehouse_transfer_item ii ON ii.id=cc.transfer_item_id AND ii.customer_id=cc.customer_id WHERE dp.balance_id=ll_inventory_balance.id AND dp.customer_id=ll_inventory_balance.customer_id AND dp.available_packages>0 AND (ll_inventory_balance.sku_code='MIXED' OR ii.sku_code=ll_inventory_balance.sku_code) AND JSON_SEARCH(cc.sku_items_json,'one',CONCAT('%',#{q.skuCode},'%'),NULL,'$[*].skuCode') IS NOT NULL))</if>" +
         "<if test='q.productName != null and q.productName != \"\"'> AND (product_name_zh LIKE CONCAT('%',#{q.productName},'%') OR product_name_en LIKE CONCAT('%',#{q.productName},'%'))</if>" +
         "<if test='q.batchNo != null and q.batchNo != \"\"'> AND EXISTS (SELECT 1 FROM ll_inventory_position p WHERE p.balance_id=ll_inventory_balance.id AND p.customer_id=ll_inventory_balance.customer_id AND p.batch_no LIKE CONCAT('%',#{q.batchNo},'%'))</if>" +
         "<if test='q.warehouseLocationCode != null and q.warehouseLocationCode != \"\"'> AND EXISTS (SELECT 1 FROM ll_inventory_position p WHERE p.balance_id=ll_inventory_balance.id AND p.customer_id=ll_inventory_balance.customer_id AND p.warehouse_location_code LIKE CONCAT('%',#{q.warehouseLocationCode},'%'))</if>" +
@@ -48,7 +48,7 @@ public interface InventoryQueryMapper {
         "<if test='q.inboundOrderNo != null and q.inboundOrderNo != \"\"'> AND b.inbound_order_no LIKE CONCAT('%',#{q.inboundOrderNo},'%')</if>" +
         "<if test='q.inboundCode != null and q.inboundCode != \"\"'> AND b.inbound_code LIKE CONCAT('%',#{q.inboundCode},'%')</if>" +
         "<if test='q.businessOrderNo != null and q.businessOrderNo != \"\"'> AND EXISTS (SELECT 1 FROM ll_inventory_ledger l WHERE l.balance_id=b.id AND l.customer_id=b.customer_id AND l.business_order_no LIKE CONCAT('%',#{q.businessOrderNo},'%'))</if>" +
-        "<if test='q.skuCode != null and q.skuCode != \"\"'> AND b.sku_code LIKE CONCAT('%',#{q.skuCode},'%')</if>" +
+        "<if test='q.skuCode != null and q.skuCode != \"\"'> AND (b.sku_code LIKE CONCAT('%',#{q.skuCode},'%') OR EXISTS (SELECT 1 FROM ll_warehouse_transfer_order tq JOIN ll_warehouse_transfer_carton cq ON cq.transfer_order_id=tq.id AND cq.customer_id=tq.customer_id WHERE tq.customer_id=b.customer_id AND tq.inbound_order_id=b.inbound_order_id AND tq.operating_warehouse_id=b.overseas_warehouse_id AND tq.transfer_no=tq.inbound_code AND cq.status IN ('COUNTED','DISCARD_PENDING') AND EXISTS (SELECT 1 FROM ll_warehouse_transfer_item iq WHERE iq.id=cq.transfer_item_id AND iq.customer_id=cq.customer_id AND (b.sku_code='MIXED' OR iq.sku_code=b.sku_code)) AND JSON_SEARCH(cq.sku_items_json,'one',CONCAT('%',#{q.skuCode},'%'),NULL,'$[*].skuCode') IS NOT NULL) OR EXISTS (SELECT 1 FROM ll_inventory_position dp JOIN ll_warehouse_transfer_receipt rr ON rr.destination_inventory_position_id=dp.id AND rr.customer_id=dp.customer_id JOIN ll_warehouse_transfer_inventory_allocation aa ON aa.id=rr.allocation_id AND aa.customer_id=rr.customer_id AND aa.status='RECEIVED' JOIN ll_inventory_position sp ON sp.id=aa.inventory_position_id AND sp.customer_id=aa.customer_id JOIN ll_warehouse_transfer_order ot ON ot.id=aa.transfer_order_id AND ot.customer_id=aa.customer_id JOIN ll_warehouse_transfer_carton chosen ON chosen.transfer_order_id=ot.id AND chosen.customer_id=ot.customer_id JOIN ll_warehouse_transfer_order origin ON origin.customer_id=ot.customer_id AND origin.inbound_code=ot.inbound_code AND origin.operating_warehouse_id=ot.operating_warehouse_id AND origin.transfer_no=origin.inbound_code JOIN ll_warehouse_transfer_carton cc ON cc.transfer_order_id=origin.id AND cc.customer_id=origin.customer_id AND cc.carton_mark=COALESCE(NULLIF(chosen.customer_carton_mark,''),chosen.carton_mark) AND cc.status='SHIPPED' JOIN ll_warehouse_transfer_pallet pp ON pp.id=cc.transfer_pallet_id AND pp.customer_id=cc.customer_id AND pp.warehouse_pallet_id=sp.pallet_id JOIN ll_warehouse_transfer_item ii ON ii.id=cc.transfer_item_id AND ii.customer_id=cc.customer_id WHERE dp.balance_id=b.id AND dp.customer_id=b.customer_id AND dp.available_packages>0 AND (b.sku_code='MIXED' OR ii.sku_code=b.sku_code) AND JSON_SEARCH(cc.sku_items_json,'one',CONCAT('%',#{q.skuCode},'%'),NULL,'$[*].skuCode') IS NOT NULL))</if>" +
         "<if test='q.productName != null and q.productName != \"\"'> AND (b.product_name_zh LIKE CONCAT('%',#{q.productName},'%') OR b.product_name_en LIKE CONCAT('%',#{q.productName},'%'))</if>" +
         "<if test='q.batchNo != null and q.batchNo != \"\"'> AND EXISTS (SELECT 1 FROM ll_inventory_position p2 WHERE p2.balance_id=b.id AND p2.customer_id=b.customer_id AND p2.batch_no LIKE CONCAT('%',#{q.batchNo},'%'))</if>" +
         "<if test='q.warehouseLocationCode != null and q.warehouseLocationCode != \"\"'> AND EXISTS (SELECT 1 FROM ll_inventory_position p2 WHERE p2.balance_id=b.id AND p2.customer_id=b.customer_id AND p2.warehouse_location_code LIKE CONCAT('%',#{q.warehouseLocationCode},'%'))</if>" +

lastleg-service/src/main/java/com/baiyue/lastleg/inventory/query/repository/InventoryPieceRepository.java

@@ -0,0 +1,15 @@
+package com.baiyue.lastleg.inventory.query.repository;
+import com.baiyue.lastleg.inventory.query.dto.InventoryQueryRequests;
+import com.baiyue.lastleg.inventory.query.mapper.InventoryPieceMapper;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Repository;
+import java.util.List;
+/** 统一库存混箱事实查询入口。 */
+@Repository
+public class InventoryPieceRepository {
+    @Resource private InventoryPieceMapper mapper;
+    /** 读取相同筛选范围的全部当前可用箱。 */
+    public List<InventoryPieceMapper.PieceRow> rows(String customerId,InventoryQueryRequests.BalanceQuery query) {
+        return mapper.rows(customerId,query);
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/inventory/query/service/InventoryPieceService.java

@@ -0,0 +1,71 @@
+package com.baiyue.lastleg.inventory.query.service;
+import com.baiyue.lastleg.inventory.query.dto.*;
+import com.baiyue.lastleg.inventory.query.mapper.InventoryPieceMapper.PieceRow;
+import com.baiyue.lastleg.inventory.query.repository.InventoryPieceRepository;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/** 用完整箱内清点投影当前可用件数，对缺失或不完整映射显式返回未知。 */
+@Service
+public class InventoryPieceService {
+    @Resource private InventoryPieceRepository repository;
+    @Resource private ObjectMapper objectMapper;
+    /** 完整筛选的多分组汇总，同一物理托盘按客户及仓去重而非相减。 */
+    @Transactional(readOnly=true)
+    public InventoryPieceProjection project(String customerId,InventoryQueryRequests.BalanceQuery query) {
+        var rows=repository.rows(customerId,query);
+        var groups=rows.stream().collect(Collectors.groupingBy(r -> Arrays.asList(r.customerId(),r.warehouseId(),r.destinationCode(),r.anchorSkuCode()),LinkedHashMap::new,Collectors.toList()));
+        var result=new ArrayList<InventoryPieceProjection.Group>(); var pallets=new HashSet<String>();
+        for(var group:groups.values()) {
+            result.add(group(group));
+            for(var row:group) if(row.palletId()!=null) pallets.add(row.customerId()+":"+row.warehouseId()+":"+row.palletId());
+        }
+        long known=0,unknown=0,cartons=0;
+        for(var group:result) { known=Math.addExact(known,group.knownAvailablePieceCount()); unknown+=group.unknownCartonCount(); cartons+=group.availableCartonCount(); }
+        return new InventoryPieceProjection(unknown==0?known:null,known,unknown,cartons,pallets.size(),result);
+    }
+
+    /** 每个仓位只有精确箱映射完整时才计入已知件数，不能从多余箱中截取或按比例推算。 */
+    private InventoryPieceProjection.Group group(List<PieceRow> rows) {
+        var positions=rows.stream().collect(Collectors.groupingBy(PieceRow::positionId,LinkedHashMap::new,Collectors.toList()));
+        var contents=new TreeMap<String,Long>(); var cartons=new ArrayList<InventoryPieceProjection.Carton>();
+        var pallets=new HashSet<Long>(); long available=0,unknown=0,known=0;
+        for(var position:positions.values()) {
+            var first=position.get(0); available+=first.availablePackages(); if(first.palletId()!=null) pallets.add(first.palletId());
+            var boxes=position.stream().filter(r -> r.cartonId()!=null).collect(Collectors.toMap(PieceRow::cartonId,r -> r,(a,b)->a,LinkedHashMap::new));
+            var parsed=new ArrayList<InventoryPieceProjection.Carton>();
+            for(var row:boxes.values()) parsed.add(carton(row));
+            if(boxes.size()!=first.availablePackages() || parsed.stream().anyMatch(c -> c.quantity()==null)) { unknown+=first.availablePackages(); continue; }
+            for(var box:parsed) {
+                cartons.add(box); known=Math.addExact(known,box.quantity());
+                for(var sku:box.items()) contents.merge(sku.skuCode(),sku.quantity(),Math::addExact);
+            }
+        }
+        var first=rows.get(0);
+        return new InventoryPieceProjection.Group(first.customerId(),first.warehouseId(),first.destinationCode(),first.anchorSkuCode(),
+            unknown==0?known:null,known,unknown,available,pallets.size(),contents.entrySet().stream().map(e -> new InventoryPieceProjection.Sku(e.getKey(),e.getValue())).toList(),cartons);
+    }
+
+    /** 清点JSON与箱总件数必须一致；缺失信息保持未知，不拿首SKU替代混箱。 */
+    private InventoryPieceProjection.Carton carton(PieceRow row) {
+        var items=new ArrayList<InventoryPieceProjection.Sku>(); Long quantity=null;
+        try {
+            var lines=objectMapper.readTree(row.skuItemsJson()); long sum=0;
+            if(lines.isArray() && !lines.isEmpty()) {
+                for(var line:lines) {
+                    String sku=line.path("skuCode").asText(""); var count=line.path("quantity");
+                    if(sku.isBlank() || !count.asText().matches("[0-9]+")) throw new IllegalArgumentException("无效箱内SKU事实");
+                    long pieces=Long.parseLong(count.asText());
+                    if(pieces<=0) throw new IllegalArgumentException("箱内件数必须为正整数");
+                    items.add(new InventoryPieceProjection.Sku(sku,pieces)); sum=Math.addExact(sum,pieces);
+                }
+                if(row.countedQuantity()!=null && sum==row.countedQuantity()) quantity=sum;
+            }
+        } catch(Exception invalid) { items.clear(); }
+        return new InventoryPieceProjection.Carton(row.cartonMark(),row.positionId(),row.palletId(),quantity,items);
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/palletops/controller/PlatformPalletOperationRecoveryController.java

@@ -0,0 +1,24 @@
+package com.baiyue.lastleg.palletops.controller;
+
+import com.baiyue.common.core.api.ApiResponse;
+import com.baiyue.common.security.AuthenticatedUser;
+import com.baiyue.lastleg.palletops.service.PalletOperationRecoveryService;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import jakarta.validation.Valid;
+
+/** 受库存管理权限保护的人工恢复入口，不允许PDA自行批准技术状态关闭。 */
+@RestController
+@RequestMapping("/api/platform/v1/last-leg/pallet-operation-recoveries")
+@PreAuthorize("hasAuthority('lastleg:inventory:manage')")
+public class PlatformPalletOperationRecoveryController {
+    private final PalletOperationRecoveryService service;
+    /** 注入恢复业务服务。 */
+    public PlatformPalletOperationRecoveryController(PalletOperationRecoveryService service){this.service=service;}
+    /** 管理员读取原作业证据。 */
+    @GetMapping("/{id}") public ApiResponse<PalletOperationRecoveryService.State> inspect(@PathVariable long id){return ApiResponse.success(service.inspect(id));}
+    /** 以认证管理员身份审计关闭。 */
+    @PostMapping("/{id}/close-no-effect")
+    public ApiResponse<PalletOperationRecoveryService.Recovery> close(@PathVariable long id,@AuthenticationPrincipal AuthenticatedUser user,@Valid @RequestBody PalletOperationRecoveryService.Close request){return ApiResponse.success(service.close(id,String.valueOf(user.userId()),request));}
+}

lastleg-service/src/main/java/com/baiyue/lastleg/palletops/mapper/PalletOperationRecoveryMapper.java

@@ -0,0 +1,25 @@
+package com.baiyue.lastleg.palletops.mapper;
+
+import com.baiyue.lastleg.palletops.entity.PdaPalletOperation;
+import org.apache.ibatis.annotations.*;
+import java.time.LocalDateTime;
+
+/** 恢复与远端意图使用同一行CAS，恢复关闭后旧执行线程不能继续发起远端写入。 */
+@Mapper
+public interface PalletOperationRecoveryMapper {
+    /** 读取原作业技术状态。 */
+    @Select("SELECT * FROM ll_pda_pallet_operation WHERE id=#{id}")
+    PdaPalletOperation find(@Param("id") long id);
+    /** 恢复审批与远端意图按原行串行。 */
+    @Select("SELECT * FROM ll_pda_pallet_operation WHERE id=#{id} FOR UPDATE")
+    PdaPalletOperation lock(@Param("id") long id);
+    /** 恢复关闭后拒绝继续持久化远端意图。 */
+    @Update("UPDATE ll_pda_pallet_operation SET remote_transitions_json=#{json},updated_at=#{at} WHERE id=#{id} AND status='PROCESSING'")
+    int journal(@Param("id") long id,@Param("json") String json,@Param("at") LocalDateTime at);
+    /** 条件关闭原作业并保存恢复审计。 */
+    @Update("UPDATE ll_pda_pallet_operation SET status='RECOVERED_NO_EFFECT',result_json=#{audit},updated_at=#{at} WHERE id=#{id} AND status IN ('PROCESSING','FAILED_COMPENSATED')")
+    int close(@Param("id") long id,@Param("audit") String audit,@Param("at") LocalDateTime at);
+    /** 旧执行线程不能用失败结果覆盖已恢复或已完成终态。 */
+    @Update("UPDATE ll_pda_pallet_operation SET status=#{status},last_error=#{error},updated_at=#{at} WHERE id=#{id} AND status NOT IN ('RECOVERED_NO_EFFECT','COMPLETED')")
+    int fail(@Param("id") long id,@Param("status") String status,@Param("error") String error,@Param("at") LocalDateTime at);
+}

lastleg-service/src/main/java/com/baiyue/lastleg/palletops/mapper/PdaPalletOperationMapper.java

@@ -53,11 +53,15 @@ public interface PdaPalletOperationMapper extends BaseMapper<PdaPalletOperation>
     @Options(useCache=false, flushCache=Options.FlushCachePolicy.TRUE)
     List<MutationPallet> mutationPallets(@Param("warehouseId") String warehouseId, @Param("applicationNos") List<String> applicationNos);
 
-    /** 收齐原入仓、退回实收、计划及原生退货业务订单，不使用MIN或其他客户代表行。 */
+    /** 收齐真实尾程订单；入仓快照ID经同客户来源分片解析，缺失关联保留空值以拒绝改绑。 */
     @Select("<script>SELECT a.customer_id AS customerId,a.lastleg_order_id AS orderId FROM ll_relabel_application a WHERE a.relabel_no IN " + MUTATION_APPS
-        + " UNION SELECT i.customer_id,i.source_inbound_order_id FROM ll_relabel_item i JOIN ll_relabel_application a ON a.id=i.application_id AND a.customer_id=i.customer_id "
+        + " UNION SELECT i.customer_id,original.id FROM ll_relabel_item i JOIN ll_relabel_application a ON a.id=i.application_id AND a.customer_id=i.customer_id "
+        + "LEFT JOIN ll_inbound_order inbound ON inbound.id=i.source_inbound_order_id AND inbound.customer_id=i.customer_id "
+        + "LEFT JOIN ll_order original ON original.customer_id=inbound.customer_id AND original.source_inbound_id=inbound.source_inbound_id "
         + "WHERE a.relabel_no IN " + MUTATION_APPS + " AND i.return_carton_id IS NULL"
-        + " UNION SELECT p.customer_id,b.inbound_order_id FROM ll_inventory_position p JOIN ll_inventory_balance b ON b.id=p.balance_id AND b.customer_id=p.customer_id "
+        + " UNION SELECT p.customer_id,original.id FROM ll_inventory_position p JOIN ll_inventory_balance b ON b.id=p.balance_id AND b.customer_id=p.customer_id "
+        + "LEFT JOIN ll_inbound_order inbound ON inbound.id=b.inbound_order_id AND inbound.customer_id=b.customer_id "
+        + "LEFT JOIN ll_order original ON original.customer_id=inbound.customer_id AND original.source_inbound_id=inbound.source_inbound_id "
         + "WHERE p.overseas_warehouse_id=#{warehouseId} AND p.pallet_id IN " + MUTATION_IDS
         + " UNION SELECT r.customer_id,r.order_id FROM ll_inbound_stock_receipt r JOIN ll_inventory_position p ON p.id=r.inventory_position_id AND p.customer_id=r.customer_id "
         + "WHERE p.overseas_warehouse_id=#{warehouseId} AND r.warehouse_pallet_id IN " + MUTATION_IDS

lastleg-service/src/main/java/com/baiyue/lastleg/palletops/repository/PalletOperationRecoveryRepository.java

@@ -0,0 +1,24 @@
+package com.baiyue.lastleg.palletops.repository;
+
+import com.baiyue.lastleg.palletops.mapper.PalletOperationRecoveryMapper;
+import com.baiyue.lastleg.palletops.entity.PdaPalletOperation;
+import org.springframework.stereotype.Repository;
+import java.time.LocalDateTime;
+
+/** 只封装本域作业记录的读取、串行锁和条件写入。 */
+@Repository
+public class PalletOperationRecoveryRepository {
+    private final PalletOperationRecoveryMapper mapper;
+    /** 注入本域作业条件写入映射。 */
+    public PalletOperationRecoveryRepository(PalletOperationRecoveryMapper mapper){this.mapper=mapper;}
+    /** 读取原作业。 */
+    public PdaPalletOperation find(long id){return mapper.find(id);}
+    /** 为恢复审批锁定原记录。 */
+    public PdaPalletOperation lock(long id){return mapper.lock(id);}
+    /** 条件持久化远端意图。 */
+    public boolean journal(long id,String json,LocalDateTime at){return mapper.journal(id,json,at)==1;}
+    /** 条件保存恢复终态和审计。 */
+    public boolean close(long id,String audit,LocalDateTime at){return mapper.close(id,audit,at)==1;}
+    /** 失败写入同样保护已恢复终态。 */
+    public boolean fail(long id,String status,String error,LocalDateTime at){return mapper.fail(id,status,error,at)==1;}
+}

lastleg-service/src/main/java/com/baiyue/lastleg/palletops/service/PalletOperationRecoveryService.java

@@ -0,0 +1,58 @@
+package com.baiyue.lastleg.palletops.service;
+
+import com.baiyue.lastleg.palletops.repository.PalletOperationRecoveryRepository;
+import com.baiyue.lastleg.palletops.entity.PdaPalletOperation;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.server.ResponseStatusException;
+import org.springframework.http.HttpStatus;
+import jakarta.validation.constraints.*;
+import java.time.LocalDateTime;
+
+/** 只关闭已超时且从未发出远端请求的换标组托，不把未知远端结果推定为无效果。 */
+@Service
+public class PalletOperationRecoveryService {
+    private final PalletOperationRecoveryRepository repository;
+    private final ObjectMapper json;
+    /** 注入本域作业仓储和统一序列化器。 */
+    public PalletOperationRecoveryService(PalletOperationRecoveryRepository repository,ObjectMapper json){this.repository=repository;this.json=json;}
+    public record Close(@Positive long warehouseId,@NotNull LocalDateTime expectedUpdatedAt,
+                        @NotBlank @Size(max=255) String idempotencyKey,@NotBlank @Size(max=1000) String reason){}
+    public record Recovery(String operationId,String status,String recoveryKey,String operatorId,String reason,
+                           String previousStatus,String previousError,LocalDateTime closedAt,boolean replayed){}
+    public record State(String operationId,String status,String operatorKey,long warehouseId,String operationType,
+                        String requestHash,String remoteTransitionsJson,String lastError,LocalDateTime updatedAt){}
+    /** 管理员只读核对原记录和不可变请求哈希，不返回其他账号会话。 */
+    @Transactional(readOnly=true)
+    public State inspect(long id){var row=required(repository.find(id));return new State(String.valueOf(id),row.getStatus(),row.getOperatorKey(),row.getOverseasWarehouseId(),row.getOperationType(),row.getRequestHash(),row.getRemoteTransitionsJson(),row.getLastError(),row.getUpdatedAt());}
+    /** 行锁与远端意图CAS互斥；审计写在原作业结果中，原错误和请求哈希保留。 */
+    @Transactional
+    public Recovery close(long id,String operatorId,Close request){
+        var row=required(repository.lock(id));
+        if(row.getOverseasWarehouseId()!=request.warehouseId())throw conflict("作业不属于指定仓库");
+        if("RECOVERED_NO_EFFECT".equals(row.getStatus())){
+            var existing=read(row.getResultJson());
+            if(!existing.recoveryKey().equals(request.idempotencyKey())||!existing.reason().equals(request.reason())||!existing.operatorId().equals(operatorId))throw conflict("恢复幂等键或载荷不一致");
+            return new Recovery(existing.operationId(),existing.status(),existing.recoveryKey(),existing.operatorId(),existing.reason(),existing.previousStatus(),existing.previousError(),existing.closedAt(),true);
+        }
+        // 已补偿失败仍须核对没有任何远端意图，不能仅凭补偿状态推断无效果。
+        if(!"RELABEL_PALLET_DISASSEMBLE".equals(row.getOperationType())||!("PROCESSING".equals(row.getStatus())||"FAILED_COMPENSATED".equals(row.getStatus())))throw conflict("只允许恢复超时的处理中或已补偿失败换标组托");
+        if(!request.expectedUpdatedAt().equals(row.getUpdatedAt())||row.getUpdatedAt()==null||row.getUpdatedAt().isAfter(LocalDateTime.now().minusMinutes(15)))throw conflict("作业仍活跃或版本已变化，请刷新后核对");
+        if(row.getResultJson()!=null&&!row.getResultJson().isBlank())throw conflict("作业已有结果，不能关闭为无效果");
+        try{if(row.getRemoteTransitionsJson()!=null&&!row.getRemoteTransitionsJson().isBlank()){
+            var attempts=json.readTree(row.getRemoteTransitionsJson());
+            if(!attempts.isArray()||!attempts.isEmpty())throw conflict("存在远端意图或回执，必须先核实远端效果，不能执行无效果恢复");
+        }}catch(com.fasterxml.jackson.core.JsonProcessingException e){throw conflict("远端意图记录不可解析，禁止恢复");}
+        var result=new Recovery(String.valueOf(id),"RECOVERED_NO_EFFECT",request.idempotencyKey(),operatorId,request.reason(),row.getStatus(),row.getLastError(),LocalDateTime.now(),false);
+        try{if(!repository.close(id,json.writeValueAsString(result),result.closedAt()))throw conflict("作业状态已变化，恢复未写入");}
+        catch(com.fasterxml.jackson.core.JsonProcessingException e){throw new IllegalStateException("恢复审计序列化失败",e);}
+        return result;
+    }
+    /** 重放只读取已持久化的恢复审计。 */
+    private Recovery read(String value){try{return json.readValue(value,Recovery.class);}catch(Exception e){throw conflict("恢复审计不可读取");}}
+    /** 原记录不存在时明确拒绝，不新建作业。 */
+    private PdaPalletOperation required(PdaPalletOperation row){if(row==null)throw new ResponseStatusException(HttpStatus.NOT_FOUND,"托盘作业不存在");return row;}
+    /** 统一表达恢复条件或幂等载荷冲突。 */
+    private ResponseStatusException conflict(String message){return new ResponseStatusException(HttpStatus.CONFLICT,message);}
+}

lastleg-service/src/main/java/com/baiyue/lastleg/palletops/service/PdaPalletOperationService.java

@@ -54,6 +54,7 @@ import java.util.HexFormat;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
@@ -63,6 +64,7 @@ import java.util.stream.Collectors;
 public class PdaPalletOperationService {
     @Resource private PdaPalletOperationMapper mapper;
     @Resource private PdaPalletOperationRepository mutationRepository;
+    @Resource private com.baiyue.lastleg.palletops.repository.PalletOperationRecoveryRepository recoveryRepository;
     @Resource private PhysicalPalletSerialPort physicalPalletSerial;
     private Clock mutationClock = Clock.systemUTC();
     @Resource private com.baiyue.lastleg.inventory.command.mapper.InventoryCommandMapper inventoryCommands;
@@ -257,7 +259,10 @@ public class PdaPalletOperationService {
         List<RelabelItem> selected = relabelItems.selectList(new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<RelabelItem>()
             .eq("application_id", application.getId()).eq("customer_id", application.getCustomerId())
             .in("carton_mark", marks));
-        if (selected.size() != marks.size()
+        // 同一退货实物来源允许多个SKU按件任务；普通箱任务仍必须一箱一项。
+        boolean bulkSkuSource = selected.stream().allMatch(item -> item.getReturnCartonId() != null
+            && "RETURN_BULK_SKU_LABEL".equals(item.getOperationType()));
+        if ((!bulkSkuSource && selected.size() != marks.size())
             || selected.stream().map(RelabelItem::getCartonMark).distinct().count() != marks.size()) {
             throw conflict("提交的箱唛不属于当前换标单");
         }
@@ -417,8 +422,10 @@ public class PdaPalletOperationService {
             // 先取得共同串行锁再触碰远端；本地失败补偿也必须在该锁释放前结束。
             try {
             applyPhysical(operation,identity.overseasWarehouseId(),target,"OCCUPIED",target.locationId(),key,"退货换标组托",journal);
+            Set<Long> movedCartons = new HashSet<>();
             for (int index = 0; index < cartons.size(); index++) {
                 RelabelItem item = selected.get(index);
+                if (!movedCartons.add(item.getReturnCartonId())) continue;
                 ReturnInventoryCarton carton = returnCartons.lockId(item.getReturnCartonId());
                 if (carton == null || !Objects.equals(carton.getCustomerId(), application.getCustomerId())
                     || (unboundSource ? (org.springframework.util.StringUtils.hasText(carton.getPalletCode()) && !"UNBOUND".equalsIgnoreCase(carton.getPalletCode()))
@@ -426,8 +433,18 @@ public class PdaPalletOperationService {
                     || !Objects.equals(carton.getRelabelApplicationId(), application.getId())
                     || !"RELABEL_PENDING".equals(carton.getStatus()))
                     throw conflict("退货换标来源库存已变化，请刷新后重试");
+                var sameSource = selected.stream().filter(line -> Objects.equals(line.getReturnCartonId(), carton.getId())).toList();
                 long move = "RETURN_BULK_SKU_LABEL".equals(item.getOperationType())
-                    ? value(item.getNotifiedPackageCount()) : value(carton.getTotalQuantity());
+                    ? sameSource.stream().mapToLong(line -> value(line.getNotifiedPackageCount())).sum() : value(carton.getTotalQuantity());
+                if (sameSource.size() > 1) {
+                    // 同一实物的多SKU整批只移动一次；部分混源必须先拆成独立实物，不能逐SKU虚构新箱。
+                    var requestedSkus = new HashMap<String, Long>();
+                    sameSource.forEach(line -> requestedSkus.merge(line.getSkuCode().toUpperCase(Locale.ROOT), (long) value(line.getNotifiedPackageCount()), Long::sum));
+                    var actualSkus = new HashMap<String, Long>();
+                    returnCartonItems.lockCarton(carton.getId()).forEach(line -> actualSkus.merge(line.getSkuCode().toUpperCase(Locale.ROOT), value(line.getQuantity()), Long::sum));
+                    if (move != value(carton.getTotalQuantity()) || !requestedSkus.equals(actualSkus))
+                        throw conflict("多SKU来源须整批完成并核平；部分贴标请先分拣为独立实物");
+                }
                 if (move <= 0 || move > value(carton.getTotalQuantity())) throw conflict("来源托盘可拆数量不足");
                 if (move < value(carton.getTotalQuantity())) {
                     splitReturnRelabelCarton(application, item, carton, target, move);
@@ -439,7 +456,7 @@ public class PdaPalletOperationService {
                     returnCartons.updateById(carton);
                 }
             }
-            recordReturnRelabelBinding(identity, application, selected, target.palletCode());
+            recordReturnRelabelBinding(identity, application, selected, source == null ? "" : source.palletCode(), target.palletCode());
             List<PalletOperationResponses.PalletContent> contents = source == null
                 ? List.of(content(identity.overseasWarehouseId(), physical.resolve(target.palletCode())))
                 : List.of(content(identity.overseasWarehouseId(), physical.resolve(source.palletCode())),
@@ -972,6 +989,7 @@ public class PdaPalletOperationService {
         return marks;
     }
 
+    /** 记录经过实物来源校验的逐任务绑定，避免多来源数组失去箱与托盘的精确关系。 */
     private void recordRelabelBinding(PdaWarehouseIdentity identity, RelabelMutation mutation,
                                       Map<Long, InventoryPosition> targets) {
         var app = mutation.application();
@@ -987,7 +1005,11 @@ public class PdaPalletOperationService {
             mutation.itemsByPosition().values().stream().flatMap(List::stream).toList(),
             mutation.itemsByPosition().keySet().stream().map(positions::selectById).filter(Objects::nonNull).findFirst().orElseThrow().getPalletId(),
             targets.values().iterator().next().getPalletId(), targets.values().iterator().next().getPalletNo(), mutation.measuredCartons());
-        record.setDetailJson(write(Map.of("round", Objects.toString(task.getReviewedAt(), "INITIAL"),
+        var itemBindings = mutation.itemsByPosition().entrySet().stream().flatMap(entry -> entry.getValue().stream().map(item ->
+            Map.of("itemId", String.valueOf(item.getId()), "sourceKnown", true,
+                "sourcePalletCode", Objects.toString(positions.selectById(entry.getKey()).getPalletNo(), ""),
+                "targetPalletCode", targets.get(entry.getKey()).getPalletNo()))).toList();
+        record.setDetailJson(write(Map.of("round", Objects.toString(task.getReviewedAt(), "INITIAL"), "itemBindings", itemBindings,
             "measuredCartons", measured,
             "cartonMarks", mutation.itemsByPosition().values().stream().flatMap(List::stream).map(RelabelItem::getCartonMark).toList(),
             "targetPallets", targets.values().stream().map(InventoryPosition::getPalletNo).distinct().toList(),
@@ -996,8 +1018,9 @@ public class PdaPalletOperationService {
         relabelWorkHistory.insert(record);
     }
 
+    /** 来源实托在变更前已经核对，历史只记录该次校验值，不反查变更后的库存托盘。 */
     private void recordReturnRelabelBinding(PdaWarehouseIdentity identity, RelabelApplication app,
-                                             List<RelabelItem> items, String targetPallet) {
+                                             List<RelabelItem> items, String sourcePallet, String targetPallet) {
         var task = relabelWorkTasks.find(app.getCustomerId(), app.getId());
         if (task == null) throw conflict("退货换标作业任务不存在，不能记录组托");
         var record = new com.baiyue.lastleg.relabel.pda.entity.PdaRelabelHistory();
@@ -1007,6 +1030,8 @@ public class PdaPalletOperationService {
         record.setOperatorKey(identity.operatorKey()); record.setOperatorName(identity.operatorName());
         record.setCreatedAt(LocalDateTime.now());
         record.setDetailJson(write(Map.of("round", Objects.toString(task.getReviewedAt(), "INITIAL"),
+            "itemBindings", items.stream().map(item -> Map.of("itemId", String.valueOf(item.getId()), "sourceKnown", true,
+                "sourcePalletCode", sourcePallet, "targetPalletCode", targetPallet)).toList(),
             "cartonMarks", items.stream().map(RelabelItem::getCartonMark).toList(),
             "targetPallets", List.of(targetPallet))));
         relabelWorkHistory.insert(record);
@@ -1200,17 +1225,18 @@ public class PdaPalletOperationService {
         newTransaction.executeWithoutResult(status -> {
             PdaPalletOperation operation = mapper.selectById(operationId);
             if (operation == null) throw new IllegalStateException("实托作业意图记录不存在，不能发出远端请求");
-            operation.setRemoteTransitionsJson(write(attempts)); operation.setUpdatedAt(LocalDateTime.now());
-            mapper.updateById(operation);
+            if (!recoveryRepository.journal(operationId, write(attempts), LocalDateTime.now()))
+                throw conflict("作业已由管理员恢复关闭，禁止继续发出远端请求");
         });
     }
+    /** 条件记录失败，避免旧线程覆盖管理员已恢复的原记录。 */
     private void fail(long operationId, RuntimeException failure, boolean compensated) {
         newTransaction.executeWithoutResult(status -> {
             PdaPalletOperation operation = mapper.selectById(operationId);
-            if (operation == null || "COMPLETED".equals(operation.getStatus())) return;
+            if (operation == null || "COMPLETED".equals(operation.getStatus()) || "RECOVERED_NO_EFFECT".equals(operation.getStatus())) return;
             operation.setStatus(compensated ? "FAILED_COMPENSATED" : "COMPENSATION_REQUIRED");
             operation.setLastError(limit(failure.getMessage(), 2000)); operation.setUpdatedAt(LocalDateTime.now());
-            mapper.updateById(operation);
+            recoveryRepository.fail(operationId, operation.getStatus(), operation.getLastError(), operation.getUpdatedAt());
         });
     }
     private boolean compensate(long warehouseId, List<PalletPhysicalGateway.Transition> transitions) {

lastleg-service/src/main/java/com/baiyue/lastleg/query/LastlegOrderFilter.java

@@ -0,0 +1,52 @@
+package com.baiyue.lastleg.query;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baiyue.lastleg.entity.LastlegOrder;
+import com.baiyue.lastleg.dto.LastlegOrderRequests;
+import com.baiyue.lastleg.mapper.LastlegOrderMapper;
+import org.springframework.util.StringUtils;
+import org.springframework.web.server.ResponseStatusException;
+import org.springframework.http.HttpStatus;
+
+/** 列表与退货全筛选统计共用筛选，避免分页和汇总的客户、状态或时间边界漂移。 */
+public final class LastlegOrderFilter {
+    /** 纯筛选工具不允许实例化。 */
+    private LastlegOrderFilter() { }
+    /** 只生成参数绑定的筛选，不读取数据库，不包含分页和排序。 */
+    public static LambdaQueryWrapper<LastlegOrder> create(String customerId, LastlegOrderRequests.Query query, String relabelNo) {
+        if (query.createdFrom() != null && query.createdTo() != null && query.createdFrom().isAfter(query.createdTo())) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "createdFrom must not be after createdTo");
+        }
+        String currentStatus = StringUtils.hasText(query.currentStatus()) ? query.currentStatus() : query.status();
+        String warehouse = StringUtils.hasText(query.warehouse()) ? query.warehouse().trim() : null;
+        return new LambdaQueryWrapper<LastlegOrder>()
+            .ne(LastlegOrder::getOrderType, "CARGO_DISCARD")
+            .eq(StringUtils.hasText(customerId), LastlegOrder::getCustomerId, customerId)
+            .and(StringUtils.hasText(query.orderNo()), nested -> nested
+                .like(LastlegOrder::getOrderNo, query.orderNo())
+                .or()
+                .like(LastlegOrder::getSourceOrderNo, query.orderNo()))
+            .and(StringUtils.hasText(relabelNo), nested -> nested
+                .like(LastlegOrder::getRelabelOrderNo, relabelNo)
+                .or().apply("EXISTS (SELECT 1 FROM ll_relabel_application r WHERE r.lastleg_order_id=ll_order.id " +
+                    "AND r.customer_id=ll_order.customer_id AND r.relabel_no LIKE CONCAT('%',{0},'%'))", relabelNo))
+            .eq(StringUtils.hasText(query.orderType()), LastlegOrder::getOrderType, query.orderType())
+            .apply(StringUtils.hasText(query.businessType()), LastlegOrderMapper.BUSINESS_TYPE_FILTER_SQL, query.businessType())
+            .apply(StringUtils.hasText(query.businessOrderNo()), LastlegOrderMapper.BUSINESS_ORDER_NO_FILTER_SQL, query.businessOrderNo())
+            .apply(StringUtils.hasText(query.externalBookingNo()), LastlegOrderMapper.EXTERNAL_BOOKING_NO_SQL + " LIKE CONCAT('%',{0},'%')", query.externalBookingNo())
+            .apply(query.sailingStage() != null, LastlegOrderMapper.SAILING_STAGE_FILTER_SQL,
+                query.sailingStage() == LastlegOrderRequests.SailingStage.AFTER_DEPARTURE ? 1 : 0)
+            .like(StringUtils.hasText(query.inboundCode()), LastlegOrder::getInboundCode, query.inboundCode())
+            .like(StringUtils.hasText(query.lxCode()), LastlegOrder::getLxCode, query.lxCode())
+            .like(StringUtils.hasText(query.sourceOrderNo()), LastlegOrder::getSourceOrderNo, query.sourceOrderNo())
+            .like(StringUtils.hasText(query.containerNo()), LastlegOrder::getContainerNo, query.containerNo())
+            .eq(StringUtils.hasText(currentStatus), LastlegOrder::getCurrentStatus, currentStatus)
+            .apply(StringUtils.hasText(warehouse), LastlegOrderMapper.WAREHOUSE_FILTER_SQL, warehouse)
+            .eq(StringUtils.hasText(query.transferWarehouseCode()), LastlegOrder::getTransferWarehouseCode,
+                query.transferWarehouseCode())
+            .eq(query.abnormal() != null, LastlegOrder::getAbnormal, query.abnormal())
+            .eq(query.detained() != null, LastlegOrder::getDetained, query.detained())
+            .ge(query.createdFrom() != null, LastlegOrder::getCreatedAt, query.createdFrom())
+            .le(query.createdTo() != null, LastlegOrder::getCreatedAt, query.createdTo());
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/relabel/controller/RelabelApplicationController.java

@@ -37,6 +37,16 @@ public class RelabelApplicationController {
     }
     @Resource private com.baiyue.lastleg.relabel.pda.service.PdaRelabelService pdaService;
 
+    /** 平台代客创建时仍按显式客户和公共作业仓返回正式库存候选。 */
+    @GetMapping("/inventory-candidates")
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.RELABEL_ORDER_CREATE + "')")
+    public ApiResponse<java.util.List<RelabelResponses.InventoryCandidate>> candidates(
+        @AuthenticationPrincipal AuthenticatedUser user, @RequestParam String customerId,
+        @RequestParam String operationWarehouseId, @RequestParam(required = false) String inboundCode) {
+        requirePlatform(user);
+        return ApiResponse.success(service.candidates(requiredCustomer(customerId), operationWarehouseId, inboundCode));
+    }
+
     @PostMapping("/{relabelNo}/rework")
     @PreAuthorize("hasAuthority('" + OverseasPermissions.RELABEL_ORDER_STATUS + "')")
     public ApiResponse<com.baiyue.lastleg.relabel.pda.dto.PdaRelabelResponses.Detail> rework(

lastleg-service/src/main/java/com/baiyue/lastleg/relabel/pda/service/PdaRelabelService.java

@@ -98,6 +98,7 @@ public class PdaRelabelService {
     @Resource private PdaRelabelOperationMapper operations;
     @Resource private PdaRelabelHistoryMapper histories;
     @Resource private RelabelApplicationService applicationService;
+    @Resource private com.baiyue.lastleg.relabel.repository.RelabelQuantityRepository quantityRepository;
     @Resource private RelabelPhotoFileGateway photoFiles;
     @Resource private ObjectMapper sourceObjectMapper;
     @Resource private com.baiyue.lastleg.mapper.LastlegOrderMapper tailOrders;
@@ -143,6 +144,7 @@ public class PdaRelabelService {
         return detail(application, tasks.find(application.getCustomerId(), application.getId()));
     }
 
+    /** 认领当前仓作业，并在首次实物移动前保存退货来源的不可变快照。 */
     @Transactional
     public PdaRelabelResponses.Detail claim(String operatorKey, String operatorName, long overseasWarehouseId,
                                             String relabelNo, PdaRelabelRequests.Claim request) {
@@ -191,6 +193,8 @@ public class PdaRelabelService {
             }
             insertHistory(task, "CLAIM", null, PROCESSING, operatorKey, operatorName,
                 Map.of("relabelNo", relabelNo));
+            insertHistory(task, "SOURCE_SNAPSHOT", PROCESSING, PROCESSING, operatorKey, operatorName,
+                quantityRepository.sourceSnapshot(application));
         }
         PdaRelabelResponses.Detail result = detail(application, task);
         saveOperation(task, operatorKey, "CLAIM", request.idempotencyKey(), command, result);
@@ -444,6 +448,7 @@ public class PdaRelabelService {
         return photoFiles.download(application.getCustomerId(), task.getId(), fileId);
     }
 
+    /** 先核对作业数量，失败不得触发组托或实测的下游校验与写入。 */
     @Transactional
     public PdaRelabelResponses.Detail complete(String operatorKey, String operatorName, long overseasWarehouseId,
                                                String relabelNo, PdaRelabelRequests.Complete request) {
@@ -454,14 +459,14 @@ public class PdaRelabelService {
         RelabelApplication application = requireApplication(relabelNo, overseasWarehouseId, true);
         PdaRelabelTask task = requireOwnedTask(application, operatorKey, true);
         requireVersion(task, request.expectedVersion());
-        if (!request.manualCompletion()) bindingGuard.requireBound(application);
-        palletMeasurements.requireMeasured(application);
         List<RelabelItem> detailItems = itemList(application);
         List<PdaRelabelUnitFact> facts = factList(task);
         boolean incomplete = detailItems.stream().anyMatch(item -> processedQuantity(facts, item.getId()) < value(item.getNotifiedPackageCount()));
         if ((incomplete || request.manualCompletion()) && !StringUtils.hasText(request.remark()))
             throw conflict("手动完成必须填写仓库异常作业备注");
         if (incomplete && !request.manualCompletion()) throw conflict("仍有未处理箱，请选择手动完成并填写作业备注");
+        if (!request.manualCompletion()) bindingGuard.requireBound(application);
+        palletMeasurements.requireMeasured(application);
         if (request.photoFileIds() == null || request.photoFileIds().isEmpty() || request.photoFileIds().size() > 20) throw conflict("完成换标必须上传 1 至 20 张作业照片");
         if (request.manualCompletion() && request.remark().trim().length() > 900) throw conflict("手动作业备注不能超过 900 字");
         for (RelabelItem item : detailItems) {

lastleg-service/src/main/java/com/baiyue/lastleg/relabel/repository/RelabelQuantityRepository.java

@@ -16,6 +16,8 @@ import java.util.List;
 public class RelabelQuantityRepository {
     @Resource private RelabelApplicationMapper applications;
     @Resource private RelabelItemMapper items;
+    @Resource private com.baiyue.lastleg.relabel.pda.mapper.PdaRelabelHistoryMapper histories;
+    @Resource private com.baiyue.lastleg.returnreceipt.mapper.ReturnInventoryCartonMapper returnCartons;
 
     /** 读取全部筛选结果，不附加当前页限制。 */
     public List<RelabelApplication> filtered(String customerId, RelabelRequests.Query query) {
@@ -28,4 +30,33 @@ public class RelabelQuantityRepository {
             .eq(RelabelItem::getApplicationId, application.getId())
             .eq(RelabelItem::getCustomerId, application.getCustomerId()));
     }
+
+    /** 只读取同客户同申请的事实历史，按稳定顺序重建首个来源和本轮最终目标。 */
+    public List<com.baiyue.lastleg.relabel.pda.entity.PdaRelabelHistory> history(RelabelApplication application) {
+        return histories.selectList(new LambdaQueryWrapper<com.baiyue.lastleg.relabel.pda.entity.PdaRelabelHistory>()
+            .eq(com.baiyue.lastleg.relabel.pda.entity.PdaRelabelHistory::getApplicationId, application.getId())
+            .eq(com.baiyue.lastleg.relabel.pda.entity.PdaRelabelHistory::getCustomerId, application.getCustomerId())
+            .orderByAsc(com.baiyue.lastleg.relabel.pda.entity.PdaRelabelHistory::getCreatedAt)
+            .orderByAsc(com.baiyue.lastleg.relabel.pda.entity.PdaRelabelHistory::getId));
+    }
+
+    /** 认领前按精确退货库存主键校验客户、仓库及占用归属，保存实物来源事实。 */
+    public java.util.Map<String, Object> sourceSnapshot(RelabelApplication application) {
+        var bindings = new java.util.ArrayList<java.util.Map<String, Object>>();
+        for (var item : items(application)) {
+            if (item.getReturnCartonId() == null) continue;
+            var carton = returnCartons.selectById(item.getReturnCartonId());
+            if (carton == null || !java.util.Objects.equals(carton.getCustomerId(), application.getCustomerId())
+                || !java.util.Objects.equals(carton.getOverseasWarehouseId(), application.getOverseasWarehouseId())
+                || !java.util.Objects.equals(carton.getRelabelApplicationId(), application.getId())
+                || !"RELABEL_PENDING".equals(carton.getStatus()) || !"CONFIRMED".equals(carton.getCountStatus())) continue;
+            var row = new java.util.LinkedHashMap<String, Object>();
+            row.put("itemId", String.valueOf(item.getId())); row.put("sourceUnitId", String.valueOf(carton.getId()));
+            row.put("sourceUnitType", java.util.Objects.toString(carton.getSourceUnitType(), "UNKNOWN"));
+            // 无托盘仅在权威记录明确为空或UNBOUND时计零；不是用箱唛推断托盘。
+            row.put("sourceKnown", true); row.put("sourcePalletCode", java.util.Objects.toString(carton.getPalletCode(), ""));
+            bindings.add(row);
+        }
+        return java.util.Map.of("schemaVersion", 1, "basis", "CONFIRMED_RETURN_INVENTORY_AT_FIRST_CLAIM", "itemBindings", bindings);
+    }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/relabel/service/RelabelPalletDimensions.java

@@ -0,0 +1,65 @@
+package com.baiyue.lastleg.relabel.service;
+
+import com.baiyue.lastleg.relabel.entity.RelabelItem;
+import com.baiyue.lastleg.relabel.pda.entity.PdaRelabelHistory;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.util.*;
+
+/** 只从不可变事实重建原托及本轮目标，不读取已移动的当前库存位置。 */
+public final class RelabelPalletDimensions {
+    /** 纯事实投影工具不允许实例化。 */
+    private RelabelPalletDimensions() { }
+    public record Result(Set<String> sources, Set<String> targets, Long cartons, Map<String, Long> sourceUnits) { }
+
+    /** 首次来源跨返工保留；返工后清空目标，随后每个任务仅采用最新绑定。 */
+    public static Result measure(List<RelabelItem> items, List<PdaRelabelHistory> history, ObjectMapper mapper) {
+        Map<String, String> sources = new HashMap<>(), targets = new HashMap<>();
+        Map<String, String> unitIds = new HashMap<>(), unitTypes = new HashMap<>();
+        Set<String> expected = new HashSet<>();
+        items.forEach(item -> expected.add(String.valueOf(item.getId())));
+        for (var event : history) {
+            if ("REWORK_ARCHIVE".equals(event.getAction())) { targets.clear(); continue; }
+            if (!Set.of("SOURCE_SNAPSHOT", "PALLET_BIND").contains(event.getAction())) continue;
+            try {
+                JsonNode detail = mapper.readTree(event.getDetailJson());
+                for (var binding : detail.path("itemBindings")) {
+                    String id = binding.path("itemId").asText();
+                    if (!expected.contains(id)) continue;
+                    if (binding.path("sourceKnown").asBoolean(false)) sources.putIfAbsent(id, binding.path("sourcePalletCode").asText(""));
+                    if ("PALLET_BIND".equals(event.getAction()) && binding.hasNonNull("targetPalletCode")) targets.put(id, binding.path("targetPalletCode").asText());
+                    if ("SOURCE_SNAPSHOT".equals(event.getAction()) && binding.hasNonNull("sourceUnitId")) {
+                        unitIds.putIfAbsent(id, binding.path("sourceUnitId").asText());
+                        unitTypes.putIfAbsent(id, binding.path("sourceUnitType").asText());
+                    }
+                }
+                // 旧历史只有单一来源和目标时才能确定箱任务关联；多来源数组及散货标识不作猜测。
+                if (!detail.has("itemBindings") && "PALLET_BIND".equals(event.getAction())) {
+                    var marks = new HashSet<String>(); detail.path("cartonMarks").forEach(mark -> marks.add(mark.asText()));
+                    for (var item : items) {
+                        if ("RETURN_BULK_SKU_LABEL".equals(item.getOperationType()) || !marks.contains(item.getCartonMark())) continue;
+                        String id = String.valueOf(item.getId());
+                        if (detail.path("sourcePallets").size() == 1) sources.putIfAbsent(id, detail.path("sourcePallets").get(0).asText());
+                        if (detail.path("targetPallets").size() == 1) targets.put(id, detail.path("targetPallets").get(0).asText());
+                    }
+                }
+            } catch (Exception ignored) { /* 历史缺失或损坏只影响可知维度，不能从当前位置补推。 */ }
+        }
+        Long cartons = null;
+        Map<String, Long> units = null;
+        if (!items.isEmpty() && unitIds.keySet().containsAll(expected)) {
+            var grouped = new HashMap<String, Set<String>>();
+            expected.forEach(id -> grouped.computeIfAbsent(unitTypes.get(id), ignored -> new HashSet<>()).add(unitIds.get(id)));
+            units = new TreeMap<>();
+            for (var entry : grouped.entrySet()) units.put(entry.getKey(), (long) entry.getValue().size());
+            if (grouped.keySet().equals(Set.of("BOX"))) cartons = (long) grouped.get("BOX").size();
+        }
+        return new Result(complete(sources, expected), complete(targets, expected), cartons, units);
+    }
+
+    /** 明确无托盘的实物来源可计零；缺少任一任务的快照则整单维度未知。 */
+    private static Set<String> complete(Map<String, String> values, Set<String> expected) {
+        if (expected.isEmpty() || !values.keySet().containsAll(expected)) return null;
+        var result = new HashSet<>(values.values()); result.remove(""); result.remove("UNBOUND"); return result;
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/relabel/service/RelabelQuantityService.java

@@ -15,10 +15,12 @@ public class RelabelQuantityService {
     @Resource private RelabelQuantityRepository repository;
     @Resource private ObjectMapper objectMapper;
     public record Quantity(Long labelPieceCount, Long cartonCount, int skuCount, boolean duplicateCarton,
-                           String quantityUnit, Long sourcePalletCount, Long targetPalletCount) { }
+                           String quantityUnit, Long sourcePalletCount, Long targetPalletCount,
+                           Map<String, Long> sourceUnitCounts) { }
     public record Totals(long orderCount, long skuCount, long knownLabelPieceCount, long unknownPieceOrders,
                          long knownCartonCount, long unknownCartonOrders,
-                         Map<String, Quantity> orders) { }
+                         Map<String, Quantity> orders, long knownSourcePalletCount, long unknownSourcePalletOrders,
+                         long knownTargetPalletCount, long unknownTargetPalletOrders) { }
 
     /** 按全部筛选单据聚合；未知件数和箱数保留未知单数，不伪造为零。 */
     @Transactional(readOnly = true)
@@ -26,20 +28,32 @@ public class RelabelQuantityService {
         var dimensions = new LinkedHashMap<String, Quantity>();
         var skus = new HashSet<String>();
         long pieces = 0, cartons = 0, unknownPieces = 0, unknownCartons = 0;
+        long unknownSources = 0, unknownTargets = 0;
+        var sourcePallets = new HashSet<String>(); var targetPallets = new HashSet<String>();
         for (var application : repository.filtered(customerId, query)) {
             var detail = repository.items(application);
             Quantity quantity = measure(detail);
+            var pallets = RelabelPalletDimensions.measure(detail, repository.history(application), objectMapper);
+            quantity = new Quantity(quantity.labelPieceCount(), quantity.cartonCount() == null ? pallets.cartons() : quantity.cartonCount(),
+                quantity.skuCount(), quantity.duplicateCarton(), quantity.quantityUnit(),
+                pallets.sources() == null ? null : (long) pallets.sources().size(),
+                pallets.targets() == null ? null : (long) pallets.targets().size(), pallets.sourceUnits());
+            if (pallets.sources() == null) unknownSources++;
+            else for (var code : pallets.sources()) sourcePallets.add(application.getOverseasWarehouseId() + "|" + code);
+            if (pallets.targets() == null) unknownTargets++;
+            else for (var code : pallets.targets()) targetPallets.add(application.getOverseasWarehouseId() + "|" + code);
             dimensions.put(application.getRelabelNo(), quantity);
             detail.forEach(item -> collectSkus(item, skus));
             if (quantity.labelPieceCount() == null) unknownPieces++; else pieces = Math.addExact(pieces, quantity.labelPieceCount());
             if (quantity.cartonCount() == null) unknownCartons++; else cartons = Math.addExact(cartons, quantity.cartonCount());
         }
-        return new Totals(dimensions.size(), skus.size(), pieces, unknownPieces, cartons, unknownCartons, dimensions);
+        return new Totals(dimensions.size(), skus.size(), pieces, unknownPieces, cartons, unknownCartons, dimensions,
+            sourcePallets.size(), unknownSources, targetPallets.size(), unknownTargets);
     }
 
     /** 箱级任务按箱唛去重；历史重复关联不重复增加件数并显式告警。 */
     public Quantity measure(List<RelabelItem> items) {
-        if (items.isEmpty()) return new Quantity(null, null, 0, false, "UNKNOWN", null, null);
+        if (items.isEmpty()) return new Quantity(null, null, 0, false, "UNKNOWN", null, null, null);
         long pieces = 0;
         boolean unknownPieces = false, bulk = false, duplicate = false, missingCarton = false;
         var cartons = new HashSet<String>();
@@ -72,7 +86,7 @@ public class RelabelQuantityService {
         }
         // 按件退货来源可能是托盘或包裹标识，不能将标识数冒充真实箱数。
         return new Quantity(unknownPieces || duplicate ? null : pieces, bulk || missingCarton ? null : (long) cartons.size(),
-            skus.size(), duplicate, bulk ? "PIECE" : "CARTON", null, null);
+            skus.size(), duplicate, bulk ? "PIECE" : "CARTON", null, null, null);
     }
 
     /** SKU种数来自子项；旧快照无子项时才采用旧SKU汇总字段。 */

lastleg-service/src/main/java/com/baiyue/lastleg/returnreceipt/controller/MerchantReturnOrderController.java

@@ -21,6 +21,13 @@ import org.springframework.web.server.ResponseStatusException;
 @RequestMapping("/api/merchant/v1/last-leg/return-orders")
 public class MerchantReturnOrderController {
     @Resource private ReturnReceiptService service;
+    @Resource private com.baiyue.lastleg.returnreceipt.service.ReturnOrderStatisticsService statistics;
+    /** 全筛选权威汇总，客户身份及权限与列表保持一致。 */
+    @GetMapping("/statistics") @PreAuthorize("hasAuthority('" + OverseasPermissions.MERCHANT_RETURN_ORDER_LIST + "')")
+    public ApiResponse<com.baiyue.lastleg.returnreceipt.dto.ReturnOrderStatistics> statistics(
+        @AuthenticationPrincipal AuthenticatedUser user, @Valid ReturnOrderRequests.Query query) {
+        return ApiResponse.success(statistics.merchant(customer(user),query));
+    }
     @PostMapping @PreAuthorize("hasAuthority('" + OverseasPermissions.MERCHANT_RETURN_ORDER_CREATE + "')")
     public ApiResponse<ReturnOrderResponses.Detail> create(@AuthenticationPrincipal AuthenticatedUser user,
         @Valid @RequestBody ReturnOrderRequests.Create request) { return ApiResponse.success(service.create(customer(user), operator(user), request)); }

lastleg-service/src/main/java/com/baiyue/lastleg/returnreceipt/controller/PlatformReturnOrderStatisticsController.java

@@ -0,0 +1,23 @@
+package com.baiyue.lastleg.returnreceipt.controller;
+
+import com.baiyue.common.core.api.ApiResponse;
+import com.baiyue.lastleg.returnreceipt.dto.ReturnOrderStatistics;
+import com.baiyue.lastleg.returnreceipt.service.ReturnOrderStatisticsService;
+import com.baiyue.lastleg.dto.LastlegOrderRequests;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.security.access.prepost.PreAuthorize;
+import jakarta.validation.Valid;
+
+/** 退货专属统计沿用尾程订单列表权限与全部筛选条件。 */
+@RestController
+@RequestMapping("/api/platform/v1/last-leg/return-orders/statistics")
+@PreAuthorize("hasAuthority('platform:overseas-warehouse:last-mile-order:list')")
+public class PlatformReturnOrderStatisticsController {
+    private final ReturnOrderStatisticsService service;
+    /** 注入只读统计服务。 */
+    public PlatformReturnOrderStatisticsController(ReturnOrderStatisticsService service) { this.service=service; }
+    /** 接受与尾程列表相同筛选。 */
+    @GetMapping
+    public ApiResponse<ReturnOrderStatistics> statistics(@Valid LastlegOrderRequests.Query query,
+        @RequestParam(required=false) String relabelNo) { return ApiResponse.success(service.platform(query,relabelNo)); }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/returnreceipt/dto/ReturnOrderStatistics.java

@@ -0,0 +1,13 @@
+package com.baiyue.lastleg.returnreceipt.dto;
+
+import java.util.List;
+
+/** 件数与签收载体分别统计；未知的预报箱托数不从件数推算。 */
+public record ReturnOrderStatistics(Totals totals, List<Dimensions> pageDimensions) {
+    public record Totals(long orderCount, long skuTypes, long expectedQuantity, long receivedQuantity,
+                         long remainingQuantity, long receivedBoxCount, long receivedParcelCount,
+                         long receivedPalletCount) { }
+    public record Dimensions(String returnNo, String lastlegOrderId, long expectedQuantity,
+                             long receivedQuantity, long remainingQuantity, long receivedBoxCount,
+                             long receivedParcelCount, long receivedPalletCount) { }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/returnreceipt/mapper/ReturnOrderStatisticsMapper.java

@@ -0,0 +1,43 @@
+package com.baiyue.lastleg.returnreceipt.mapper;
+
+import com.baiyue.lastleg.returnreceipt.dto.ReturnOrderStatistics;
+import org.apache.ibatis.annotations.*;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baiyue.lastleg.entity.LastlegOrder;
+import java.util.List;
+
+/** 全筛选先固定订单集合，子项分别聚合，禁止多表连接放大件数。 */
+@Mapper
+public interface ReturnOrderStatisticsMapper {
+    String MERCHANT_FILTER = " WHERE ro.customer_id=#{customerId} "
+        + "<if test='q.returnNo != null and q.returnNo.trim() != &quot;&quot;'>AND ro.return_no LIKE CONCAT('%',TRIM(#{q.returnNo}),'%')</if>"
+        + "<if test='q.status != null and q.status.trim() != &quot;&quot;'>AND ro.status=UPPER(TRIM(#{q.status}))</if>"
+        + "<if test='q.skuCode != null and q.skuCode.trim() != &quot;&quot;'>AND EXISTS(SELECT 1 FROM ll_return_order_item i WHERE i.return_order_id=ro.id AND i.customer_id=ro.customer_id AND i.sku_code LIKE CONCAT('%',TRIM(#{q.skuCode}),'%'))</if>"
+        + "<if test='q.trackingNo != null and q.trackingNo.trim() != &quot;&quot;'>AND EXISTS(SELECT 1 FROM ll_return_receipt r WHERE r.return_order_id=ro.id AND r.customer_id=ro.customer_id AND r.tracking_no LIKE CONCAT('%',TRIM(#{q.trackingNo}),'%'))</if>";
+    String MERCHANT_SET = "WITH selected AS (SELECT ro.* FROM ll_return_order ro " + MERCHANT_FILTER + ") ";
+    String PLATFORM_SET = "WITH selected AS (SELECT ro.* FROM (SELECT ll_order.* FROM ll_order ${ew.customSqlSegment}) p JOIN ll_return_order ro ON ro.lastleg_order_id=p.id AND ro.customer_id=p.customer_id) ";
+    String PLATFORM_PAGE_SET = "WITH selected AS (SELECT ro.* FROM (SELECT ll_order.* FROM ll_order ${ew.customSqlSegment} ORDER BY ll_order.created_at DESC,ll_order.id DESC LIMIT #{size} OFFSET #{offset}) p JOIN ll_return_order ro ON ro.lastleg_order_id=p.id AND ro.customer_id=p.customer_id) ";
+    String RECEIPT_SET = ", units AS (SELECT r.* FROM ll_return_receipt r JOIN selected s ON s.id=r.return_order_id AND s.customer_id=r.customer_id), "
+        + "carriers AS (SELECT return_order_id,COALESCE(SUM(CASE WHEN unit_type='PARCEL' THEN 0 ELSE total_box_count END),0) AS boxes,"
+        + "COUNT(DISTINCT CASE WHEN unit_type='PARCEL' THEN CONCAT(customer_id,':',COALESCE(NULLIF(unit_code,''),receipt_no)) END) AS parcels,"
+        + "COUNT(DISTINCT CASE WHEN unit_type='PALLET' THEN CONCAT(customer_id,':',COALESCE(NULLIF(pallet_code,''),unit_code)) END) AS pallets FROM units GROUP BY return_order_id) ";
+    String TOTALS = "SELECT COUNT(*) AS orderCount,"
+        + "(SELECT COUNT(DISTINCT UPPER(TRIM(i.sku_code))) FROM ll_return_order_item i JOIN selected s ON s.id=i.return_order_id AND s.customer_id=i.customer_id) AS skuTypes,"
+        + "COALESCE(SUM(expected_quantity),0) AS expectedQuantity,COALESCE(SUM(received_quantity),0) AS receivedQuantity,"
+        + "COALESCE(SUM(GREATEST(expected_quantity-received_quantity,0)),0) AS remainingQuantity,"
+        + "COALESCE((SELECT SUM(CASE WHEN unit_type='PARCEL' THEN 0 ELSE total_box_count END) FROM units),0) AS receivedBoxCount,"
+        + "(SELECT COUNT(DISTINCT CASE WHEN unit_type='PARCEL' THEN CONCAT(customer_id,':',COALESCE(NULLIF(unit_code,''),receipt_no)) END) FROM units) AS receivedParcelCount,"
+        + "(SELECT COUNT(DISTINCT CASE WHEN unit_type='PALLET' THEN CONCAT(customer_id,':',COALESCE(NULLIF(pallet_code,''),unit_code)) END) FROM units) AS receivedPalletCount FROM selected";
+    String DIMENSIONS = "SELECT s.return_no AS returnNo,CAST(s.lastleg_order_id AS CHAR) AS lastlegOrderId,s.expected_quantity AS expectedQuantity,s.received_quantity AS receivedQuantity,"
+        + "GREATEST(s.expected_quantity-s.received_quantity,0) AS remainingQuantity,COALESCE(c.boxes,0) AS receivedBoxCount,COALESCE(c.parcels,0) AS receivedParcelCount,COALESCE(c.pallets,0) AS receivedPalletCount "
+        + "FROM selected s LEFT JOIN carriers c ON c.return_order_id=s.id ORDER BY s.created_at DESC,s.id DESC LIMIT #{size} OFFSET #{offset}";
+    @Select("<script>" + MERCHANT_SET + RECEIPT_SET + TOTALS + "</script>")
+    ReturnOrderStatistics.Totals merchantTotals(@Param("customerId") String customerId, @Param("q") com.baiyue.lastleg.returnreceipt.dto.ReturnOrderRequests.Query query);
+    @Select("<script>" + MERCHANT_SET + RECEIPT_SET + DIMENSIONS + "</script>")
+    List<ReturnOrderStatistics.Dimensions> merchantDimensions(@Param("customerId") String customerId, @Param("q") com.baiyue.lastleg.returnreceipt.dto.ReturnOrderRequests.Query query, @Param("size") long size, @Param("offset") long offset);
+    @Select("<script>" + PLATFORM_SET + RECEIPT_SET + TOTALS + "</script>")
+    ReturnOrderStatistics.Totals platformTotals(@Param("ew") Wrapper<LastlegOrder> wrapper);
+    @Select("<script>" + PLATFORM_PAGE_SET + RECEIPT_SET + "SELECT s.return_no AS returnNo,CAST(s.lastleg_order_id AS CHAR) AS lastlegOrderId,s.expected_quantity AS expectedQuantity,s.received_quantity AS receivedQuantity,GREATEST(s.expected_quantity-s.received_quantity,0) AS remainingQuantity,COALESCE(c.boxes,0) AS receivedBoxCount,COALESCE(c.parcels,0) AS receivedParcelCount,COALESCE(c.pallets,0) AS receivedPalletCount FROM selected s LEFT JOIN carriers c ON c.return_order_id=s.id</script>")
+    List<ReturnOrderStatistics.Dimensions> platformDimensions(@Param("ew") Wrapper<LastlegOrder> wrapper, @Param("size") long size, @Param("offset") long offset);
+}
+

lastleg-service/src/main/java/com/baiyue/lastleg/returnreceipt/repository/ReturnOrderStatisticsRepository.java

@@ -0,0 +1,27 @@
+package com.baiyue.lastleg.returnreceipt.repository;
+
+import com.baiyue.lastleg.returnreceipt.dto.*;
+import com.baiyue.lastleg.returnreceipt.mapper.ReturnOrderStatisticsMapper;
+import com.baiyue.lastleg.dto.LastlegOrderRequests;
+import com.baiyue.lastleg.query.LastlegOrderFilter;
+import com.baiyue.lastleg.entity.LastlegOrder;
+import org.springframework.stereotype.Repository;
+
+/** 列表统计只经本域Mapper读取正式订单与签收事实。 */
+@Repository
+public class ReturnOrderStatisticsRepository {
+    private final ReturnOrderStatisticsMapper mapper;
+    /** 注入订单统计映射。 */
+    public ReturnOrderStatisticsRepository(ReturnOrderStatisticsMapper mapper) { this.mapper=mapper; }
+    /** 客户范围来自认证身份，分页不进入总计查询。 */
+    public ReturnOrderStatistics merchant(String customerId, ReturnOrderRequests.Query query) {
+        return new ReturnOrderStatistics(mapper.merchantTotals(customerId,query),
+            mapper.merchantDimensions(customerId,query,query.size(),Math.multiplyExact(query.page()-1,query.size())));
+    }
+    /** 与平台尾程列表使用同一筛选构造器，只统计其中原生退货单。 */
+    public ReturnOrderStatistics platform(LastlegOrderRequests.Query query, String relabelNo) {
+        var filter=LastlegOrderFilter.create(null,query,relabelNo);
+        return new ReturnOrderStatistics(mapper.platformTotals(filter),
+            mapper.platformDimensions(filter,query.size(),Math.multiplyExact(query.page()-1,query.size())));
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/returnreceipt/service/ReturnOrderStatisticsService.java

@@ -0,0 +1,21 @@
+package com.baiyue.lastleg.returnreceipt.service;
+
+import com.baiyue.lastleg.returnreceipt.dto.*;
+import com.baiyue.lastleg.returnreceipt.repository.ReturnOrderStatisticsRepository;
+import com.baiyue.lastleg.dto.LastlegOrderRequests;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/** 汇总和当前页维度在同一只读快照内返回，避免签收并发时前后口径不一致。 */
+@Service
+public class ReturnOrderStatisticsService {
+    private final ReturnOrderStatisticsRepository repository;
+    /** 注入只读统计仓储。 */
+    public ReturnOrderStatisticsService(ReturnOrderStatisticsRepository repository) { this.repository=repository; }
+    /** 当前客户的总计与页内维度使用同一只读快照。 */
+    @Transactional(readOnly=true, isolation=org.springframework.transaction.annotation.Isolation.REPEATABLE_READ)
+    public ReturnOrderStatistics merchant(String customerId, ReturnOrderRequests.Query query) { return repository.merchant(customerId,query); }
+    /** 平台筛选范围中的退货总计与混合列表页内维度。 */
+    @Transactional(readOnly=true, isolation=org.springframework.transaction.annotation.Isolation.REPEATABLE_READ)
+    public ReturnOrderStatistics platform(LastlegOrderRequests.Query query, String relabelNo) { return repository.platform(query,relabelNo); }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/service/LastlegOrderService.java

@@ -86,6 +86,7 @@ public class LastlegOrderService {
     @Resource private WarehouseResourceGateway warehouseResourceGateway;
     @Resource private ContainerShippingGateMapper containerShippingGates;
     @Resource private ReturnOrderReferenceResolver returnOrderReferences;
+    @Resource private com.baiyue.lastleg.transfer.service.TransferQuantityService transferQuantities;
 
     public PageResult<LastlegOrderSummary> page(String customerId, LastlegOrderRequests.Query query) {
         return page(customerId, query, null);
@@ -102,11 +103,12 @@ public class LastlegOrderService {
         Map<Long, LastlegOrderMapper.OrderWeightRow> weights = orderWeights(page.getRecords());
         Map<Long, List<com.baiyue.lastleg.dto.RelabelSubOrder>> relabels = relabelSubOrders(page.getRecords());
         Map<Long, LastlegOrderSummary.BusinessSource> businessSources = businessSources(page.getRecords());
+        var quantities = transferQuantities.forOrders(page.getRecords());
         return new PageResult<>(page.getRecords().stream().map(order -> summary(order, mergeRelations.get(order.getId()),
                 StringUtils.hasText(order.getSourceContainerBookingId())
                     ? containerNodes.get(order.getSourceContainerBookingId()) : null,
                 dispatchStatuses.getOrDefault(order.getId(), "UNSCHEDULED"), weights.get(order.getId()),
-                relabels.getOrDefault(order.getId(), List.of()), businessSources.get(order.getId()))).toList(),
+                relabels.getOrDefault(order.getId(), List.of()), businessSources.get(order.getId()), quantities.get(order.getId()))).toList(),
             page.getCurrent(), page.getSize(), page.getTotal(), page.getPages());
     }
 
@@ -363,7 +365,7 @@ public class LastlegOrderService {
         return new LastlegOrderDetailResponse(summary(order, palletMergeRelations(List.of(order)).get(order.getId()),
             containerNode(order), dispatchStatuses(List.of(order)).getOrDefault(order.getId(), "UNSCHEDULED"),
             orderWeights(List.of(order)).get(order.getId()), relabelSubOrders(List.of(order)).getOrDefault(order.getId(), List.of()),
-            businessSources(List.of(order)).get(order.getId())), manualNodes, cargo, history.stream()
+            businessSources(List.of(order)).get(order.getId()), transferQuantities.forOrders(List.of(order)).get(order.getId())), manualNodes, cargo, history.stream()
             .map(value -> new LastlegOrderDetailResponse.History(value.getId(), value.getFromStatus(),
                 value.getToStatus(), value.getRemark(), value.getCreatedAt())).toList(), fees, operations.stream()
             .map(value -> new LastlegOrderDetailResponse.Operation(value.getId(), value.getOperationNode(),
@@ -532,45 +534,18 @@ public class LastlegOrderService {
         return orders.size();
     }
 
+    /** 与主列表复用同一筛选，汇总只纳入仓储转运且不使用分页参数。 */
+    public com.baiyue.lastleg.transfer.dto.TransferQuantityTotals transferQuantityTotals(
+        String customerId, LastlegOrderRequests.Query query, String relabelNo) {
+        return transferQuantities.totals(filter(customerId, query, relabelNo).eq(LastlegOrder::getOrderType,"WAREHOUSE_TRANSFER"));
+    }
+
     private LambdaQueryWrapper<LastlegOrder> filter(String customerId, LastlegOrderRequests.Query query) {
         return filter(customerId, query, null);
     }
 
     private LambdaQueryWrapper<LastlegOrder> filter(String customerId, LastlegOrderRequests.Query query, String relabelNo) {
-        if (query.createdFrom() != null && query.createdTo() != null && query.createdFrom().isAfter(query.createdTo())) {
-            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "createdFrom must not be after createdTo");
-        }
-        String currentStatus = StringUtils.hasText(query.currentStatus()) ? query.currentStatus() : query.status();
-        String warehouse = StringUtils.hasText(query.warehouse()) ? query.warehouse().trim() : null;
-        return new LambdaQueryWrapper<LastlegOrder>()
-            .ne(LastlegOrder::getOrderType, "CARGO_DISCARD")
-            .eq(StringUtils.hasText(customerId), LastlegOrder::getCustomerId, customerId)
-            .and(StringUtils.hasText(query.orderNo()), nested -> nested
-                .like(LastlegOrder::getOrderNo, query.orderNo())
-                .or()
-                .like(LastlegOrder::getSourceOrderNo, query.orderNo()))
-            .and(StringUtils.hasText(relabelNo), nested -> nested
-                .like(LastlegOrder::getRelabelOrderNo, relabelNo)
-                .or().apply("EXISTS (SELECT 1 FROM ll_relabel_application r WHERE r.lastleg_order_id=ll_order.id " +
-                    "AND r.customer_id=ll_order.customer_id AND r.relabel_no LIKE CONCAT('%',{0},'%'))", relabelNo))
-            .eq(StringUtils.hasText(query.orderType()), LastlegOrder::getOrderType, query.orderType())
-            .apply(StringUtils.hasText(query.businessType()), LastlegOrderMapper.BUSINESS_TYPE_FILTER_SQL, query.businessType())
-            .apply(StringUtils.hasText(query.businessOrderNo()), LastlegOrderMapper.BUSINESS_ORDER_NO_FILTER_SQL, query.businessOrderNo())
-            .apply(StringUtils.hasText(query.externalBookingNo()), LastlegOrderMapper.EXTERNAL_BOOKING_NO_SQL + " LIKE CONCAT('%',{0},'%')", query.externalBookingNo())
-            .apply(query.sailingStage() != null, LastlegOrderMapper.SAILING_STAGE_FILTER_SQL,
-                query.sailingStage() == LastlegOrderRequests.SailingStage.AFTER_DEPARTURE ? 1 : 0)
-            .like(StringUtils.hasText(query.inboundCode()), LastlegOrder::getInboundCode, query.inboundCode())
-            .like(StringUtils.hasText(query.lxCode()), LastlegOrder::getLxCode, query.lxCode())
-            .like(StringUtils.hasText(query.sourceOrderNo()), LastlegOrder::getSourceOrderNo, query.sourceOrderNo())
-            .like(StringUtils.hasText(query.containerNo()), LastlegOrder::getContainerNo, query.containerNo())
-            .eq(StringUtils.hasText(currentStatus), LastlegOrder::getCurrentStatus, currentStatus)
-            .apply(StringUtils.hasText(warehouse), LastlegOrderMapper.WAREHOUSE_FILTER_SQL, warehouse)
-            .eq(StringUtils.hasText(query.transferWarehouseCode()), LastlegOrder::getTransferWarehouseCode,
-                query.transferWarehouseCode())
-            .eq(query.abnormal() != null, LastlegOrder::getAbnormal, query.abnormal())
-            .eq(query.detained() != null, LastlegOrder::getDetained, query.detained())
-            .ge(query.createdFrom() != null, LastlegOrder::getCreatedAt, query.createdFrom())
-            .le(query.createdTo() != null, LastlegOrder::getCreatedAt, query.createdTo());
+        return com.baiyue.lastleg.query.LastlegOrderFilter.create(customerId, query, relabelNo);
     }
 
     private LastlegOrder findOwned(String customerId, long orderId) {
@@ -647,7 +622,8 @@ public class LastlegOrderService {
                                          String containerNode, String dispatchStatus,
                                          LastlegOrderMapper.OrderWeightRow weight,
                                          List<com.baiyue.lastleg.dto.RelabelSubOrder> relabelApplications,
-                                         LastlegOrderSummary.BusinessSource businessSource) {
+                                         LastlegOrderSummary.BusinessSource businessSource,
+                                         com.baiyue.lastleg.transfer.dto.TransferQuantityView transferQuantity) {
         List<LastlegOrderMapper.PalletMergeRelationRow> related = relations == null ? List.of() : relations;
         return new LastlegOrderSummary(o.getId(), displayOrderNo(o), o.getOrderType(),
             LastlegOrderType.labelOf(o.getOrderType()), o.getDestinationType(), o.getSourceInboundId(),
@@ -665,7 +641,7 @@ public class LastlegOrderService {
             o.getPalletMergeFlag(), related.stream().map(LastlegOrderMapper.PalletMergeRelationRow::mergeGroupNo).distinct().findFirst().orElse(null),
             related.stream().map(LastlegOrderMapper.PalletMergeRelationRow::relatedInboundNo).filter(Objects::nonNull).distinct().toList(),
             o.getCurrentStatus(), o.getSubOrderStatus(), o.getPrivateRemark(),
-            o.getCustomerRemark(), o.getWarehouseRemark(), o.getCreatedAt(), o.getUpdatedAt(), relabelApplications, businessSource);
+            o.getCustomerRemark(), o.getWarehouseRemark(), o.getCreatedAt(), o.getUpdatedAt(), relabelApplications, businessSource, transferQuantity);
     }
 
     private static Integer packageDifference(LastlegOrder order) {
@@ -722,3 +698,4 @@ public class LastlegOrderService {
     }
 
 }
+

lastleg-service/src/main/java/com/baiyue/lastleg/transfer/controller/MerchantWarehouseTransferController.java

@@ -77,6 +77,14 @@ public class MerchantWarehouseTransferController {
         return ApiResponse.success(service.submit(customer(user), transferNo, operator(user)));
     }
 
+    /** 客户当前筛选的全部转运数量，不受页码影响。 */
+    @GetMapping("/quantities")
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.MERCHANT_TRANSFER_LIST + "')")
+    public ApiResponse<com.baiyue.lastleg.transfer.dto.TransferQuantityTotals> quantities(
+        @AuthenticationPrincipal AuthenticatedUser user,@Valid WarehouseTransferRequests.Query query) {
+        return ApiResponse.success(service.quantityTotals(customer(user),query));
+    }
+
     @GetMapping
     @PreAuthorize("hasAuthority('" + OverseasPermissions.MERCHANT_TRANSFER_LIST + "')")
     public ApiResponse<PageResult<WarehouseTransferResponses.Summary>> page(@AuthenticationPrincipal AuthenticatedUser user,

lastleg-service/src/main/java/com/baiyue/lastleg/transfer/dto/TransferQuantityTotals.java

@@ -0,0 +1,8 @@
+package com.baiyue.lastleg.transfer.dto;
+
+/** 全筛选结果汇总，不受分页影响；已知小计与未知票数同时返回。 */
+public record TransferQuantityTotals(long orderCount, Long declaredPieceCount, long knownDeclaredPieceCount,
+    long unknownDeclaredOrderCount, Long receivedPieceCount, long knownReceivedPieceCount,
+    long unknownReceivedOrderCount, long declaredCartonCount, long receivedCartonCount,
+    long receivedPalletCount, long availableCartonCount, long shippedCartonCount,
+    long remainingPalletCount, long shippedPalletCount) { }

lastleg-service/src/main/java/com/baiyue/lastleg/transfer/dto/TransferQuantityView.java

@@ -0,0 +1,6 @@
+package com.baiyue.lastleg.transfer.dto;
+
+/** 分离客户预报、历史实收和当前箱状态；未知件数保持空值。 */
+public record TransferQuantityView(Long lastlegOrderId, Long declaredPieceCount, Long receivedPieceCount,
+    long declaredCartonCount, long receivedCartonCount, long receivedPalletCount,
+    long availableCartonCount, long shippedCartonCount, long remainingPalletCount, long shippedPalletCount) { }

lastleg-service/src/main/java/com/baiyue/lastleg/transfer/dto/WarehouseTransferRequests.java

@@ -212,7 +212,10 @@ public final class WarehouseTransferRequests {
     public record Query(@Min(1) long page, @Min(1) @Max(200) long size,
                         String transferNo, String inboundCode, String operatingWarehouseId,
                         String fbaWarehouseCode, String status, Boolean needRelabel,
-                        LocalDateTime createdFrom, LocalDateTime createdTo) {
+                        LocalDateTime createdFrom, LocalDateTime createdTo,
+                        LocalDateTime reviewedFrom, LocalDateTime reviewedTo,
+                        LocalDateTime measuredFrom, LocalDateTime measuredTo,
+                        LocalDateTime outboundFrom, LocalDateTime outboundTo) {
         public Query { if (page == 0) page = 1; if (size == 0) size = 20; }
     }
 }

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

@@ -0,0 +1,78 @@
+package com.baiyue.lastleg.transfer.mapper;
+
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baiyue.lastleg.entity.LastlegOrder;
+import com.baiyue.lastleg.transfer.dto.TransferQuantityView;
+import org.apache.ibatis.annotations.*;
+import java.util.List;
+
+/** 使用主订单相同筛选读取转运数量事实，不把历史实收与剩余库存相减。 */
+@Mapper
+public interface TransferQuantityMapper {
+    String SELECTED = "SELECT id,customer_id FROM ll_order ${ew.customSqlSegment}";
+    String RECEIVED = "c.counted_at IS NOT NULL AND c.status IN ('COUNTED','DISCARD_PENDING','DISCARDED','SHIPPED')";
+    String FACTS = """
+        SELECT t.lastleg_order_id lastlegOrderId,
+          (SELECT CASE WHEN COUNT(*)=0 OR COUNT(*)<>COUNT(i.declared_quantity) THEN NULL ELSE SUM(i.declared_quantity) END
+           FROM ll_warehouse_transfer_item i WHERE i.customer_id=t.customer_id AND i.transfer_order_id=t.id) declaredPieceCount,
+          (SELECT CASE WHEN COUNT(*)=0 OR COUNT(*)<>COUNT(c.counted_quantity) THEN NULL ELSE SUM(c.counted_quantity) END
+           FROM ll_warehouse_transfer_carton c WHERE c.customer_id=t.customer_id AND c.transfer_order_id=t.id AND
+        """ + RECEIVED + """
+          ) receivedPieceCount,
+          t.package_count declaredCartonCount,
+          COALESCE(f.receivedCartonCount,0) receivedCartonCount, COALESCE(f.receivedPalletCount,0) receivedPalletCount,
+          COALESCE(f.availableCartonCount,0) availableCartonCount, COALESCE(f.shippedCartonCount,0) shippedCartonCount,
+          COALESCE(f.remainingPalletCount,0) remainingPalletCount, COALESCE(f.shippedPalletCount,0) shippedPalletCount
+        FROM ll_warehouse_transfer_order t JOIN (
+        """ + SELECTED + """
+        ) selected ON selected.id=t.lastleg_order_id AND selected.customer_id=t.customer_id
+        LEFT JOIN (
+          SELECT c.customer_id,c.transfer_order_id,
+        """ + "SUM(" + RECEIVED + ") receivedCartonCount," +
+        "COUNT(DISTINCT CASE WHEN " + RECEIVED + " THEN p.warehouse_pallet_id END) receivedPalletCount," + """
+          SUM(c.status='COUNTED') availableCartonCount, SUM(c.status='SHIPPED') shippedCartonCount,
+          COUNT(DISTINCT CASE WHEN c.status IN ('COUNTED','DISCARD_PENDING') THEN p.warehouse_pallet_id END) remainingPalletCount,
+          COUNT(DISTINCT CASE WHEN c.status='SHIPPED' THEN p.warehouse_pallet_id END) shippedPalletCount
+          FROM ll_warehouse_transfer_carton c LEFT JOIN ll_warehouse_transfer_pallet p
+            ON p.id=c.transfer_pallet_id AND p.customer_id=c.customer_id
+          GROUP BY c.customer_id,c.transfer_order_id
+        ) f ON f.transfer_order_id=t.id AND f.customer_id=t.customer_id
+        """;
+
+    /** 一次读取筛选范围或本页订单的预报及实收事实。 */
+    @Select("<script>" + FACTS + "</script>")
+    List<TransferQuantityView> rows(@Param("ew") Wrapper<LastlegOrder> filter);
+
+    /** 按真实托盘身份在完整筛选集合去重，同托部分出库可同时属于实收、剩余、出库集合。 */
+    @Select("<script>SELECT DISTINCT c.customer_id customerId,p.warehouse_pallet_id palletId,c.status status " +
+        "FROM ll_warehouse_transfer_order t JOIN (" + SELECTED + ") selected " +
+        "ON selected.id=t.lastleg_order_id AND selected.customer_id=t.customer_id " +
+        "JOIN ll_warehouse_transfer_carton c ON c.transfer_order_id=t.id AND c.customer_id=t.customer_id " +
+        "JOIN ll_warehouse_transfer_pallet p ON p.id=c.transfer_pallet_id AND p.customer_id=c.customer_id " +
+        "WHERE " + RECEIVED + " AND p.warehouse_pallet_id IS NOT NULL</script>")
+    List<PalletFact> pallets(@Param("ew") Wrapper<LastlegOrder> filter);
+
+    /** 物理托盘事实，保留客户隔离。 */
+    record PalletFact(String customerId, Long palletId, String status) { }
+
+    /** 库存转运目的仓实收依正式签收凭据；件数只取精确选箱对应原清点事实。 */
+    @Select("<script>SELECT t.lastleg_order_id lastlegOrderId,t.customer_id customerId,a.package_count cartonCount," +
+        "a.pallet_id sourcePalletId,a.status status,r.id receiptId,dp.pallet_id destinationPalletId," +
+        "(SELECT CASE WHEN COUNT(DISTINCT c.id)=a.package_count AND COUNT(*)=COUNT(c.counted_quantity) THEN SUM(c.counted_quantity) ELSE NULL END " +
+        "FROM ll_warehouse_transfer_carton chosen JOIN ll_warehouse_transfer_order origin " +
+        "ON origin.customer_id=t.customer_id AND origin.inbound_code=t.inbound_code AND origin.operating_warehouse_id=t.operating_warehouse_id AND origin.transfer_no=origin.inbound_code " +
+        "JOIN ll_warehouse_transfer_carton c ON c.customer_id=origin.customer_id AND c.transfer_order_id=origin.id " +
+        "AND c.carton_mark=COALESCE(NULLIF(chosen.customer_carton_mark,''),chosen.carton_mark) " +
+        "JOIN ll_warehouse_transfer_pallet cp ON cp.id=c.transfer_pallet_id AND cp.customer_id=c.customer_id AND cp.warehouse_pallet_id=a.pallet_id " +
+        "WHERE chosen.transfer_order_id=t.id AND chosen.customer_id=t.customer_id AND c.counted_at IS NOT NULL) pieceCount " +
+        "FROM ll_warehouse_transfer_order t JOIN (" + SELECTED + ") selected ON selected.id=t.lastleg_order_id AND selected.customer_id=t.customer_id " +
+        "JOIN ll_warehouse_transfer_inventory_allocation a ON a.transfer_order_id=t.id AND a.customer_id=t.customer_id " +
+        "LEFT JOIN ll_warehouse_transfer_receipt r ON r.allocation_id=a.id AND r.customer_id=a.customer_id " +
+        "LEFT JOIN ll_inventory_position dp ON dp.id=r.destination_inventory_position_id AND dp.customer_id=r.customer_id " +
+        "WHERE t.transfer_no&lt;&gt;t.inbound_code AND a.status IN ('RESERVED','SHIPPED','RECEIVED')</script>")
+    List<MovementFact> movements(@Param("ew") Wrapper<LastlegOrder> filter);
+
+    /** 每个分配来源的实际出库与目的仓签收事实。 */
+    record MovementFact(Long lastlegOrderId,String customerId,long cartonCount,Long sourcePalletId,String status,
+        Long receiptId,Long destinationPalletId,Long pieceCount) { }
+}

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

@@ -0,0 +1,28 @@
+package com.baiyue.lastleg.transfer.repository;
+
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baiyue.lastleg.entity.LastlegOrder;
+import com.baiyue.lastleg.transfer.dto.TransferQuantityView;
+import com.baiyue.lastleg.transfer.mapper.TransferQuantityMapper;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Repository;
+import java.util.List;
+
+/** 转运数量只读持久化入口。 */
+@Repository
+public class TransferQuantityRepository {
+    @Resource private TransferQuantityMapper mapper;
+    @Resource private com.baiyue.lastleg.transfer.mapper.WarehouseTransferOrderMapper transfers;
+    /** 以客户列表相同筛选读取关联主订单，不读取分页参数。 */
+    public List<Long> selectedOrderIds(Wrapper<com.baiyue.lastleg.transfer.entity.WarehouseTransferOrder> filter) {
+        return transfers.selectList(filter).stream()
+            .map(com.baiyue.lastleg.transfer.entity.WarehouseTransferOrder::getLastlegOrderId)
+            .filter(java.util.Objects::nonNull).distinct().toList();
+    }
+    /** 读取完整筛选集合的事实，分页由主列表单独处理。 */
+    public List<TransferQuantityView> rows(Wrapper<LastlegOrder> filter) { return mapper.rows(filter); }
+    /** 读取完整筛选集合的物理托盘。 */
+    public List<TransferQuantityMapper.PalletFact> pallets(Wrapper<LastlegOrder> filter) { return mapper.pallets(filter); }
+    /** 读取库存转运实际出库及目的仓签收，按来源分配去重。 */
+    public List<TransferQuantityMapper.MovementFact> movements(Wrapper<LastlegOrder> filter) { return mapper.movements(filter); }
+}

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

@@ -0,0 +1,87 @@
+package com.baiyue.lastleg.transfer.service;
+
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baiyue.lastleg.entity.LastlegOrder;
+import com.baiyue.lastleg.transfer.dto.*;
+import com.baiyue.lastleg.transfer.repository.TransferQuantityRepository;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import java.util.*;
+import java.util.function.ToLongFunction;
+import java.util.stream.Collectors;
+
+/** 预报、实收、当前剩余分别汇总，空件数不会被零值掩盖。 */
+@Service
+public class TransferQuantityService {
+    @Resource private TransferQuantityRepository repository;
+
+    /** 客户列表共享完整筛选，主订单查询仍显式限定客户。 */
+    @Transactional(readOnly=true)
+    public TransferQuantityTotals merchantTotals(Wrapper<com.baiyue.lastleg.transfer.entity.WarehouseTransferOrder> filter, String customerId) {
+        var ids = repository.selectedOrderIds(filter);
+        var orders = new LambdaQueryWrapper<LastlegOrder>().eq(LastlegOrder::getCustomerId, customerId);
+        if (ids.isEmpty()) orders.apply("1=0"); else orders.in(LastlegOrder::getId, ids);
+        return totals(orders);
+    }
+
+    /** 主列表批量加载本页转运，其他业务不改变字段语义。 */
+    public Map<Long,TransferQuantityView> forOrders(List<LastlegOrder> orders) {
+        var ids=orders.stream().filter(o -> "WAREHOUSE_TRANSFER".equals(o.getOrderType())).map(LastlegOrder::getId).toList();
+        if(ids.isEmpty()) return Map.of();
+        var filter = new LambdaQueryWrapper<LastlegOrder>().in(LastlegOrder::getId,ids);
+        return withMovements(repository.rows(filter),repository.movements(filter))
+            .stream().collect(Collectors.toMap(TransferQuantityView::lastlegOrderId, v -> v));
+    }
+
+    /** 同一只读事务按完整筛选汇总，page/size不参与数量计算。 */
+    @Transactional(readOnly=true)
+    public TransferQuantityTotals totals(Wrapper<LastlegOrder> filter) {
+        var movements=repository.movements(filter);
+        var rows=withMovements(repository.rows(filter),movements); var pallets=repository.pallets(filter);
+        long unknownDeclared=rows.stream().filter(v -> v.declaredPieceCount()==null).count();
+        long unknownReceived=rows.stream().filter(v -> v.receivedPieceCount()==null).count();
+        long declared=sum(rows,v -> v.declaredPieceCount()==null?0:v.declaredPieceCount());
+        long received=sum(rows,v -> v.receivedPieceCount()==null?0:v.receivedPieceCount());
+        var all=new HashSet<String>(); var remaining=new HashSet<String>(); var shipped=new HashSet<String>();
+        for(var pallet:pallets) {
+            String key=pallet.customerId()+":"+pallet.palletId(); all.add(key);
+            if(Set.of("COUNTED","DISCARD_PENDING").contains(pallet.status())) remaining.add(key);
+            if("SHIPPED".equals(pallet.status())) shipped.add(key);
+        }
+        for (var move:movements) {
+            if (move.receiptId()!=null && move.destinationPalletId()!=null) all.add(move.customerId()+":"+move.destinationPalletId());
+            if (Set.of("SHIPPED","RECEIVED").contains(move.status()) && move.sourcePalletId()!=null) shipped.add(move.customerId()+":"+move.sourcePalletId());
+        }
+        return new TransferQuantityTotals(rows.size(),unknownDeclared==0?declared:null,declared,unknownDeclared,
+            unknownReceived==0?received:null,received,unknownReceived,sum(rows,TransferQuantityView::declaredCartonCount),
+            sum(rows,TransferQuantityView::receivedCartonCount),all.size(),sum(rows,TransferQuantityView::availableCartonCount),
+            sum(rows,TransferQuantityView::shippedCartonCount),remaining.size(),shipped.size());
+    }
+
+    /** 库存转运的实收来自目的仓凭据，原仓出库事实保留独立维度。 */
+    private List<TransferQuantityView> withMovements(List<TransferQuantityView> rows,
+        List<com.baiyue.lastleg.transfer.mapper.TransferQuantityMapper.MovementFact> movements) {
+        var grouped=movements.stream().collect(Collectors.groupingBy(com.baiyue.lastleg.transfer.mapper.TransferQuantityMapper.MovementFact::lastlegOrderId));
+        return rows.stream().map(row -> {
+            var facts=grouped.get(row.lastlegOrderId()); if(facts==null) return row;
+            long received=0,pieces=0,shipped=0; boolean known=true; var targets=new HashSet<Long>(); var sources=new HashSet<Long>();
+            for(var fact:facts) {
+                if(fact.receiptId()!=null) {
+                    received=Math.addExact(received,fact.cartonCount());
+                    if(fact.pieceCount()==null) known=false; else pieces=Math.addExact(pieces,fact.pieceCount());
+                    if(fact.destinationPalletId()!=null) targets.add(fact.destinationPalletId());
+                }
+                if(Set.of("SHIPPED","RECEIVED").contains(fact.status())) { shipped=Math.addExact(shipped,fact.cartonCount()); if(fact.sourcePalletId()!=null) sources.add(fact.sourcePalletId()); }
+            }
+            return new TransferQuantityView(row.lastlegOrderId(),row.declaredPieceCount(),received>0&&known?pieces:null,
+                row.declaredCartonCount(),received,targets.size(),0,shipped,0,sources.size());
+        }).toList();
+    }
+
+    /** 使用精确整数累加，溢出不能静默返回错误汇总。 */
+    private long sum(List<TransferQuantityView> rows,ToLongFunction<TransferQuantityView> measure) {
+        long value=0; for(var row:rows) value=Math.addExact(value,measure.applyAsLong(row)); return value;
+    }
+}

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

@@ -92,6 +92,7 @@ import java.util.stream.Collectors;
 
 @Service
 public class WarehouseTransferService {
+    @Resource private TransferQuantityService transferQuantityService;
     @Resource private com.baiyue.lastleg.fleet.pickup.FleetPickupService pickupService;
     /** 退货单在转运来源中的展示编码，避免把退货单号误当成普通入仓码查询。 */
     public static final String RETURN_ORDER_PREFIX = "RETURN_ORDER:";
@@ -551,19 +552,15 @@ public class WarehouseTransferService {
             transferCartons.updateById(carton);
         }
     }
-    @Transactional(readOnly = true)
-    public PageResult<WarehouseTransferResponses.Summary> page(String customerId, WarehouseTransferRequests.Query query) {
-        return page(customerId, query, true);
-    }
-
-    @Transactional(readOnly = true)
-    public PageResult<WarehouseTransferResponses.Summary> page(String customerId, WarehouseTransferRequests.Query query,
-                                                                boolean includeDrafts) {
-        if (query.createdFrom() != null && query.createdTo() != null && query.createdFrom().isAfter(query.createdTo())) {
-            throw badRequest("createdFrom must not be after createdTo");
-        }
+    /** 列表和全筛选数量共享条件，避免翻页或状态分组后口径漂移。 */
+    private LambdaQueryWrapper<WarehouseTransferOrder> transferPageFilter(String customerId,
+        WarehouseTransferRequests.Query query, boolean includeDrafts) {
+        validateQuantityRange(query.createdFrom(), query.createdTo(), "创建");
+        validateQuantityRange(query.reviewedFrom(), query.reviewedTo(), "审核");
+        validateQuantityRange(query.measuredFrom(), query.measuredTo(), "清点完成");
+        validateQuantityRange(query.outboundFrom(), query.outboundTo(), "出库");
         List<String> groupedStatuses = customerMainStatuses(query.status());
-        LambdaQueryWrapper<WarehouseTransferOrder> wrapper = new LambdaQueryWrapper<WarehouseTransferOrder>()
+        return new LambdaQueryWrapper<WarehouseTransferOrder>()
             .eq(StringUtils.hasText(customerId), WarehouseTransferOrder::getCustomerId, customerId)
             .like(StringUtils.hasText(query.transferNo()), WarehouseTransferOrder::getTransferNo, query.transferNo())
             .like(StringUtils.hasText(query.inboundCode()), WarehouseTransferOrder::getInboundCode, query.inboundCode())
@@ -577,7 +574,35 @@ public class WarehouseTransferService {
             .eq(query.needRelabel() != null, WarehouseTransferOrder::getNeedRelabel, query.needRelabel())
             .ge(query.createdFrom() != null, WarehouseTransferOrder::getCreatedAt, query.createdFrom())
             .le(query.createdTo() != null, WarehouseTransferOrder::getCreatedAt, query.createdTo())
+            .ge(query.reviewedFrom() != null, WarehouseTransferOrder::getReviewedAt, query.reviewedFrom())
+            .le(query.reviewedTo() != null, WarehouseTransferOrder::getReviewedAt, query.reviewedTo())
+            .ge(query.outboundFrom() != null, WarehouseTransferOrder::getOutboundAt, query.outboundFrom())
+            .le(query.outboundTo() != null, WarehouseTransferOrder::getOutboundAt, query.outboundTo())
+            .apply(query.measuredFrom() != null, "(SELECT MAX(qp.completed_at) FROM ll_warehouse_transfer_pallet qp WHERE qp.transfer_order_id=ll_warehouse_transfer_order.id AND qp.customer_id=ll_warehouse_transfer_order.customer_id) >= {0}", query.measuredFrom())
+            .apply(query.measuredTo() != null, "(SELECT MAX(qp.completed_at) FROM ll_warehouse_transfer_pallet qp WHERE qp.transfer_order_id=ll_warehouse_transfer_order.id AND qp.customer_id=ll_warehouse_transfer_order.customer_id) <= {0}", query.measuredTo())
             .orderByDesc(WarehouseTransferOrder::getCreatedAt).orderByDesc(WarehouseTransferOrder::getId);
+    }
+
+    /** 日期区间统一校验，列表与数量汇总均拒绝反向区间。 */
+    private void validateQuantityRange(LocalDateTime from, LocalDateTime to, String name) {
+        if (from != null && to != null && from.isAfter(to)) throw badRequest(name + "开始时间不能晚于结束时间");
+    }
+
+    /** 客户侧完整筛选数量，不读取其他客户且不使用页码。 */
+    @Transactional(readOnly = true)
+    public com.baiyue.lastleg.transfer.dto.TransferQuantityTotals quantityTotals(String customerId, WarehouseTransferRequests.Query query) {
+        return transferQuantityService.merchantTotals(transferPageFilter(customerId, query, true), customerId);
+    }
+
+    @Transactional(readOnly = true)
+    public PageResult<WarehouseTransferResponses.Summary> page(String customerId, WarehouseTransferRequests.Query query) {
+        return page(customerId, query, true);
+    }
+
+    @Transactional(readOnly = true)
+    public PageResult<WarehouseTransferResponses.Summary> page(String customerId, WarehouseTransferRequests.Query query,
+                                                                boolean includeDrafts) {
+        var wrapper = transferPageFilter(customerId, query, includeDrafts);
         Page<WarehouseTransferOrder> result = transfers.selectPage(Page.of(query.page(), query.size()), wrapper);
         Map<String, RelabelApplication> relabelApplicationsByNo = relabelApplications(result.getRecords());
         Map<Long, LocalDateTime> measurementTimes = measurementTimes(result.getRecords());
@@ -961,7 +986,7 @@ public class WarehouseTransferService {
                                                            WarehouseTransferRequests.CountCartons request) {
         WarehouseTransferOrder transfer = transfers.lockForPda(transferNo, String.valueOf(warehouseId));
         if (transfer == null) throw notFound("当前仓没有该转运单");
-        if ("WAREHOUSE_PICKUP".equals(transfer.getDeliveryMethod())) pickupService.requireArrived(transfer);
+        if ("WAREHOUSE_PICKUP".equals(transfer.getDeliveryMethod())) pickupService.requireArrived(transfer.getId(), transfer.getDeliveryMethod(), transfer.getTransferNo(), transfer.getInboundCode());
         String customerId = transfer.getCustomerId();
         List<WarehouseTransferCarton> cartons = transferCartons.listOrder(customerId, transfer.getId());
         // 客户补箱后旧设备快照不可确认短收，必须刷新取得新增的预报箱唛。
@@ -1096,7 +1121,11 @@ public class WarehouseTransferService {
 
     /** 上门取货必须先送仓；按 PDA 绑定仓锁定后继续使用原测量流程。 */
     private WarehouseTransferOrder requirePdaMeasuringTransfer(long warehouseId, String transferNo) {
-        return pickupService.requireMeasuringSource(String.valueOf(warehouseId), transferNo);
+        WarehouseTransferOrder transfer = transfers.lockForPda(transferNo, String.valueOf(warehouseId));
+        if (transfer == null) throw notFound("仓储转运单不存在");
+        if (!WAIT_PDA_RECEIVING.equals(transfer.getStatus())) throw conflict("当前转运单不允许测量");
+        pickupService.requireArrived(transfer.getId(), transfer.getDeliveryMethod(), transfer.getTransferNo(), transfer.getInboundCode());
+        return transfer;
     }
 
     private void validatePalletMeasurement(BigDecimal length, BigDecimal width, BigDecimal height, BigDecimal volume) {
@@ -1114,7 +1143,7 @@ public class WarehouseTransferService {
                                                         WarehouseTransferRequests.Palletize request) {
         WarehouseTransferOrder transfer = transfers.lockForPda(transferNo, String.valueOf(overseasWarehouseId));
         if (transfer == null) throw notFound("Warehouse transfer order not found");
-        if ("WAREHOUSE_PICKUP".equals(transfer.getDeliveryMethod())) pickupService.requireArrived(transfer);
+        if ("WAREHOUSE_PICKUP".equals(transfer.getDeliveryMethod())) pickupService.requireArrived(transfer.getId(), transfer.getDeliveryMethod(), transfer.getTransferNo(), transfer.getInboundCode());
         if (!String.valueOf(overseasWarehouseId).equals(transfer.getOperatingWarehouseId())) {
             throw new ResponseStatusException(HttpStatus.FORBIDDEN, "Warehouse transfer belongs to another warehouse");
         }
@@ -1683,7 +1712,7 @@ public class WarehouseTransferService {
                                                                                String transferNo, MultipartFile file) {
         WarehouseTransferOrder transfer = transfers.lockForPda(transferNo, String.valueOf(overseasWarehouseId));
         if (transfer == null) throw notFound("Warehouse transfer order not found");
-        if ("WAREHOUSE_PICKUP".equals(transfer.getDeliveryMethod())) pickupService.requireArrived(transfer);
+        if ("WAREHOUSE_PICKUP".equals(transfer.getDeliveryMethod())) pickupService.requireArrived(transfer.getId(), transfer.getDeliveryMethod(), transfer.getTransferNo(), transfer.getInboundCode());
         if (!WAIT_PDA_RECEIVING.equals(transfer.getStatus())) {
             throw conflict("Measurement photos can only be uploaded before palletization completes");
         }