Merge branch 'dev-lyhfive' of http://git.buggoglobal.com/java-project/baiyue-firstleg into dev

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

@@ -0,0 +1,73 @@
+package com.baiyue.lastleg.service;
+
+import com.baomidou.mybatisplus.core.toolkit.IdWorker;
+import com.baiyue.common.event.EventEnvelope;
+import com.baiyue.common.event.EventIdentifiers;
+import com.baiyue.common.event.EventPayloadCanonicalizer;
+import com.baiyue.common.event.EventPayloadHash;
+import com.baiyue.common.event.EventTypes;
+import com.baiyue.common.event.OverseasInboundOrderDetainedChangedV1;
+import com.baiyue.common.event.RegionCode;
+import com.baiyue.lastleg.entity.LastlegEventOutbox;
+import com.baiyue.lastleg.entity.LastlegOrder;
+import com.baiyue.lastleg.mapper.LastlegEventOutboxMapper;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+
+/** 在尾程业务事务内冻结按来源入仓单回传国内的暂扣状态事件。 */
+@Service
+public class InboundOrderDetainedOutboxService {
+    @Resource private LastlegEventOutboxMapper mapper;
+    @Resource private ObjectMapper objectMapper;
+
+    public void publish(LastlegOrder order, boolean detained, String reason, String operatorId,
+                        String operatorName, Instant changedAt, long changeVersion) {
+        requireText(order.getSourceInboundId(), "sourceInboundId");
+        requireText(order.getInboundCode(), "inboundCode");
+        requireText(order.getCustomerId(), "customerId");
+        var payload = new OverseasInboundOrderDetainedChangedV1(order.getSourceInboundId(),
+            order.getInboundCode(), String.valueOf(order.getId()), order.getOrderNo(), detained,
+            reason, operatorId, operatorName, changedAt);
+        JsonNode payloadNode = objectMapper.valueToTree(payload);
+        String eventKey = EventTypes.OVERSEAS_INBOUND_ORDER_DETAINED_CHANGED + ':'
+            + order.getSourceInboundId() + ':' + changeVersion;
+        EventEnvelope envelope = new EventEnvelope(EventIdentifiers.newUuid(),
+            EventTypes.OVERSEAS_INBOUND_ORDER_DETAINED_CHANGED, 1, changedAt,
+            RegionCode.OVERSEAS, RegionCode.CN, order.getCustomerId(), "INBOUND_ORDER",
+            order.getSourceInboundId(), changeVersion, 1L, EventIdentifiers.newUuid(),
+            eventKey, order.getSourceEventId(), payloadNode,
+            EventPayloadHash.sha256(EventPayloadCanonicalizer.canonicalize(payloadNode))).requireValid();
+
+        LastlegEventOutbox event = new LastlegEventOutbox();
+        event.setId(IdWorker.getId());
+        event.setCustomerId(order.getCustomerId());
+        event.setAggregateType(envelope.aggregateType());
+        event.setAggregateId(envelope.aggregateId());
+        event.setEventType(envelope.eventType());
+        event.setEventVersion(envelope.eventVersion());
+        event.setEventKey(eventKey);
+        event.setPayloadJson(json(envelope));
+        event.setStatus("PENDING");
+        event.setRetryCount(0);
+        event.setCreatedAt(LocalDateTime.ofInstant(changedAt, ZoneOffset.UTC));
+        mapper.insert(event);
+    }
+
+    private static void requireText(String value, String field) {
+        if (value == null || value.isBlank()) throw new IllegalStateException(field + " is required");
+    }
+
+    private String json(Object value) {
+        try { return objectMapper.writeValueAsString(value); }
+        catch (JsonProcessingException exception) {
+            throw new IllegalStateException("Cannot serialize inbound detained event", exception);
+        }
+    }
+}

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

@@ -4,9 +4,13 @@ import com.baiyue.lastleg.mapper.LastlegOrderNoDailySequenceMapper;
 import jakarta.annotation.Resource;
 import org.springframework.stereotype.Component;
 
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
 import java.time.LocalDate;
 import java.time.ZoneId;
 import java.time.format.DateTimeFormatter;
