优化

firstleg/AGENTS.md

@@ -88,7 +88,7 @@
 - 新增模拟柜只保存智能装柜的 9 类计划渠道 channel_group_code；未关联已放舱订舱时 channel_code/channel_name 为空，关联后才冻结订舱的实际渠道。智能装柜全局工作台和订舱关联候选均按计划渠道组匹配；服务端把业务渠道分组映射为实际渠道，并分别分页查询候选与 `WAIT_LOADING/EDITING/LOADING` 柜次；候选支持按创建日期和预计到货日期闭区间筛选，状态筛选使用最多四项的 `orderStatuses`，未传表示 `PENDING_REVIEW/WAIT_MEASURE/WAIT_SPLIT/LOADING` 全部未完成状态。状态只用于搜索和展示，能否加入以响应 `canAssign` 为准，由有效柜次占用、剩余箱数、容量、组锁和版本等事实决定；人工加入允许订单国内仓及渠道与柜次不同，智能推荐允许跨国内仓但仍只选择柜次渠道。容积和重量均允许达到柜型额定值的 150%，超过即拒绝。待审核事实必须经 `PendingReviewOrderClient` 重新核验 Order 权威 `SUBMITTED` 订单，待审核或待测量可先占位，但确认预装和启动 PDA 前仍必须进入 `WAIT_SPLIT`。计划明细通过 `totalPackageCount/remainingPackageCount` 返回可调总量和余量：测量前取 Order 原始申报箱数，进入 `WAIT_SPLIT/LOADING` 后取最新已审核测量箱数；只读补充失败时保守回退当前已分配数，调整写入仍重新查询并校验权威数量。同柜不可拆组只有全部成员命中状态集合时才返回，且必须成员完整、满箱并作为单个分页与分配单元，不能跨页或拆分。一次性移除未拣明细时，普通未拣项直接移除；同柜组仅全组未拣时整组移除，任一成员已拣则整组保留，单事务只递增一次计划版本。推荐顺序按入库时间先进先出。装柜计划状态为 `EDITING -> LOADING -> COMPLETED`，PDA 全部明细处理完成后自动完成。
 - 预装进入 `CONFIRMING/CONFIRMED` 只固化确认快照，不得锁死尚未完成柜次的智能装柜分配；装柜计划仍处于 `EDITING/LOADING` 时可继续新增，未产生实物拣货的明细可调整或移除，已拣明细保持锁定。
 - 客户入库费用只在登录客户范围、测量审核通过、`feeStatus=SENT` 且存在已发布明细时可见；确认必须具备 `merchant:order:edit`，携带当前 `expectedFeeVersion` 与幂等键。成功后记录确认成员和时间；客户未确认或该票尚未装柜完成时，平台仍可修改箱规规则、生成新费用版本并重新发送，新版本必须清空旧版客户确认快照。仅当“客户已确认且该票已装柜完成”同时成立时最终冻结；装柜完成不得代替客户自动确认。旧版本、未发送或重复异参确认均返回冲突，不做兼容覆盖。
-- PDA 拣货以 `fl_inbound_carton_label.box_code` 对应的稳定箱唛箱码为扫描身份；审核建单、重复打印、手工测量和墨家测量复用同一映射，版本字段只用于并发控制，不进入扫码文本。一个有效且未重复的箱码扫描表示拣出一箱，不得以 SKU、商品件数或页面展示字段替代箱码。装柜允许跨国内仓，仓库与渠道限制统一由上游装柜编排负责；PDA 只按已生成任务读取各入仓单自身的 `CONFIRMED` 库位资源，不得再用柜次仓库过滤任务明细、库存快照或拣货写入。任务下发与提交契约见 `src/main/resources/openapi/phase3-pda-convergence-v1.yaml`。
+- PDA 拣货以 `fl_inbound_carton_label.box_code` 对应的稳定箱唛箱码为扫描身份；审核建单、重复打印、手工测量和墨家测量复用同一映射，版本字段只用于并发控制，不进入扫码文本。一个有效且未重复的箱码扫描表示拣出一箱，不得以 SKU、商品件数或页面展示字段替代箱码。PDA 首页从 Warehouse 主档选择启用国内仓，一件代发与装柜待办列表必须按所选 `warehouseId` 服务端过滤；装柜任务内部仍允许跨国内仓，仓库与渠道限制统一由上游装柜编排负责，PDA 只按已生成任务读取各入仓单自身的 `CONFIRMED` 库位资源，不得再用柜次仓库过滤任务明细、库存快照或拣货写入。任务下发与提交契约见 `src/main/resources/openapi/phase3-pda-convergence-v1.yaml`。
 - PDA 部分拣货生成二级子入库单时，数量必须守恒：`已拣数量 + 子单数量 = 拣货前主单可用数量`。子单只允许一层，不能继续拆分。
 - 首张称重图片确认时按 `max(已确认称重图片数, ceil(有效体积 / 默认托盘容量))` 尽力预留并确认整票库位块；有效体积先取入库单已落地的正数实测体积，否则对最新测量批次的正数 `totalVolumeCbm/originalVolumeCbm` 取较大值，再无有效值才查询 Order 最新客户申报体积，全部无效则拒绝。后续确认绑定最小空槽，所需槽数增长时通过 Warehouse `/blocks/expand` 原子追加，既有 `blockId/slotNo/reservationId/locationId/sharedOverflow` 不得变化。库位指引失败只记录警告，不阻断称重确认；测量提交后以最新已确认图片调用 `ensureForSubmission` 再次补齐和校验，失败同样不回滚已提交的测量主流程。Firstleg 必须显式保存 `weightResultId -> blockId/slotNo/reservationId/locationId/locationCode`，按 `confirmedAt + weightResultId` 稳定顺序绑定，禁止按列表下标推断；普通连续位不足的新增槽由 Warehouse 放入共享 A0，不阻断确认。
 - 删除称重图片只解除图片和托盘快照绑定，将槽位恢复为 `RESERVED_EMPTY`；槽位和整票块继续归当前入仓码。解绑失败时不得调用文件删除，文件删除失败时本地解绑和重量结果删除必须回滚。

