优化

lastleg-service/src/main/java/com/baiyue/lastleg/inboundplan/pda/controller/ReceivingContainerController.java

@@ -112,14 +112,6 @@ public class ReceivingContainerController {
         return ApiResponse.success(service.resolveCarton(identity.operatorKey(), request));
     }
 
-    @PostMapping("/current/skus/resolve")
-    public ApiResponse<ReceivingContainerResponses.SkuResolved> resolveSku(
-        @AuthenticationPrincipal AuthenticatedUser user,
-        @Valid @RequestBody ReceivingContainerRequests.SkuResolve request) {
-        PdaWarehouseIdentity identity = currentIdentity(user);
-        return ApiResponse.success(service.resolveSku(identity.operatorKey(), request));
-    }
-
     @PostMapping("/current/pallets/resolve")
     public ApiResponse<ReceivingContainerResponses.PalletResolved> resolvePallet(
         @AuthenticationPrincipal AuthenticatedUser user,

lastleg-service/src/main/java/com/baiyue/lastleg/inboundplan/pda/dto/ReceivingContainerRequests.java

@@ -18,10 +18,8 @@ public final class ReceivingContainerRequests {
     public record SignedPhoto(@NotNull ReceivingPhotoRole role,
                               @NotBlank @Pattern(regexp = "^[1-9][0-9]{0,18}$") String fileId) { }
     public record CartonResolve(@NotBlank String cartonMark) { }
-    public record SkuResolve(@NotBlank @Size(max = 128) String skuCode) { }
     public record PalletResolve(@NotBlank String palletCode, @NotBlank String inboundCode) { }
-    public record BulkReceive(@NotBlank String inboundCode, @NotBlank @Size(max = 128) String skuCode,
-                              @NotBlank String palletCode,
+    public record BulkReceive(@NotBlank String inboundCode, @NotBlank String palletCode,
                               @Positive int packageCount, @NotBlank @Size(max = 255) String idempotencyKey) { }
     public record CartonReceive(@NotBlank String cartonMark, @NotBlank String palletCode,
                                 @NotBlank @Size(max = 255) String idempotencyKey) { }

lastleg-service/src/main/java/com/baiyue/lastleg/inboundplan/pda/dto/ReceivingContainerResponses.java

@@ -28,20 +28,13 @@ public final class ReceivingContainerResponses {
                           String fbaWarehouseCode, int plannedPalletCount, int totalPackages,
                           int receivedPackages, int pendingPackages) { }
 
-    public record CartonResolved(String cartonMark, String skuCode, String inboundCode,
+    public record CartonResolved(String cartonMark, String inboundCode,
                                  String destinationType, String overseasWarehouseId,
                                  String overseasWarehouseName, String destinationWarehouseId,
                                  String destinationWarehouseCode, String destinationWarehouseName,
                                  String fbaWarehouseCode, int plannedPalletCount, int totalPackages,
                                  int receivedPackages, int pendingPackages) { }
 
-    public record SkuResolved(String skuCode, String productName, String inboundCode,
-                              String destinationType, String overseasWarehouseId,
-                              String overseasWarehouseName, String destinationWarehouseId,
-                              String destinationWarehouseCode, String destinationWarehouseName,
-                              String fbaWarehouseCode, int plannedPalletCount, int totalPackages,
-                              int receivedPackages, int pendingPackages) { }
-
     public record PalletResolved(String palletCode, long warehouseId, String status,
                                  String fbaWarehouseCode, String inboundCode,
                                  String destinationType, boolean compatible) { }

lastleg-service/src/main/java/com/baiyue/lastleg/inboundplan/pda/service/ReceivingContainerService.java

@@ -226,42 +226,16 @@ public class ReceivingContainerService {
                                                                     ReceivingContainerRequests.CartonResolve request) {
         ReceivingContainerSession session = requireSigned(operatorKey);
         String customerId = session.getCustomerId();
-        List<InboundRef> currentRefs = refs(customerId, session.getContainerNo());
-        if (currentRefs.stream().noneMatch(value ->
-            "OVERSEAS".equals(destinationType(value.line(), value.order())))) {
-            throw conflict("FBA destination must use bulk count");
-        }
-        InboundPlanCarton carton = cartons.selectOne(new LambdaQueryWrapper<InboundPlanCarton>()
-            .eq(InboundPlanCarton::getCustomerId, customerId).eq(InboundPlanCarton::getCartonMark, request.cartonMark()));
-        if (carton == null) throw notFound("Carton mark was not found");
-        InboundRef ref = currentRefs.stream()
-            .filter(value -> Objects.equals(value.line().getOrderId(), carton.getOrderId())).findFirst()
-            .orElseThrow(() -> conflict("Carton mark belongs to another container"));
-        if (!"OVERSEAS".equals(destinationType(ref.line(), ref.order()))) {
-            throw conflict("FBA inbound must use bulk count instead of carton scan");
-        }
+        CartonRef carton = requireCartonRef(customerId, session.getContainerNo(), request.cartonMark());
+        InboundRef ref = carton.ref();
         ReceivingContainerResponses.Inbound inbound = inbound(ref);
-        return new ReceivingContainerResponses.CartonResolved(carton.getCartonMark(), carton.getSkuCode(),
+        return new ReceivingContainerResponses.CartonResolved(carton.carton().getCartonMark(),
             inbound.inboundCode(), inbound.destinationType(), inbound.overseasWarehouseId(),
             inbound.overseasWarehouseName(), inbound.destinationWarehouseId(),
             inbound.destinationWarehouseCode(), inbound.destinationWarehouseName(), inbound.fbaWarehouseCode(),
             inbound.plannedPalletCount(), inbound.totalPackages(), inbound.receivedPackages(), inbound.pendingPackages());
     }
 
-    public ReceivingContainerResponses.SkuResolved resolveSku(String operatorKey,
-                                                               ReceivingContainerRequests.SkuResolve request) {
-        ReceivingContainerSession session = requireSigned(operatorKey);
-        String customerId = session.getCustomerId();
-        List<SkuRef> matches = refs(customerId, session.getContainerNo()).stream()
-            .filter(ref -> "FBA".equals(destinationType(ref.line(), ref.order())))
-            .map(ref -> skuRef(ref, request.skuCode()))
-            .filter(Objects::nonNull)
-            .toList();
-        if (matches.isEmpty()) throw notFound("SKU was not found in the current FBA container");
-        if (matches.size() != 1) throw conflict("SKU belongs to multiple inbound codes in the current container");
-        return skuResponse(matches.get(0));
-    }
-
     public ReceivingContainerResponses.PalletResolved resolvePallet(String operatorKey,
                                                                     ReceivingContainerRequests.PalletResolve request) {
         ReceivingContainerSession session = requireSigned(operatorKey);
@@ -284,22 +258,27 @@ public class ReceivingContainerService {
         if (!"FBA".equals(destinationType(ref.line(), ref.order()))) {
             throw conflict("OVERSEAS destination must use carton-by-carton scanning; bulk count is forbidden");
         }
-        SkuRef sku = requireSku(ref, request.skuCode());
-        validateSkuPending(customerId, sku, request.packageCount());
-        workflow.validateBulkResolved(customerId, ref.plan(), ref.line(), request.packageCount());
+        List<InboundRef> fbaPlanRefs = requireFbaPlanRefs(customerId, session.getContainerNo(), ref);
+        List<FbaSkuAllocation> skuAllocations = allocateFbaSkuReceipts(customerId, fbaPlanRefs, request.packageCount());
+        skuAllocations.forEach(allocation -> workflow.validateBulkResolved(customerId, allocation.ref().plan(),
+            allocation.ref().line(), allocation.packages()));
         WarehouseResourceGateway.WarehousePalletReference resource = warehouse.resolvePallet(request.palletCode());
         validatePallet(ref, resource);
         InboundPlanPallet pallet = choosePallet(ref, resource);
         Long resourceLockId = workflow.assignResolvedPallet(customerId, ref.plan(), pallet, resource);
         try {
-            int accepted = workflow.receiveBulkResolved(customerId, ref.plan(), ref.line(), pallet,
-                request.packageCount(), operatorKey, operatorName);
-            recordSkuReceipt(session, sku, pallet, accepted);
+            int accepted = 0;
+            for (FbaSkuAllocation allocation : skuAllocations) {
+                accepted += workflow.receiveBulkResolved(customerId, allocation.ref().plan(), allocation.ref().line(), pallet,
+                    allocation.packages(), operatorKey, operatorName);
+                recordSkuReceipt(session, allocation, pallet);
+            }
             markReceiving(session);
-            ReceivingContainerResponses.Inbound inbound = inbound(ref);
+            int received = fbaPlanRefs.stream().mapToInt(this::receivedLinePackages).sum();
+            int total = fbaPlanRefs.stream().mapToInt(refValue -> value(refValue.line().getRequiredPackageCount())).sum();
             ReceivingContainerResponses.Receipt result = new ReceivingContainerResponses.Receipt("RECEIVED",
-                session.getContainerNo(), inbound.inboundCode(), inbound.destinationType(), resource.palletNo(), accepted,
-                inbound.receivedPackages(), inbound.pendingPackages(), session.getStatus());
+                session.getContainerNo(), ref.line().getInboundCode(), "FBA", resource.palletNo(), accepted,
+                received, Math.max(0, total - received), session.getStatus());
             save(session, "BULK_RECEIVE", request.idempotencyKey(), request, result);
             return result;
         } catch (RuntimeException failure) {
@@ -320,12 +299,8 @@ public class ReceivingContainerService {
             "OVERSEAS".equals(destinationType(value.line(), value.order())))) {
             throw conflict("FBA destination must use bulk count");
         }
-        InboundPlanCarton carton = cartons.selectOne(new LambdaQueryWrapper<InboundPlanCarton>()
-            .eq(InboundPlanCarton::getCustomerId, customerId).eq(InboundPlanCarton::getCartonMark, request.cartonMark()));
-        if (carton == null) throw notFound("Carton mark was not found");
-        InboundRef ref = currentRefs.stream()
-            .filter(value -> Objects.equals(value.line().getOrderId(), carton.getOrderId())).findFirst()
-            .orElseThrow(() -> conflict("Carton mark belongs to another container"));
+        CartonRef carton = requireCartonRef(customerId, session.getContainerNo(), request.cartonMark());
+        InboundRef ref = carton.ref();
         if (!"OVERSEAS".equals(destinationType(ref.line(), ref.order()))) {
             throw conflict("FBA destination must use bulk count");
         }
@@ -426,7 +401,8 @@ public class ReceivingContainerService {
         List<InboundRef> result = new ArrayList<>();
         for (InboundPlan plan : plansForContainer(customerId, containerNo)) {
             for (InboundPlanLine line : lines.selectList(new LambdaQueryWrapper<InboundPlanLine>()
-                .eq(InboundPlanLine::getCustomerId, customerId).eq(InboundPlanLine::getPlanId, plan.getId()))) {
+                .eq(InboundPlanLine::getCustomerId, customerId).eq(InboundPlanLine::getPlanId, plan.getId())
+                .orderByAsc(InboundPlanLine::getId))) {
                 LastlegOrder order = orders.selectById(line.getOrderId());
                 if (order == null || !customerId.equals(order.getCustomerId())) throw conflict("Inbound line order is missing");
                 result.add(new InboundRef(plan, line, order));
@@ -439,8 +415,37 @@ public class ReceivingContainerService {
         List<InboundRef> matches = refs(customerId, containerNo).stream()
             .filter(value -> inboundCode.equals(value.line().getInboundCode())).toList();
         if (matches.isEmpty()) throw notFound("Inbound code is not part of the current container");
-        if (matches.size() != 1) throw conflict("Inbound code is duplicated inside the current container");
-        return matches.get(0);
+        Set<Long> planIds = matches.stream().map(value -> value.plan().getId()).collect(Collectors.toSet());
+        if (planIds.size() != 1) throw conflict("Inbound code is duplicated inside the current container");
+        return matches.stream().min(Comparator.comparing(value -> value.line().getId())).orElseThrow();
+    }
+
+    private CartonRef requireCartonRef(String customerId, String containerNo, String cartonMark) {
+        InboundPlanCarton carton = cartons.selectOne(new LambdaQueryWrapper<InboundPlanCarton>()
+            .eq(InboundPlanCarton::getCustomerId, customerId).eq(InboundPlanCarton::getCartonMark, cartonMark));
+        if (carton == null) throw notFound("Carton mark was not found");
+        List<InboundRef> matches = refs(customerId, containerNo).stream()
+            .filter(value -> carton.getLineId() == null || Objects.equals(value.line().getId(), carton.getLineId()))
+            .filter(value -> carton.getPlanId() == null || Objects.equals(value.plan().getId(), carton.getPlanId()))
+            .filter(value -> Objects.equals(value.line().getOrderId(), carton.getOrderId())).toList();
+        if (matches.size() != 1) throw conflict("Carton mark belongs to another container");
+        return new CartonRef(carton, matches.get(0));
+    }
+
+    private List<InboundRef> requireFbaPlanRefs(String customerId, String containerNo, InboundRef selected) {
+        List<InboundRef> values = refs(customerId, containerNo).stream()
+            .filter(value -> Objects.equals(value.plan().getId(), selected.plan().getId()))
+            .sorted(Comparator.comparing(value -> value.line().getId())).toList();
+        if (values.isEmpty() || values.stream().anyMatch(value ->
+            !"FBA".equals(destinationType(value.line(), value.order())))) {
+            throw conflict("FBA bulk receiving requires every line in the selected inbound plan to be FBA");
+        }
+        Set<String> destinations = values.stream().map(value -> trim(value.line().getFbaWarehouseCode()))
+            .collect(Collectors.toSet());
+        if (destinations.size() != 1 || destinations.contains(null)) {
+            throw conflict("FBA bulk receiving requires one destination warehouse per inbound plan");
+        }
+        return values;
     }
 
     private InboundPlanPallet choosePallet(InboundRef ref, WarehouseResourceGateway.WarehousePalletReference resource) {
@@ -553,44 +558,54 @@ public class ReceivingContainerService {
         throw conflict("Unload photo file ID must be a positive decimal string");
     }
 
-    private SkuRef requireSku(InboundRef ref, String skuCode) {
-        SkuRef result = skuRef(ref, skuCode);
-        if (result == null) throw notFound("SKU is not part of the selected inbound code");
+    private List<FbaSkuAllocation> allocateFbaSkuReceipts(String customerId, List<InboundRef> refs, int packageCount) {
+        int remaining = packageCount;
+        List<FbaSkuAllocation> result = new ArrayList<>();
+        for (InboundRef ref : refs) {
+            int linePending = value(ref.line().getRequiredPackageCount()) - receivedLinePackages(ref);
+            List<SkuExpectation> expectations = skuExpectations(ref);
+            int skuPending = expectations.stream().mapToInt(expectation -> expectation.expectedPackages()
+                - receivedSkuPackages(customerId, ref.line().getId(), expectation.skuCode())).sum();
+            if (linePending < 0 || skuPending != linePending) {
+                throw conflict("FBA SKU receipt progress must exactly match the inbound line progress");
+            }
+            for (SkuExpectation expectation : expectations) {
+                if (remaining == 0) break;
+                int skuPendingPackages = expectation.expectedPackages()
+                    - receivedSkuPackages(customerId, ref.line().getId(), expectation.skuCode());
+                int accepted = Math.min(remaining, skuPendingPackages);
+                if (accepted > 0) {
+                    result.add(new FbaSkuAllocation(ref, expectation.skuCode(), expectation.productName(), accepted));
+                    remaining -= accepted;
+                }
+            }
+            if (remaining == 0) break;
+        }
+        if (remaining != 0) throw conflict("Received package count exceeds the FBA inbound pending total");
         return result;
     }
 
-    private SkuRef skuRef(InboundRef ref, String skuCode) {
-        String requested = trim(skuCode);
-        if (requested == null) return null;
+    private List<SkuExpectation> skuExpectations(InboundRef ref) {
         List<LastlegOrderDetail> details = orderDetails.selectList(new LambdaQueryWrapper<LastlegOrderDetail>()
             .eq(LastlegOrderDetail::getCustomerId, ref.order().getCustomerId())
             .eq(LastlegOrderDetail::getOrderId, ref.order().getId()).orderByAsc(LastlegOrderDetail::getId));
-        List<LastlegOrderDetail> matched = details.stream()
-            .filter(detail -> requested.equalsIgnoreCase(trim(detail.getSkuCode()))).toList();
-        int expected = matched.stream().mapToInt(detail -> value(detail.getPackageCount())).sum();
-        if (expected <= 0) return null;
-        String canonicalSku = matched.stream().map(LastlegOrderDetail::getSkuCode).map(ReceivingContainerService::trim)
-            .filter(Objects::nonNull).findFirst().orElse(requested);
-        String productName = matched.stream().map(detail -> first(detail.getProductNameZh(), detail.getProductNameEn()))
-            .filter(Objects::nonNull).findFirst().orElse(null);
-        return new SkuRef(ref, canonicalSku, productName, expected);
-    }
-
-    private ReceivingContainerResponses.SkuResolved skuResponse(SkuRef sku) {
-        ReceivingContainerResponses.Inbound inbound = inbound(sku.ref());
-        int received = receivedSkuPackages(sku.ref().order().getCustomerId(), sku.ref().line().getId(), sku.skuCode());
-        return new ReceivingContainerResponses.SkuResolved(sku.skuCode(), sku.productName(), inbound.inboundCode(),
-            inbound.destinationType(), inbound.overseasWarehouseId(), inbound.overseasWarehouseName(),
-            inbound.destinationWarehouseId(), inbound.destinationWarehouseCode(),
-            inbound.destinationWarehouseName(), inbound.fbaWarehouseCode(), inbound.plannedPalletCount(),
-            sku.expectedPackages(), received, Math.max(0, sku.expectedPackages() - received));
-    }
-
-    private void validateSkuPending(String customerId, SkuRef sku, int packageCount) {
-        int received = receivedSkuPackages(customerId, sku.ref().line().getId(), sku.skuCode());
-        if (packageCount <= 0 || packageCount > sku.expectedPackages() - received) {
-            throw conflict("Received package count exceeds the SKU pending total");
+        Map<String, SkuExpectation> grouped = new LinkedHashMap<>();
+        for (LastlegOrderDetail detail : details) {
+            String skuCode = trim(detail.getSkuCode());
+            int expected = value(detail.getPackageCount());
+            if (skuCode == null || expected <= 0) continue;
+            String key = skuCode.toUpperCase(java.util.Locale.ROOT);
+            SkuExpectation existing = grouped.get(key);
+            grouped.put(key, existing == null ? new SkuExpectation(skuCode,
+                first(detail.getProductNameZh(), detail.getProductNameEn()), expected)
+                : new SkuExpectation(existing.skuCode(), existing.productName(), existing.expectedPackages() + expected));
         }
+        List<SkuExpectation> result = List.copyOf(grouped.values());
+        int expected = result.stream().mapToInt(SkuExpectation::expectedPackages).sum();
+        if (result.isEmpty() || expected != value(ref.line().getRequiredPackageCount())) {
+            throw conflict("Frozen FBA SKU package snapshots must exactly match the inbound line total");
+        }
+        return result;
     }
 
     private int receivedSkuPackages(String customerId, Long lineId, String skuCode) {
@@ -598,7 +613,15 @@ public class ReceivingContainerService {
             .mapToInt(value -> value(value.getReceivedPackages())).sum();
     }
 
-    private void recordSkuReceipt(ReceivingContainerSession session, SkuRef sku, InboundPlanPallet pallet, int packages) {
+    private int receivedLinePackages(InboundRef ref) {
+        return allocations.selectList(new LambdaQueryWrapper<InboundPlanPalletAllocation>()
+            .eq(InboundPlanPalletAllocation::getCustomerId, ref.order().getCustomerId())
+            .eq(InboundPlanPalletAllocation::getPlanId, ref.plan().getId())
+            .eq(InboundPlanPalletAllocation::getLineId, ref.line().getId())).stream()
+            .mapToInt(value -> value(value.getPickedPackageCount())).sum();
+    }
+
+    private void recordSkuReceipt(ReceivingContainerSession session, FbaSkuAllocation sku, InboundPlanPallet pallet) {
         List<ReceivingSkuReceipt> existing = skuReceipts.lockLineSku(session.getCustomerId(),
             sku.ref().line().getId(), sku.skuCode());
         ReceivingSkuReceipt receipt = existing.stream()
@@ -610,11 +633,11 @@ public class ReceivingContainerService {
             receipt.setPlanId(sku.ref().plan().getId()); receipt.setLineId(sku.ref().line().getId());
             receipt.setPalletId(pallet.getId()); receipt.setOrderId(sku.ref().order().getId());
             receipt.setInboundCode(sku.ref().line().getInboundCode()); receipt.setSkuCode(sku.skuCode());
-            receipt.setProductName(sku.productName()); receipt.setReceivedPackages(packages);
+            receipt.setProductName(sku.productName()); receipt.setReceivedPackages(sku.packages());
             receipt.setCreatedAt(now); receipt.setUpdatedAt(now); receipt.setVersion(0);
             skuReceipts.insert(receipt);
         } else {
-            receipt.setReceivedPackages(value(receipt.getReceivedPackages()) + packages);
+            receipt.setReceivedPackages(value(receipt.getReceivedPackages()) + sku.packages());
             receipt.setUpdatedAt(now);
             if (skuReceipts.updateById(receipt) != 1) throw conflict("SKU receiving progress changed concurrently");
         }
@@ -623,21 +646,14 @@ public class ReceivingContainerService {
     private void validateFbaSkuBalance(String customerId, String containerNo) {
         for (InboundRef ref : refs(customerId, containerNo)) {
             if (!"FBA".equals(destinationType(ref.line(), ref.order()))) continue;
-            List<LastlegOrderDetail> details = orderDetails.selectList(new LambdaQueryWrapper<LastlegOrderDetail>()
-                .eq(LastlegOrderDetail::getCustomerId, customerId).eq(LastlegOrderDetail::getOrderId, ref.order().getId()));
-            Set<String> skuCodes = details.stream().map(LastlegOrderDetail::getSkuCode)
-                .map(ReceivingContainerService::trim).filter(Objects::nonNull)
-                .map(value -> value.toUpperCase(java.util.Locale.ROOT))
-                .collect(Collectors.toCollection(java.util.LinkedHashSet::new));
-            int expected = 0;
+            List<SkuExpectation> skuCodes = skuExpectations(ref);
             int received = 0;
-            for (String skuCode : skuCodes) {
-                SkuRef sku = requireSku(ref, skuCode);
+            for (SkuExpectation sku : skuCodes) {
                 int skuReceived = receivedSkuPackages(customerId, ref.line().getId(), sku.skuCode());
                 if (skuReceived != sku.expectedPackages()) throw conflict("Every FBA SKU must be fully received before completing the container");
-                expected += sku.expectedPackages(); received += skuReceived;
+                received += skuReceived;
             }
-            if (skuCodes.isEmpty() || expected != value(ref.line().getRequiredPackageCount()) || received != expected) {
+            if (received != value(ref.line().getRequiredPackageCount())) {
                 throw conflict("FBA SKU package snapshots must exactly match the inbound code total");
             }
         }
@@ -790,7 +806,9 @@ public class ReceivingContainerService {
     private static ResponseStatusException notFound(String message) { return new ResponseStatusException(HttpStatus.NOT_FOUND, message); }
 
     private record InboundRef(InboundPlan plan, InboundPlanLine line, LastlegOrder order) { }
-    private record SkuRef(InboundRef ref, String skuCode, String productName, int expectedPackages) { }
+    private record CartonRef(InboundPlanCarton carton, InboundRef ref) { }
+    private record SkuExpectation(String skuCode, String productName, int expectedPackages) { }
+    private record FbaSkuAllocation(InboundRef ref, String skuCode, String productName, int packages) { }
     private record Totals(int inboundCount, List<String> destinationCodes, int plannedPalletCount,
                           int total, int received) { }
     private record PrepareCommand(String containerNo, String idempotencyKey) { }