+import java.util.Locale;
 
 @Component
 public class LastlegOrderNoGenerator {
@@ -26,4 +30,61 @@ public class LastlegOrderNoGenerator {
         }
         return "LMO-" + BUSINESS_DATE.format(businessDate) + "-" + String.format("%04d", sequence);
     }
+
+    public String next(String businessType, String warehouse, long uniqueId) {
+        String type = normalizeType(businessType);
+        return type + "-" + warehouseCode(warehouse) + "-"
+            + LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE) + "-"
+            + String.format(Locale.ROOT, "%06d", Math.floorMod(uniqueId, 1_000_000));
+    }
+
+    private String normalizeType(String value) {
+        String code = value == null ? "LMO" : value.trim().toUpperCase(Locale.ROOT);
+        return switch (code) {
+            case "FIRST_LEG" -> "FL";
+            case "ONE_CLICK_DROPSHIP" -> "OD";
+            case "RELABEL_APPLICATION", "RELABEL" -> "RL";
+            case "WAREHOUSE_TRANSFER", "TRANSFER" -> "WT";
+            case "LOCAL_LOOSEBOARD", "LOOSEBOARD" -> "LB";
+            case "DISPATCH", "PICKUP_CAR" -> "DS";
+            case "OUTBOUND" -> "OB";
+            case "DELIVERY" -> "DL";
+            case "TRUCK" -> "TR";
+            case "EXCEPTION" -> "EX";
+            case "DISCARD" -> "CD";
+            case "PROCUREMENT" -> "PR";
+            case "INBOUND_PLAN" -> "IP";
+            default -> {
+                String normalized = code.replaceAll("[^A-Z0-9]", "");
+                yield normalized.isEmpty() ? "LMO" : normalized.substring(0, Math.min(4, normalized.length()));
+            }
+        };
+    }
+
+    public String warehouseCode(String value) {
+        String code = value == null ? "" : value.trim().toUpperCase(Locale.ROOT);
+        if (code.isEmpty()) return "WH";
+        if (code.matches(".*(LAX|ONT|NYC|JFK|LGB|EWR|SFO|SEA|DFW|ORD|ATL|MIA|PHX|LAS|YYZ|YVR|AMS|LHR|FRA|CDG|HKG|NRT|SYD).*")) {
+            var match = java.util.regex.Pattern.compile("(LAX|ONT|NYC|JFK|LGB|EWR|SFO|SEA|DFW|ORD|ATL|MIA|PHX|LAS|YYZ|YVR|AMS|LHR|FRA|CDG|HKG|NRT|SYD)").matcher(code);
+            if (match.find()) return match.group(1);
+        }
+        if (code.matches("[A-Z0-9]{2,8}")) return code;
+        return "WH";
+    }
+
+    /** The physical container number is the tail-leg business order grouping boundary. */
+    public String forContainerNo(String containerNo) {
+        if (containerNo == null || containerNo.isBlank()) {
+            throw new IllegalArgumentException("containerNo is required");
+        }
+        String normalized = containerNo.trim();
+        try {
+            byte[] digest = MessageDigest.getInstance("SHA-256")
+                .digest(normalized.getBytes(StandardCharsets.UTF_8));
+            long suffix = java.nio.ByteBuffer.wrap(digest, 0, 8).getLong();
+            return next("FIRST_LEG", null, suffix);
+        } catch (NoSuchAlgorithmException exception) {
+            throw new IllegalStateException("SHA-256 is unavailable", exception);
+        }
+    }
 }

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

@@ -1,6 +1,7 @@
 package com.baiyue.lastleg.service;
 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.toolkit.IdWorker;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baiyue.common.core.api.PageResult;
 import com.baiyue.common.event.ContainerNumbers;
@@ -12,11 +13,16 @@ import com.baiyue.lastleg.dto.ContainerPlanProgressSummary;
 import com.baiyue.lastleg.entity.LastlegOrder;
 import com.baiyue.lastleg.entity.LastlegOrderDetail;
 import com.baiyue.lastleg.entity.LastlegOrderStatusHistory;
+import com.baiyue.lastleg.entity.LastlegOrderFee;
+import com.baiyue.lastleg.entity.LastlegOrderOperationLog;
 import com.baiyue.lastleg.inboundplan.entity.InboundPlanCarton;
 import com.baiyue.lastleg.inboundplan.mapper.InboundPlanCartonMapper;