firstleg/src/main/java/com/baiyue/firstleg/client/WarehouseMasterDataClient.java

@@ -6,6 +6,8 @@ import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestHeader;
 
+import java.util.List;
+
 /** 获取平台仓库主数据，供虚拟柜校验国内中转仓使用。 */
 @FeignClient(name = "warehouse-service", contextId = "firstlegWarehouseMasterDataClient",
     url = "${baiyue.clients.warehouse.url:}", path = "/internal/warehouses")
@@ -15,10 +17,17 @@ public interface WarehouseMasterDataClient {
                                @PathVariable long tenantId,
                                @PathVariable long warehouseId);
 
+    @GetMapping("/domestic")
+    ApiResponse<List<WarehouseOption>> domestic(
+        @RequestHeader("X-Internal-Service-Token") String token);
+
     record Detail(Warehouse warehouse) {
     }
 
     record Warehouse(Long id, Long tenantId, String warehouseCode, String internalCode, String warehouseName,
                      String warehouseType, String status) {
     }
+
+    record WarehouseOption(Long id, String warehouseCode, String warehouseName) {
+    }
 }

firstleg/src/main/java/com/baiyue/firstleg/controller/PlatformDropshipPalletizationController.java

@@ -39,9 +39,10 @@ public class PlatformDropshipPalletizationController {
     @PreAuthorize("hasAuthority('platform:firstleg:pda:view')")
     public ApiResponse<List<DropshipPalletizationDtos.PendingTask>> pending(
         @AuthenticationPrincipal AuthenticatedUser user,
+        @RequestParam @Positive long warehouseId,
         @RequestParam(required = false) @Size(max = 64) String keyword) {
         FirstlegScopeGuard.platform(user);
-        return ApiResponse.success(service.pending(user.userId(), keyword));
+        return ApiResponse.success(service.pending(user.userId(), warehouseId, keyword));
     }
 
     @GetMapping("/tasks/{taskId}")
@@ -121,6 +122,21 @@ public class PlatformDropshipPalletizationController {
         return ApiResponse.success(service.seal(taskId, palletId, request, user.userId(), user.username()));
     }
 
+    @GetMapping("/tasks/{taskId}/pallets/{palletId}/print")
+    @PreAuthorize("hasAuthority('platform:firstleg:pda:view')")
+    public ResponseEntity<byte[]> printTaskPallet(@AuthenticationPrincipal AuthenticatedUser user,
+                                                  @PathVariable @Positive long taskId,
+                                                  @PathVariable @Positive long palletId,
+                                                  @RequestParam @Positive long warehouseId,
+                                                  @RequestHeader(value = "X-Request-Id", required = false) String requestId) {
+        FirstlegScopeGuard.platform(user);
+        Pallet pallet = service.task(taskId, warehouseId, user.userId()).pallets().stream()
+            .filter(item -> item.palletId() == palletId).findFirst()
+            .orElseThrow(() -> new com.baiyue.common.core.exception.BizException(
+                com.baiyue.common.core.api.ResultCode.NOT_FOUND, "托盘不存在"));
+        return printService.generateDropshipPallet(pallet, requestId);
+    }
+
     @GetMapping("/inbound-orders/{inboundId}/pallets")
     @PreAuthorize("hasAuthority('firstleg:inbound:list')")
     public ApiResponse<List<Pallet>> inboundPallets(@AuthenticationPrincipal AuthenticatedUser user,

firstleg/src/main/java/com/baiyue/firstleg/controller/PlatformLoadingPdaController.java

@@ -20,6 +20,8 @@ import java.util.List;
 import com.baiyue.firstleg.dto.LoadingPickDtos.Task;
 import com.baiyue.firstleg.service.FirstlegScopeGuard;
 import com.baiyue.firstleg.service.LoadingPickService;
+import com.baiyue.firstleg.service.PdaWarehouseCatalogService;
+import com.baiyue.firstleg.client.WarehouseMasterDataClient.WarehouseOption;
 import com.baiyue.firstleg.loading.service.CabinetLoadingEvidenceService;
 import org.springframework.http.ResponseEntity;
 import org.springframework.http.MediaType;
@@ -51,6 +53,8 @@ public class PlatformLoadingPdaController {
     @Resource
     private LoadingPickService service;
     @Resource
+    private PdaWarehouseCatalogService warehouseCatalog;
+    @Resource
     private CabinetLoadingEvidenceService evidenceService;
 
     @GetMapping("/tasks")
@@ -66,10 +70,18 @@ public class PlatformLoadingPdaController {
     @GetMapping("/tasks/pending")
     @PreAuthorize("hasAuthority('platform:firstleg:pda:view')")
     public ApiResponse<List<PendingTask>> pendingTasks(@AuthenticationPrincipal AuthenticatedUser user,
+                                                       @RequestParam @Positive long warehouseId,
                                                        @RequestParam(required = false)
                                                        @Size(max = 64) String keyword) {
         FirstlegScopeGuard.platform(user);
-        return ApiResponse.success(service.pendingTasks(user.userId(), keyword));
+        return ApiResponse.success(service.pendingTasks(user.userId(), warehouseId, keyword));
+    }
+
+    @GetMapping("/warehouses")
+    @PreAuthorize("hasAuthority('platform:firstleg:pda:view')")
+    public ApiResponse<List<WarehouseOption>> warehouses(@AuthenticationPrincipal AuthenticatedUser user) {
+        FirstlegScopeGuard.platform(user);
+        return ApiResponse.success(warehouseCatalog.activeDomesticWarehouses());
     }
 
     @GetMapping("/tasks/{taskId}")

firstleg/src/main/java/com/baiyue/firstleg/mapper/DropshipPalletizationMapper.java

@@ -30,10 +30,12 @@ public interface DropshipPalletizationMapper {
   o.warehouse_name,t.total_cartons,t.counted_cartons,t.allocated_cartons bound_cartons,
   t.counted_cartons-t.allocated_cartons unbound_cartons,t.discrepancy_cartons,t.task_status,t.created_at
   FROM fl_dropship_pallet_task t JOIN fl_inbound_order o ON o.id=t.inbound_id AND o.tenant_id=t.tenant_id
-  WHERE t.task_status IN ('PENDING','CLAIMED') AND (t.assignee_id IS NULL OR t.assignee_id=#{operatorId})
+  WHERE t.task_status IN ('PENDING','CLAIMED') AND t.warehouse_id=#{warehouseId}
+  AND (t.assignee_id IS NULL OR t.assignee_id=#{operatorId})
   AND (#{keyword} IS NULL OR o.inbound_code LIKE CONCAT('%',#{keyword},'%') OR o.customer_name LIKE CONCAT('%',#{keyword},'%'))
   ORDER BY t.created_at,t.id""")
- List<PendingTask> pending(@Param("operatorId") long operatorId,@Param("keyword") String keyword);
+ List<PendingTask> pending(@Param("operatorId") long operatorId,@Param("warehouseId") long warehouseId,
+                           @Param("keyword") String keyword);
 
  @Select("""
   SELECT t.*,o.inbound_code,o.customer_name,o.warehouse_name,o.process_status,o.fulfillment_type

firstleg/src/main/java/com/baiyue/firstleg/mapper/LoadingPickTaskMapper.java

@@ -100,6 +100,7 @@ public interface LoadingPickTaskMapper extends BaseMapper<LoadingPickTaskEntity>
           JOIN fl_loading_pick_item pick_item ON pick_item.pick_task_id = task.id
           LEFT JOIN fl_loading_pick_assignment assignment ON assignment.pick_task_id = task.id
          WHERE task.task_status IN ('LOADING','COMPLETING','COMPLETION_FAILED') AND booking.record_status = 'ACTIVE'
+           AND booking.warehouse_id = #{warehouseId}
            AND (assignment.pick_task_id IS NULL OR assignment.assignee_id = #{operatorId})
            <if test="keyword != null and keyword != ''">
              AND (booking.container_no LIKE CONCAT('%', #{keyword}, '%')
@@ -115,6 +116,7 @@ public interface LoadingPickTaskMapper extends BaseMapper<LoadingPickTaskEntity>
         </script>
         """)
     List<PendingTaskRow> selectPendingForOperator(@Param("operatorId") long operatorId,
+                                                   @Param("warehouseId") long warehouseId,
                                                    @Param("keyword") String keyword);
 
     class PendingTaskRow {

firstleg/src/main/java/com/baiyue/firstleg/repository/LoadingPickRepository.java

@@ -90,8 +90,8 @@ public class LoadingPickRepository {
         return tasks.selectLoadingByPlan(loadingPlanId, warehouseId);
     }
 
-    public List<PendingTaskRow> pendingTasks(long operatorId, String keyword) {
-        return tasks.selectPendingForOperator(operatorId, keyword);
+    public List<PendingTaskRow> pendingTasks(long operatorId, long warehouseId, String keyword) {
+        return tasks.selectPendingForOperator(operatorId, warehouseId, keyword);
     }
 
     public ContainerBookingEntity activeBookingByTask(long taskId) {

firstleg/src/main/java/com/baiyue/firstleg/service/DropshipPalletizationService.java

@@ -36,6 +36,7 @@ public class DropshipPalletizationService {
    return view(task);
   }
   if(!"CLAIMED".equals(task.getTaskStatus())||!"WAIT_PALLETIZE".equals(task.getProcessStatus())) throw conflict("当前任务不允许创建托盘");
+  if(!Objects.equals(task.getCountedCartons(),task.getTotalCartons())) throw conflict("请先完成全部箱码清点，再生成托盘码");
   int expected=mapper.unboundCount(taskId);
   if(expected==0) throw conflict("当前没有待绑托箱，请先清点箱码");
   long palletId=IdWorker.getId();
@@ -43,6 +44,10 @@ public class DropshipPalletizationService {
   mapper.insertPallet(palletId,taskId,task.getTenantId(),task.getInboundId(),task.getWarehouseId(),palletNo,operation,operatorId,operatorName);
   int bound=mapper.bindPending(taskId,palletId,operation,operatorId,operatorName);
   if(bound!=expected||mapper.adjustBound(taskId,operatorId,bound)!=1) throw conflict("待绑托箱已变化，请刷新后重试");
+  if(mapper.seal(taskId,palletId,1,request.warehouseId(),operation,operatorId,operatorName)!=1)
+   throw conflict("托盘完成状态已变化，请刷新后重试");
+  if(mapper.completeTask(taskId)!=1 || mapper.completeInbound(taskId,task.getTenantId(),task.getInboundId(),operatorId)!=1)
+   throw conflict("一件代发入库完成状态已变化，请刷新后重试");
   return view(requireTask(taskId,request.warehouseId()));
  }
 
@@ -52,7 +57,7 @@ public class DropshipPalletizationService {
   mapper.insertTask(IdWorker.getId(),inbound.getTenantId(),inbound.getId(),inbound.getWarehouseId(),inbound.getTotalPackageCount());
  }
 
- public List<PendingTask> pending(long operatorId,String keyword){ return mapper.pending(operatorId,normalize(keyword)); }
+ public List<PendingTask> pending(long operatorId,long warehouseId,String keyword){ return mapper.pending(operatorId,warehouseId,normalize(keyword)); }
 
  @Transactional
  public Task claim(long taskId,long warehouseId,long operatorId,String operatorName){
@@ -99,8 +104,8 @@ public class DropshipPalletizationService {
   if(!mismatch && request.discrepancyAction()!=DiscrepancyAction.MATCH) throw invalid("实收数量一致时差异动作必须为 MATCH");
   if(mismatch && request.discrepancyAction()!=DiscrepancyAction.ACCEPT_VARIANCE) throw conflict("实收数量存在差异，请确认差异处理结果");
   if(mismatch && !StringUtils.hasText(remark)) throw invalid("接受数量差异时必须填写处理说明");
-  PalletRow pallet=StringUtils.hasText(request.palletNo())
-   ? getOrCreatePallet(task,request.palletNo().trim(),operation,operatorId,operatorName):null;
+  if(StringUtils.hasText(request.palletNo())) throw invalid("逐箱清点阶段不能提前绑定托盘码");
+  PalletRow pallet=null;
   long cartonId=IdWorker.getId();
   mapper.insertCarton(cartonId,taskId,pallet==null?null:pallet.getId(),task.getTenantId(),task.getInboundId(),
    label.getInboundDetailId(),label.getCartonLabelId(),label.getSkuCode(),label.getCargoName(),label.getBoxCode(),
@@ -113,6 +118,7 @@ public class DropshipPalletizationService {
  @Transactional
  public Task bindPending(long taskId,BindPendingRequest request,long operatorId,String operatorName){
   TaskRow task=requireWorkingTask(taskId,request.warehouseId(),operatorId);
+  if(!Objects.equals(task.getCountedCartons(),task.getTotalCartons())) throw conflict("请先完成全部箱码清点，再绑定托盘码");
   String operation=operation(request.operationId());
   if(mapper.bindOperationCount(taskId,operation)>0) return view(requireTask(taskId,request.warehouseId()));
   PalletRow pallet=getOrCreatePallet(task,request.palletNo().trim(),operation,operatorId,operatorName);

firstleg/src/main/java/com/baiyue/firstleg/service/InboundCartonLabelPrintService.java

@@ -115,7 +115,8 @@ public class InboundCartonLabelPrintService {
 
     /** 一件代发托盘标签：托盘号、入仓码、SKU箱数和托盘二维码。 */
     public ResponseEntity<byte[]> generateDropshipPallet(Pallet pallet, String requestId) {
-        if (pallet == null || !StringUtils.hasText(pallet.palletNo()) || pallet.items().isEmpty()) {
+        if (pallet == null || !"SEALED".equals(pallet.status())
+            || !StringUtils.hasText(pallet.palletNo()) || pallet.items().isEmpty()) {
             throw new BizException(ResultCode.CONFLICT, "只有已完成且包含货物的一件代发托盘可以打印");
         }
         String inboundCodes = pallet.items().stream().map(item -> item.inboundCode())

firstleg/src/main/java/com/baiyue/firstleg/service/LoadingPickService.java

@@ -233,9 +233,9 @@ public class LoadingPickService {
         return view(requiredTask(taskId), warehouseId);
     }
 
-    public List<PendingTask> pendingTasks(long operatorId, String keyword) {
+    public List<PendingTask> pendingTasks(long operatorId, long warehouseId, String keyword) {
         String normalizedKeyword = StringUtils.hasText(keyword) ? keyword.trim() : null;
-        return repository.pendingTasks(operatorId, normalizedKeyword).stream()
+        return repository.pendingTasks(operatorId, warehouseId, normalizedKeyword).stream()
             .map(row -> new PendingTask(row.getTaskId(), row.getLoadingPlanId(), row.getContainerBookingId(),
                 row.getCabinetNo(), row.getContainerNo(),
                 row.getSourceType(), row.getRecordStatus(), row.getMergedIntoContainerBookingId(),

firstleg/src/main/java/com/baiyue/firstleg/service/PdaWarehouseCatalogService.java

@@ -0,0 +1,37 @@
+package com.baiyue.firstleg.service;
+
+import com.baiyue.common.core.api.ApiResponse;
+import com.baiyue.common.core.api.ResultCode;
+import com.baiyue.common.core.exception.BizException;
+import com.baiyue.firstleg.client.WarehouseMasterDataClient;
+import com.baiyue.firstleg.client.WarehouseMasterDataClient.WarehouseOption;
+import jakarta.annotation.Resource;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/** 为国内 PDA 提供启用中的国内仓选择项，主档仍由 Warehouse Service 唯一维护。 */
+@Service
+public class PdaWarehouseCatalogService {
+    @Resource private WarehouseMasterDataClient warehouses;
+    @Value("${baiyue.security.internal-service-token:}") private String internalToken;
+
+    public List<WarehouseOption> activeDomesticWarehouses() {
+        try {
+            ApiResponse<List<WarehouseOption>> response = warehouses.domestic(internalToken);
+            if (response == null || !response.successful() || response.data() == null) {
+                throw unavailable();
+            }
+            return response.data();
+        } catch (BizException exception) {
+            throw exception;
+        } catch (RuntimeException exception) {
+            throw unavailable();
+        }
+    }
+
+    private static BizException unavailable() {
+        return new BizException(ResultCode.SERVICE_UNAVAILABLE, "国内仓目录暂时不可用，请稍后重试");
+    }
+}

firstleg/src/main/resources/openapi/dropship-palletization-v1.yaml

@@ -2,12 +2,13 @@ openapi: 3.0.3
 info:
   title: 一件代发国内清点组托 API
   version: 2.0.0
-  description: 测量、计费后独立下发。箱码逐箱确认 SKU 实收数量；托盘码可先扫或后扫，封托后作为不可拆分柜单元。
+  description: 测量、计费后独立下发。先逐箱确认 SKU 实收数量；全部箱码清点完成后才原子生成、绑定并封存正式 DP 托盘码，随后可打印托盘标签。
 paths:
   /api/platform/v1/first-leg/pda-dropship/tasks/pending:
     get:
       summary: 查询待领取或本人已领取任务
       x-required-authority: platform:firstleg:pda:view
+      parameters: [{$ref: '#/components/parameters/WarehouseId'}, {name: keyword, in: query, required: false, schema: {type: string, maxLength: 64}}]
       responses: {'200': {description: OK}}
   /api/platform/v1/first-leg/pda-dropship/tasks/{taskId}:
     get:
@@ -33,8 +34,8 @@ paths:
       responses: {'200': {description: OK}}
   /api/platform/v1/first-leg/pda-dropship/tasks/{taskId}/cartons/count:
     post:
-      summary: 逐箱确认 SKU 实收数量，可同时绑定当前托盘
-      description: palletNo 为空时进入 COUNTED_UNBOUND；不为空时幂等获取或创建 OPEN 托盘并绑定。数量不一致必须 ACCEPT_VARIANCE 且填写说明。
+      summary: 逐箱确认 SKU 实收数量
+      description: 清点阶段只记录箱级实收并进入 COUNTED_UNBOUND，不得提前生成或绑定托盘码。数量不一致必须 ACCEPT_VARIANCE 且填写说明。
       x-required-authority: platform:firstleg:pda:work
       parameters: [{$ref: '#/components/parameters/TaskId'}]
       requestBody: {required: true, content: {application/json: {schema: {$ref: '#/components/schemas/CountCartonRequest'}}}}
@@ -48,8 +49,8 @@ paths:
       responses: {'200': {description: OK}}
   /api/platform/v1/first-leg/pda-dropship/tasks/{taskId}/pallets/create-and-bind:
     post:
-      summary: 系统生成 DP 托盘码并原子绑定全部待绑箱
-      description: 仅当前仓库本人已领取的待组托任务可执行。没有待绑箱时不发码、不建空托。operationId 在同任务和仓库重放不重复创建；不同任务使用同幂等号拒绝。返回当前 Task。
+      summary: 完成一件代发入库并生成正式 DP 托盘码
+      description: 仅全部箱码已经清点的本人任务可执行；同一事务内生成 DP 托盘码、绑定全部箱、封托并把入仓单推进到待分柜。未完成清点或没有待绑箱时不发码、不建空托。operationId 重放不重复创建；返回已完成 Task。
       x-required-authority: platform:firstleg:pda:work
       parameters: [{$ref: '#/components/parameters/TaskId'}]
       requestBody: {required: true, content: {application/json: {schema: {$ref: '#/components/schemas/CreateAndBindRequest'}}}}
@@ -72,6 +73,17 @@ paths:
         - {name: palletId, in: path, required: true, schema: {type: integer, format: int64}}
       requestBody: {required: true, content: {application/json: {schema: {$ref: '#/components/schemas/SealPalletRequest'}}}}
       responses: {'200': {description: OK}}
+  /api/platform/v1/first-leg/pda-dropship/tasks/{taskId}/pallets/{palletId}/print:
+    get:
+      summary: PDA 打印已封托的一件代发托盘码
+      description: 仅当前仓库、当前操作员可访问；未封托托盘拒绝打印。返回 100mm × 100mm PDF。
+      x-required-authority: platform:firstleg:pda:view
+      parameters:
+        - {$ref: '#/components/parameters/TaskId'}
+        - {name: palletId, in: path, required: true, schema: {type: integer, format: int64}}
+        - {$ref: '#/components/parameters/WarehouseId'}
+      responses:
+        '200': {description: 托盘码 PDF, content: {application/pdf: {schema: {type: string, format: binary}}}}
   /api/platform/v1/first-leg/pda-dropship/inbound-orders/{inboundId}/pallets:
     get:
       summary: Admin 查询入仓单权威托盘结果
@@ -134,7 +146,6 @@ components:
         actualSkuQuantity: {type: integer, minimum: 1}
         discrepancyAction: {type: string, enum: [MATCH, ACCEPT_VARIANCE]}
         discrepancyRemark: {type: string, maxLength: 500, nullable: true}
-        palletNo: {$ref: '#/components/schemas/NullablePalletNo'}
         operationId: {type: string, maxLength: 128}
     BindPendingRequest:
       type: object

firstleg/src/main/resources/openapi/phase3-pda-convergence-v1.yaml

@@ -3,6 +3,17 @@ info:
   title: Phase 3 Container PDA Picking API
   version: 1.0.0
 paths:
+  /api/platform/v1/first-leg/pda-loading/warehouses:
+    get:
+      summary: List active domestic warehouses available to the PDA operator
+      responses:
+        '200':
+          description: Warehouse master-data options used to scope PDA pending-task lists
+          content:
+            application/json:
+              schema:
+                type: array
+                items: {$ref: '#/components/schemas/WarehouseOption'}
   /api/platform/v1/first-leg/pda-loading/tasks:
     get:
       summary: Find the active container picking task in one platform warehouse
@@ -18,6 +29,7 @@ paths:
     get:
       summary: List active tasks available to the authenticated PDA operator
       parameters:
+        - {name: warehouseId, in: query, required: true, schema: {type: integer, format: int64, minimum: 1}}
         - {name: keyword, in: query, required: false, schema: {type: string, maxLength: 64}}
       responses:
         '200':
@@ -175,6 +187,13 @@ components:
     TaskId: {name: taskId, in: path, required: true, schema: {type: integer, format: int64, minimum: 1}}
     ItemId: {name: itemId, in: path, required: true, schema: {type: integer, format: int64, minimum: 1}}
   schemas:
+    WarehouseOption:
+      type: object
+      required: [id, warehouseCode, warehouseName]
+      properties:
+        id: {type: integer, format: int64}
+        warehouseCode: {type: string}
+        warehouseName: {type: string}
     Task:
       type: object
       required: [id, loadingPlanId, containerBookingId, inboundId, inboundVersion, loadingVersion, cabinetNo, sourceType, recordStatus, taskStatus, workflowStatus, version, items]

firstleg/src/test/java/com/baiyue/firstleg/repository/DropshipPalletizationSqlContractTest.java

@@ -1,6 +1,8 @@
 package com.baiyue.firstleg.repository;
 
 import org.junit.jupiter.api.Test;
+import org.apache.ibatis.annotations.Select;
+import com.baiyue.firstleg.mapper.DropshipPalletizationMapper;
 import org.springframework.core.io.ClassPathResource;
 
 import java.nio.charset.StandardCharsets;
@@ -10,6 +12,17 @@ import java.nio.file.Path;
 import static org.assertj.core.api.Assertions.assertThat;
 
 class DropshipPalletizationSqlContractTest {
+    @Test
+    void pendingPdaTasksAreScopedByTheSelectedWarehouse() throws Exception {
+        String sql = DropshipPalletizationMapper.class
+            .getDeclaredMethod("pending", long.class, long.class, String.class)
+            .getAnnotation(Select.class).value()[0];
+
+        assertThat(sql)
+            .contains("t.warehouse_id=#{warehouseId}")
+            .contains("t.assignee_id IS NULL OR t.assignee_id=#{operatorId}");
+    }
+
     @Test
     void moduleAndUnifiedSchemasExposeCountingPalletAndWholePalletAssignmentFacts() throws Exception {
         String inbound = new ClassPathResource("db/phase2-inbound-schema.sql")

firstleg/src/test/java/com/baiyue/firstleg/repository/LoadingPickPdaTaskSqlContractTest.java

@@ -37,12 +37,13 @@ class LoadingPickPdaTaskSqlContractTest {
     @Test
     void pendingTasksAreLimitedToUnassignedOrCurrentOperatorWithoutCustomerInput() throws Exception {
         String sql = LoadingPickTaskMapper.class
-            .getDeclaredMethod("selectPendingForOperator", long.class, String.class)
+            .getDeclaredMethod("selectPendingForOperator", long.class, long.class, String.class)
             .getAnnotation(Select.class).value()[0];
 
         assertThat(sql)
             .contains("task.task_status IN ('LOADING','COMPLETING','COMPLETION_FAILED')")
             .contains("booking.record_status = 'ACTIVE'")
+            .contains("booking.warehouse_id = #{warehouseId}")
             .contains("booking.source_type AS sourceType")
             .contains("booking.record_status AS recordStatus")
             .contains("booking.merged_into_container_booking_id AS mergedIntoContainerBookingId")

firstleg/src/test/java/com/baiyue/firstleg/service/DropshipPalletizationServiceTest.java

@@ -22,18 +22,27 @@ class DropshipPalletizationServiceTest {
 
  DropshipPalletizationServiceTest(){ ReflectionTestUtils.setField(service,"mapper",mapper); ReflectionTestUtils.setField(service,"documentNumbers",numbers); }
 
- @Test void generatesAndBindsOnlyWhenPendingCartonsExist(){
-  when(mapper.lockTask(10L,100L)).thenReturn(10L); when(mapper.task(10L,100L)).thenReturn(task());
+ @Test void generatesBindsSealsAndCompletesOnlyAfterEveryCartonIsCounted(){
+  when(mapper.lockTask(10L,100L)).thenReturn(10L); when(mapper.task(10L,100L)).thenReturn(readyToComplete());
   when(mapper.unboundCount(10L)).thenReturn(2); when(numbers.next("DP")).thenReturn("DP-260909-0001");
   when(mapper.bindPending(eq(10L),anyLong(),eq("create-1"),eq(7L),eq("张三"))).thenReturn(2);
   when(mapper.adjustBound(10L,7L,2)).thenReturn(1);
+  when(mapper.seal(eq(10L),anyLong(),eq(1),eq(100L),eq("create-1"),eq(7L),eq("张三"))).thenReturn(1);
+  when(mapper.completeTask(10L)).thenReturn(1); when(mapper.completeInbound(10L,1L,30L,7L)).thenReturn(1);
   service.createAndBind(10L,new com.baiyue.firstleg.dto.DropshipPalletizationDtos.CreateAndBindRequest(100L,"create-1"),7L,"张三");
   verify(mapper).insertPallet(anyLong(),eq(10L),eq(1L),eq(30L),eq(100L),eq("DP-260909-0001"),eq("create-1"),eq(7L),eq("张三"));
   verify(numbers,times(1)).next("DP");
  }
 
- @Test void noPendingCartonsNeverAllocatesNumberOrEmptyPallet(){
+ @Test void incompleteCountingNeverAllocatesAPalletNumber(){
   when(mapper.lockTask(10L,100L)).thenReturn(10L); when(mapper.task(10L,100L)).thenReturn(task());
+  assertThatThrownBy(()->service.createAndBind(10L,new com.baiyue.firstleg.dto.DropshipPalletizationDtos.CreateAndBindRequest(100L,"early"),7L,"张三"))
+   .hasMessageContaining("完成全部箱码清点");
+  verifyNoInteractions(numbers);
+ }
+
+ @Test void noPendingCartonsNeverAllocatesNumberOrEmptyPallet(){
+  when(mapper.lockTask(10L,100L)).thenReturn(10L); when(mapper.task(10L,100L)).thenReturn(readyToComplete());
   assertThatThrownBy(()->service.createAndBind(10L,new com.baiyue.firstleg.dto.DropshipPalletizationDtos.CreateAndBindRequest(100L,"empty"),7L,"张三")).hasMessageContaining("没有待绑托箱");
   verifyNoInteractions(numbers);
   verify(mapper,never()).insertPallet(anyLong(),anyLong(),anyLong(),anyLong(),anyLong(),anyString(),anyString(),anyLong(),anyString());
@@ -48,7 +57,7 @@ class DropshipPalletizationServiceTest {
  }
 
  @Test void rejectsOtherOperatorAndCrossTaskReplay(){
-  when(mapper.lockTask(10L,100L)).thenReturn(10L); when(mapper.task(10L,100L)).thenReturn(task());
+  when(mapper.lockTask(10L,100L)).thenReturn(10L); when(mapper.task(10L,100L)).thenReturn(readyToComplete());
   var request=new com.baiyue.firstleg.dto.DropshipPalletizationDtos.CreateAndBindRequest(100L,"replay");
   assertThatThrownBy(()->service.createAndBind(10L,request,8L,"李四")).hasMessageContaining("当前操作员");
   PalletRow other=pallet(); other.setTaskId(11L); when(mapper.palletByOpenOperation("replay")).thenReturn(other);
@@ -59,7 +68,7 @@ class DropshipPalletizationServiceTest {
  @Test void rejectsUnknownWarehouseAndChangedBindCount(){
   var request=new com.baiyue.firstleg.dto.DropshipPalletizationDtos.CreateAndBindRequest(100L,"new");
   assertThatThrownBy(()->service.createAndBind(10L,request,7L,"张三")).hasMessageContaining("当前仓库");
-  when(mapper.lockTask(10L,100L)).thenReturn(10L); when(mapper.task(10L,100L)).thenReturn(task());
+  when(mapper.lockTask(10L,100L)).thenReturn(10L); when(mapper.task(10L,100L)).thenReturn(readyToComplete());
   when(mapper.unboundCount(10L)).thenReturn(2); when(numbers.next("DP")).thenReturn("DP-260909-0002");
   assertThatThrownBy(()->service.createAndBind(10L,request,7L,"张三")).hasMessageContaining("待绑托箱已变化");
   verify(mapper,never()).adjustBound(anyLong(),anyLong(),anyInt());
@@ -87,23 +96,16 @@ class DropshipPalletizationServiceTest {
   verify(mapper,never()).insertCarton(anyLong(),anyLong(),any(),anyLong(),anyLong(),anyLong(),anyLong(),any(),any(),any(),anyInt(),anyInt(),any(),any(),any(),anyLong(),any());
  }
 
- @Test void countsOneCartonDirectlyIntoScannedPallet(){
-  TaskRow before=task(),after=task(); after.setCountedCartons(1); after.setAllocatedCartons(1);
-  LabelRow label=label(); PalletRow pallet=pallet(); CartonRow carton=carton();
-  when(mapper.task(10L,100L)).thenReturn(before,after);
-  when(mapper.label(10L,"BOX-1")).thenReturn(label); when(mapper.palletByNo("DP-260908-0001")).thenReturn(pallet);
-  when(mapper.addCounted(10L,7L,1,0)).thenReturn(1); when(mapper.carton(eq(10L),anyLong())).thenReturn(carton);
-  when(mapper.pallet(10L,20L,100L)).thenReturn(pallet); when(mapper.cartons(20L)).thenReturn(java.util.List.of(carton));
-  when(mapper.metrics(20L)).thenReturn(new DropshipPalletizationMapper.PalletMetrics(java.math.BigDecimal.ONE,java.math.BigDecimal.TEN));
+ @Test void countingCannotExposeOrBindAPalletNumberEarly(){
+  when(mapper.task(10L,100L)).thenReturn(task()); when(mapper.label(10L,"BOX-1")).thenReturn(label());
   var request=new CountCartonRequest(100L,"BOX-1",12,DiscrepancyAction.MATCH,null,"DP-260908-0001","op-1");
-  var result=service.countCarton(10L,request,7L,"张三");
-  assertThat(result.carton().countStatus()).isEqualTo("BOUND");
-  assertThat(result.pallet().status()).isEqualTo("OPEN");
-  verify(mapper).insertCarton(anyLong(),eq(10L),eq(20L),eq(1L),eq(30L),eq(40L),eq(50L),eq("SKU-1"),
-   eq("货物"),eq("BOX-1"),eq(12),eq(12),eq("MATCH"),isNull(),eq("op-1"),eq(7L),eq("张三"));
+  assertThatThrownBy(()->service.countCarton(10L,request,7L,"张三"))
+   .hasMessageContaining("不能提前绑定托盘码");
+  verify(mapper,never()).insertCarton(anyLong(),anyLong(),any(),anyLong(),anyLong(),anyLong(),anyLong(),any(),any(),any(),anyInt(),anyInt(),any(),any(),any(),anyLong(),any());
  }
 
  private static TaskRow task(){ TaskRow t=new TaskRow();t.setId(10L);t.setTenantId(1L);t.setInboundId(30L);t.setWarehouseId(100L);t.setInboundCode("IN-1");t.setTaskStatus("CLAIMED");t.setAssigneeId(7L);t.setProcessStatus("WAIT_PALLETIZE");t.setTotalCartons(2);t.setCountedCartons(0);t.setAllocatedCartons(0);t.setDiscrepancyCartons(0);t.setVersion(1);return t; }
+ private static TaskRow readyToComplete(){ TaskRow t=task();t.setCountedCartons(2);return t; }
  private static LabelRow label(){LabelRow l=new LabelRow();l.setCartonLabelId(50L);l.setInboundDetailId(40L);l.setSkuCode("SKU-1");l.setCargoName("货物");l.setUnitsPerCarton(12);l.setInboundCode("IN-1");l.setBoxCode("BOX-1");return l;}
  private static PalletRow pallet(){PalletRow p=new PalletRow();p.setId(20L);p.setTaskId(10L);p.setTenantId(1L);p.setInboundId(30L);p.setWarehouseId(100L);p.setPalletNo("DP-260908-0001");p.setPalletStatus("OPEN");p.setVersion(1);return p;}
  private static CartonRow carton(){CartonRow c=new CartonRow();c.setId(60L);c.setTaskId(10L);c.setPalletId(20L);c.setPalletNo("DP-260908-0001");c.setInboundId(30L);c.setInboundDetailId(40L);c.setSkuCode("SKU-1");c.setCargoName("货物");c.setBoxCode("BOX-1");c.setExpectedSkuQuantity(12);c.setActualSkuQuantity(12);c.setDiscrepancyStatus("MATCH");return c;}

firstleg/src/test/java/com/baiyue/firstleg/service/InboundCartonLabelPrintServiceTest.java

@@ -4,6 +4,8 @@ import com.baiyue.common.core.api.ResultCode;
 import com.baiyue.common.core.exception.BizException;
 import com.baiyue.firstleg.client.PrintPdfClient;
 import com.baiyue.firstleg.dto.InboundCartonLabels;
+import com.baiyue.firstleg.dto.DropshipPalletizationDtos.Pallet;
+import com.baiyue.firstleg.dto.DropshipPalletizationDtos.SkuItem;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -35,6 +37,25 @@ class InboundCartonLabelPrintServiceTest {
         ReflectionTestUtils.setField(service, "internalToken", "internal-token");
     }
 
+    @Test
+    void dropshipPalletLabelIsAvailableOnlyAfterSeal() {
+        Pallet open = dropshipPallet("OPEN");
+        assertThatThrownBy(() -> service.generateDropshipPallet(open, "request-open"))
+            .isInstanceOf(BizException.class)
+            .hasMessageContaining("已完成");
+        verifyNoInteractions(print);
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_PDF);
+        when(print.generateInboundMarks(org.mockito.ArgumentMatchers.anyString(),
+            org.mockito.ArgumentMatchers.eq("request-sealed"), org.mockito.ArgumentMatchers.any()))
+            .thenReturn(new ResponseEntity<>(new byte[] {7, 8, 9}, headers,
+                org.springframework.http.HttpStatus.OK));
+
+        ResponseEntity<byte[]> response = service.generateDropshipPallet(dropshipPallet("SEALED"), "request-sealed");
+        assertThat(response.getBody()).containsExactly(7, 8, 9);
+    }
+
     @Test
     void forwardsStableLabelsAndOnlySafePdfHeaders() {
         when(labels.list(10001L, 70001L, List.of(1))).thenReturn(batch());
@@ -159,4 +180,11 @@ class InboundCartonLabelPrintServiceTest {
             "PCHK2608040174", "MCC1", "CTNS:19-1", "洛杉矶普船海卡");
         return new InboundCartonLabels.Batch(70001L, 80001L, "PCHK2608040174", 19, List.of(label));
     }
+
+    private Pallet dropshipPallet(String status) {
+        SkuItem item = new SkuItem(70001L, "PCHK2608040174", 2L,
+            "SKU-1", "音箱", 1, 19, List.of("PCHK2608040174#19-1"));
+        return new Pallet(90001L, "DP-260911-0001", status, 1, 1, 0,
+            BigDecimal.ONE, BigDecimal.ONE, 1, List.of(item), List.of(), null);
+    }
 }

firstleg/src/test/java/com/baiyue/firstleg/service/LoadingPickServiceTest.java

@@ -337,9 +337,9 @@ class LoadingPickServiceTest {
         row.setAssignmentVersion(0);
         row.setItemCount(1);
         row.setPendingItemCount(0);
-        when(repository.pendingTasks(9L, null)).thenReturn(List.of(row));
+        when(repository.pendingTasks(9L, 200001L, null)).thenReturn(List.of(row));
 
-        var result = service.pendingTasks(9L, null).get(0);
+        var result = service.pendingTasks(9L, 200001L, null).get(0);
 
         assertThat(result.sourceType()).isEqualTo("SIMULATION");
         assertThat(result.recordStatus()).isEqualTo("ACTIVE");

firstleg/src/test/java/com/baiyue/firstleg/service/PdaWarehouseCatalogServiceTest.java

@@ -0,0 +1,39 @@
+package com.baiyue.firstleg.service;
+
+import com.baiyue.common.core.api.ApiResponse;
+import com.baiyue.common.core.exception.BizException;
+import com.baiyue.firstleg.client.WarehouseMasterDataClient;
+import org.junit.jupiter.api.Test;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class PdaWarehouseCatalogServiceTest {
+    @Test
+    void returnsDomesticWarehouseMasterDataWithoutHardcodedOptions() {
+        WarehouseMasterDataClient client = mock(WarehouseMasterDataClient.class);
+        PdaWarehouseCatalogService service = new PdaWarehouseCatalogService();
+        ReflectionTestUtils.setField(service, "warehouses", client);
+        ReflectionTestUtils.setField(service, "internalToken", "token");
+        var option = new WarehouseMasterDataClient.WarehouseOption(200001L, "CN-DONGGUAN-01", "东莞仓");
+        when(client.domestic("token")).thenReturn(ApiResponse.success(List.of(option)));
+
+        assertThat(service.activeDomesticWarehouses()).containsExactly(option);
+    }
+
+    @Test
+    void failsClosedWhenWarehouseDirectoryIsUnavailable() {
+        WarehouseMasterDataClient client = mock(WarehouseMasterDataClient.class);
+        PdaWarehouseCatalogService service = new PdaWarehouseCatalogService();
+        ReflectionTestUtils.setField(service, "warehouses", client);
+        ReflectionTestUtils.setField(service, "internalToken", "token");
+        when(client.domestic("token")).thenThrow(new IllegalStateException("down"));
+
+        assertThatThrownBy(service::activeDomesticWarehouses).isInstanceOf(BizException.class);
+    }
+}