+import com.baiyue.lastleg.inventory.command.service.InventoryCommandService;
 import com.baiyue.lastleg.mapper.LastlegOrderDetailMapper;
 import com.baiyue.lastleg.mapper.LastlegOrderMapper;
 import com.baiyue.lastleg.mapper.LastlegOrderStatusHistoryMapper;
+import com.baiyue.lastleg.mapper.LastlegOrderFeeMapper;
+import com.baiyue.lastleg.mapper.LastlegOrderOperationLogMapper;
 import com.baiyue.lastleg.model.LastlegOrderType;
 import jakarta.annotation.Resource;
 import org.springframework.http.HttpStatus;
@@ -26,9 +32,15 @@ import org.springframework.util.StringUtils;
 import org.springframework.web.server.ResponseStatusException;
 
 import java.nio.charset.StandardCharsets;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
 import java.time.LocalDateTime;
+import java.time.ZoneOffset;
 import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 
 @Service
@@ -36,17 +48,24 @@ public class LastlegOrderService {
     public static final String PENDING_ASSIGNMENT = "PENDING_ASSIGNMENT";
     public static final String DESTINATION_ASSIGNED = "DESTINATION_ASSIGNED";
     public static final String INBOUND_PLANNED = "INBOUND_PLANNED";
+    public static final String PALLET_MERGE_REQUIRED = "REQUIRED";
+    public static final String PALLET_MERGED = "MERGED";
 
     @Resource private LastlegOrderMapper orderMapper;
     @Resource private LastlegOrderDetailMapper detailMapper;
     @Resource private LastlegOrderStatusHistoryMapper historyMapper;
+    @Resource private LastlegOrderFeeMapper feeMapper;
+    @Resource private LastlegOrderOperationLogMapper operationLogMapper;
     @Resource private InboundPlanCartonMapper cartonMapper;
     @Resource private FbaWarehouseValidator fbaWarehouseValidator;
+    @Resource private InventoryCommandService inventory;
+    @Resource private InboundOrderDetainedOutboxService detainedOutbox;
 
     public PageResult<LastlegOrderSummary> page(String customerId, LastlegOrderRequests.Query query) {
         Page<LastlegOrder> page = orderMapper.selectPage(
             new Page<>(query.page(), query.size()), filter(customerId, query).orderByDesc(LastlegOrder::getCreatedAt));
-        return new PageResult<>(page.getRecords().stream().map(this::summary).toList(),
+        Map<Long, List<LastlegOrderMapper.PalletMergeRelationRow>> mergeRelations = palletMergeRelations(page.getRecords());
+        return new PageResult<>(page.getRecords().stream().map(order -> summary(order, mergeRelations.get(order.getId()))).toList(),
             page.getCurrent(), page.getSize(), page.getTotal(), page.getPages());
     }
 
@@ -100,9 +119,165 @@ public class LastlegOrderService {
                 .eq(LastlegOrderStatusHistory::getCustomerId, order.getCustomerId())
                 .eq(LastlegOrderStatusHistory::getOrderId, orderId)
                 .orderByAsc(LastlegOrderStatusHistory::getCreatedAt));
-        return new LastlegOrderDetailResponse(summary(order), cargo, history.stream()
+        List<LastlegOrderFee> fees = feeMapper.selectList(new LambdaQueryWrapper<LastlegOrderFee>()
+            .eq(LastlegOrderFee::getCustomerId, order.getCustomerId())
+            .eq(LastlegOrderFee::getOrderId, orderId).orderByAsc(LastlegOrderFee::getCreatedAt));
+        List<LastlegOrderOperationLog> operations = operationLogMapper.selectList(
+            new LambdaQueryWrapper<LastlegOrderOperationLog>()
+                .eq(LastlegOrderOperationLog::getCustomerId, order.getCustomerId())
+                .eq(LastlegOrderOperationLog::getOrderId, orderId)
+                .orderByAsc(LastlegOrderOperationLog::getCreatedAt));
+        return new LastlegOrderDetailResponse(summary(order, palletMergeRelations(List.of(order)).get(order.getId())), cargo, history.stream()
             .map(value -> new LastlegOrderDetailResponse.History(value.getId(), value.getFromStatus(),
-                value.getToStatus(), value.getRemark(), value.getCreatedAt())).toList());
+                value.getToStatus(), value.getRemark(), value.getCreatedAt())).toList(), fees, operations.stream()
+            .map(value -> new LastlegOrderDetailResponse.Operation(value.getId(), value.getOperationNode(),
+                value.getOperatorName(), value.getResult(), value.getCreatedAt())).toList());
+    }
+
+    @Transactional
+    public LastlegOrderFee createFee(String customerId, long orderId, LastlegOrderRequests.CreateFee request,
+                                     String operatorName) {
+        LastlegOrder order = findOwned(customerId, orderId);
+        LocalDateTime now = LocalDateTime.now();
+        LastlegOrderFee fee = new LastlegOrderFee();
+        fee.setId(IdWorker.getId());
+        fee.setCustomerId(order.getCustomerId());
+        fee.setOrderId(orderId);
+        fee.setFeeItem(request.feeItem().trim());
+        fee.setCurrency(request.currency());
+        fee.setAmount(request.amount());
+        fee.setStatus(request.status());
+        fee.setSupplierDescription(StringUtils.hasText(request.supplierDescription())
+            ? request.supplierDescription().trim() : null);
+        fee.setCreatedBy(operatorName);
+        fee.setCreatedAt(now);
+        fee.setUpdatedAt(now);
+        feeMapper.insert(fee);
+
+        LastlegOrderOperationLog operation = new LastlegOrderOperationLog();
+        operation.setId(IdWorker.getId());
+        operation.setCustomerId(order.getCustomerId());
+        operation.setOrderId(orderId);
+        operation.setOperationNode("新增费用");
+        operation.setOperatorName(operatorName);
+        operation.setResult("新增" + fee.getFeeItem() + "：" + fee.getCurrency() + " " + fee.getAmount().toPlainString());
+        operation.setCreatedAt(now);
+        operationLogMapper.insert(operation);
+        return fee;
+    }
+
+    @Transactional
+    public void setDetained(String customerId, long orderId, LastlegOrderRequests.SetDetained request,
+                            String operatorName) {
+        setDetained(customerId, orderId, request, null, operatorName);
+    }
+
+    @Transactional
+    public void setDetained(String customerId, long orderId, LastlegOrderRequests.SetDetained request,
+                            String operatorId, String operatorName) {
+        LastlegOrder current = findOwned(customerId, orderId);
+        LastlegOrder order = orderMapper.lockById(current.getCustomerId(), orderId);
+        if (order == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Tail-leg order not found");
+        boolean detained = request.detained();
+        if (Boolean.TRUE.equals(order.getDetained()) == detained) {
+            throw new ResponseStatusException(HttpStatus.CONFLICT, detained ? "Order is already held" : "Order is not held");
+        }
+        if (detained && "INBOUND_COMPLETED".equals(order.getCurrentStatus())) {
+            throw new ResponseStatusException(HttpStatus.CONFLICT, "Completed inbound orders cannot be newly held");
+        }
+        LocalDateTime now = LocalDateTime.now();
+        order.setDetained(detained);
+        order.setUpdatedAt(now);
+        orderMapper.updateById(order);
+        if (!detained && "INBOUND_COMPLETED".equals(order.getCurrentStatus())) {
+            inventory.releaseInboundOrderHold(order.getCustomerId(), operatorName, orderId, order.getOrderNo(), request.remark().trim());
+        }
+        LastlegOrderOperationLog operation = new LastlegOrderOperationLog();
+        operation.setId(IdWorker.getId());
+        operation.setCustomerId(order.getCustomerId());
+        operation.setOrderId(orderId);
+        operation.setOperationNode(detained ? "暂扣" : "解除暂扣");
+        operation.setOperatorName(operatorName);
+        operation.setResult(request.remark().trim());
+        operation.setCreatedAt(now);
+        operationLogMapper.insert(operation);
+        if (StringUtils.hasText(order.getSourceInboundId())) {
+            detainedOutbox.publish(order, detained, request.remark().trim(), operatorId, operatorName,
+                now.toInstant(ZoneOffset.UTC), operation.getId());
+        }
+    }
+
+    @Transactional
+    public void setPalletMergeRequired(String customerId, long orderId,
+                                       LastlegOrderRequests.SetPalletMergeRequired request,
+                                       String operatorName) {
+        LastlegOrder current = findOwned(customerId, orderId);
+        LastlegOrder order = orderMapper.lockById(current.getCustomerId(), orderId);
+        if (order == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Tail-leg order not found");
+        if ("INBOUND_COMPLETED".equals(order.getCurrentStatus())) {
+            throw new ResponseStatusException(HttpStatus.CONFLICT,
+                "Completed inbound orders cannot change the pallet merge mark");
+        }
+        if (PALLET_MERGED.equals(order.getPalletMergeFlag())) {
+            throw new ResponseStatusException(HttpStatus.CONFLICT,
+                "A completed pallet merge cannot be unmarked");
+        }
+        String target = request.palletMergeRequired() ? PALLET_MERGE_REQUIRED : null;
+        if (Objects.equals(target, order.getPalletMergeFlag())) return;
+        LocalDateTime now = LocalDateTime.now();
+        if (orderMapper.updatePalletMergeFlag(order.getCustomerId(), orderId, target, now) != 1) {
+            throw new ResponseStatusException(HttpStatus.CONFLICT, "Pallet merge mark was not updated");
+        }
+        LastlegOrderOperationLog operation = new LastlegOrderOperationLog();
+        operation.setId(IdWorker.getId());
+        operation.setCustomerId(order.getCustomerId());
+        operation.setOrderId(orderId);
+        operation.setOperationNode(request.palletMergeRequired() ? "标记合托" : "取消合托标记");
+        operation.setOperatorName(operatorName);
+        operation.setResult(request.palletMergeRequired()
+            ? "PDA扫描本单箱唛时提示需要合托" : "已取消PDA合托提示");
+        operation.setCreatedAt(now);
+        operationLogMapper.insert(operation);
+    }
+
+    @Transactional
+    public void setPalletMergeBatch(String customerId, LastlegOrderRequests.SetPalletMergeBatch request,
+                                    String operatorName) {
+        List<Long> ids = request.orderIds().stream().filter(Objects::nonNull).distinct().toList();
+        if (ids.isEmpty()) throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "At least one order is required");
+        List<LastlegOrder> orders = orderMapper.selectList(new LambdaQueryWrapper<LastlegOrder>()
+            .eq(StringUtils.hasText(customerId), LastlegOrder::getCustomerId, customerId)
+            .in(LastlegOrder::getId, ids).last("FOR UPDATE"));
+        if (orders.size() != ids.size()) {
+            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "One or more tail-leg orders were not found");
+        }
+        if (orders.stream().map(LastlegOrder::getCustomerId).distinct().count() != 1) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Pallet merge orders must belong to one customer");
+        }
+        if (orders.stream().map(order -> StringUtils.hasText(order.getTransferWarehouseCode())
+            ? order.getTransferWarehouseCode() : order.getFbaWarehouseCode()).filter(Objects::nonNull).distinct().count() > 1) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Pallet merge orders must have one destination warehouse");
+        }
+        if (orders.stream().anyMatch(order -> "INBOUND_COMPLETED".equals(order.getCurrentStatus())
+            || PALLET_MERGED.equals(order.getPalletMergeFlag()))) {
+            throw new ResponseStatusException(HttpStatus.CONFLICT, "Completed pallet merge orders cannot be changed");
+        }
+        String batchId = request.palletMergeRequired()
+            ? "PMG-" + java.util.UUID.randomUUID().toString().replace("-", "") : null;
+        String flag = request.palletMergeRequired() ? PALLET_MERGE_REQUIRED : null;
+        LocalDateTime now = LocalDateTime.now();
+        for (LastlegOrder order : orders) {
+            if (orderMapper.updatePalletMergeBatch(order.getCustomerId(), order.getId(), flag, batchId, now) != 1) {
+                throw new ResponseStatusException(HttpStatus.CONFLICT, "Pallet merge group was not updated");
+            }
+            LastlegOrderOperationLog operation = new LastlegOrderOperationLog();
+            operation.setId(IdWorker.getId()); operation.setCustomerId(order.getCustomerId());
+            operation.setOrderId(order.getId());
+            operation.setOperationNode(request.palletMergeRequired() ? "批量标记合托" : "取消合托标记");
+            operation.setOperatorName(operatorName);
+            operation.setResult(request.palletMergeRequired() ? "PDA合托分组 " + batchId : "已取消PDA合托分组");
+            operation.setCreatedAt(now); operationLogMapper.insert(operation);
+        }
     }
 
     @Transactional
@@ -163,12 +338,25 @@ public class LastlegOrderService {
     }
 
     public byte[] exportCsv(String customerId, LastlegOrderRequests.Query query) {
-        List<LastlegOrder> orders = orderMapper.selectList(filter(customerId, query)
-            .orderByDesc(LastlegOrder::getCreatedAt).last("LIMIT 10000"));
-        List<String> lines = new ArrayList<>();
-        lines.add("ID,尾程单号,订单类型,入仓码,头程单号,货主,海外仓,转仓,转仓编码,FBA仓库,集装箱号,货柜状态,是否异常,是否暂扣,托数,箱数,体积(m3),数量,体积重量,预计到港时间,实际到港时间,预计到仓,入库单号,换标单号,换标状态,合托标记,主流程状态,子单状态,备注(仅自己),备注(客户),备注(仓库)");
-        for (LastlegOrder order : orders) {
-            lines.add(String.join(",", List.of(
+        try (ByteArrayOutputStream output = new ByteArrayOutputStream()) {
+            writeExportCsv(customerId, query, output);
+            return output.toByteArray();
+        } catch (IOException e) {
+            throw new IllegalStateException("Unable to export tail-leg orders", e);
+        }
+    }
+
+    public void writeExportCsv(String customerId, LastlegOrderRequests.Query query, OutputStream output)
+        throws IOException {
+        output.write("\uFEFFID,尾程单号,订单类型,入仓码,头程单号,货主,海外仓,转仓,转仓编码,FBA仓库,集装箱号,货柜状态,是否异常,是否暂扣,托数,箱数,体积(m3),数量,体积重量,预计到港时间,实际到港时间,预计到仓,入库单号,换标单号,换标状态,合托标记,主流程状态,子单状态,备注(仅自己),备注(客户),备注(仓库)\r\n".getBytes(StandardCharsets.UTF_8));
+        final int batchSize = 1000;
+        long page = 1;
+        while (true) {
+            List<LastlegOrder> orders = orderMapper.selectPage(new com.baomidou.mybatisplus.extension.plugins.pagination.Page<>(page, batchSize),
+                filter(customerId, query).orderByDesc(LastlegOrder::getCreatedAt).orderByDesc(LastlegOrder::getId)).getRecords();
+            if (orders.isEmpty()) break;
+            for (LastlegOrder order : orders) {
+                String line = String.join(",", List.of(
                 csv(order.getId()), csv(order.getOrderNo()), csv(LastlegOrderType.labelOf(order.getOrderType())),
                 csv(order.getInboundCode()),
                 csv(order.getSourceOrderNo()), csv(order.getCustomerName()), csv(order.getOverseasWarehouseName()),
@@ -178,9 +366,13 @@ public class LastlegOrderService {
                 csv(order.getVolumeWeightKg()), csv(order.getEstimatedArrivalAt()), csv(order.getActualArrivalAt()),
                 csv(order.getEstimatedWarehouseAt()), csv(order.getInboundOrderNo()), csv(order.getRelabelOrderNo()), csv(order.getRelabelStatus()),
                 csv(order.getPalletMergeFlag()), csv(order.getCurrentStatus()), csv(order.getSubOrderStatus()), csv(order.getPrivateRemark()),
-                csv(order.getCustomerRemark()), csv(order.getWarehouseRemark()))));
+                csv(order.getCustomerRemark()), csv(order.getWarehouseRemark()))) + "\r\n";
+                output.write(line.getBytes(StandardCharsets.UTF_8));
+            }
+            output.flush();
+            if (orders.size() < batchSize) break;
+            page++;
         }
-        return ("\uFEFF" + String.join("\r\n", lines)).getBytes(StandardCharsets.UTF_8);
     }
 
     private LambdaQueryWrapper<LastlegOrder> filter(String customerId, LastlegOrderRequests.Query query) {
@@ -224,7 +416,20 @@ public class LastlegOrderService {
         }
     }
 
-    private LastlegOrderSummary summary(LastlegOrder o) {
+    private Map<Long, List<LastlegOrderMapper.PalletMergeRelationRow>> palletMergeRelations(List<LastlegOrder> orders) {
+        if (orders.isEmpty()) return Map.of();
+        Map<Long, List<LastlegOrderMapper.PalletMergeRelationRow>> result = new LinkedHashMap<>();
+        List<LastlegOrderMapper.PalletMergeRelationRow> rows = orderMapper.findPalletMergeRelations(
+            orders.stream().map(LastlegOrder::getId).toList());
+        if (rows == null) return Map.of();
+        for (LastlegOrderMapper.PalletMergeRelationRow row : rows) {
+            result.computeIfAbsent(row.orderId(), ignored -> new ArrayList<>()).add(row);
+        }
+        return result;
+    }
+
+    private LastlegOrderSummary summary(LastlegOrder o, List<LastlegOrderMapper.PalletMergeRelationRow> relations) {
+        List<LastlegOrderMapper.PalletMergeRelationRow> related = relations == null ? List.of() : relations;
         return new LastlegOrderSummary(o.getId(), o.getOrderNo(), o.getOrderType(),
             LastlegOrderType.labelOf(o.getOrderType()), o.getDestinationType(), o.getSourceInboundId(),
             o.getInboundCode(), o.getSourceOrderNo(), o.getCustomerId(), o.getCustomerName(), o.getOverseasWarehouseId(),
@@ -233,7 +438,9 @@ public class LastlegOrderService {
             o.getAbnormal(), o.getDetained(), o.getPalletCount(), o.getPackageCount(), o.getVolumeCbm(),
             o.getProductQuantity(), o.getVolumeWeightKg(), o.getEstimatedArrivalAt(), o.getActualArrivalAt(),
             o.getEstimatedWarehouseAt(), o.getInboundOrderNo(), o.getRelabelOrderNo(), o.getRelabelStatus(),
-            o.getPalletMergeFlag(), o.getCurrentStatus(), o.getSubOrderStatus(), o.getPrivateRemark(),
+            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());
     }
 

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

@@ -82,8 +82,8 @@ public class LoadingCompletedConsumer {
         // The loading-plan and container-shipping events are independent aggregate streams.
         // Seeding the shipping version from the loading-plan version makes a valid first node
         // (aggregateVersion=0) look stale whenever the loading plan has a higher version.
-        String orderNo = orderNoGenerator.next();
         JsonNode rawOrders = envelope.payload().path("orders");
+        String orderNo = orderNoGenerator.forContainerNo(payload.containerNo());
         for (int index = 0; index < payload.orders().size(); index++) {
             var source = payload.orders().get(index);
             JsonNode rawSource = rawOrders.isArray() && index < rawOrders.size() ? rawOrders.get(index) : objectMapper.createObjectNode();
@@ -216,7 +216,9 @@ public class LoadingCompletedConsumer {
         order.setOverseasWarehouseId(null); order.setOverseasWarehouseName(null);
         order.setFbaWarehouseCode(source.destinationWarehouseCode()); order.setContainerNo(containerNo);
         order.setContainerStatus("待转柜"); order.setAbnormal(false); order.setDetained(false);
-        order.setPackageCount(source.packageCount()); order.setPalletCount(dropshipPallets.size());
+        order.setPackageCount(source.packageCount());
+        order.setPalletCount("ONE_CLICK_DROPSHIP".equals(orderType)
+            ? dropshipPallets.size() : Objects.requireNonNullElse(source.palletCount(), 0));
         order.setProductQuantity(source.productQuantity()); order.setVolumeCbm(source.volumeCbm());
         order.setEstimatedWarehouseAt(parsePlannedArrival(payload.estimatedWarehouseArrivalAt()));
         order.setVolumeWeightKg(source.items().stream().map(FirstLegLoadingPlanCompletedV1.Item::dimensionalWeightKg)