优化

firstleg/src/main/java/com/baiyue/firstleg/oceanbooking/controller/PlatformOceanBookingController.java

@@ -16,6 +16,7 @@ import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.security.core.annotation.AuthenticationPrincipal;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
+import java.util.List;
 
 @Validated
 @RestController
@@ -26,6 +27,11 @@ public class PlatformOceanBookingController {
 
     @GetMapping @PreAuthorize("hasAuthority('platform:firstleg:ocean-booking:list')")
     public ApiResponse<PageResult<OceanBookingEntity>> page(@AuthenticationPrincipal AuthenticatedUser user, @Valid Query query) { FirstlegScopeGuard.platform(user); return ApiResponse.success(service.page(query)); }
+    @GetMapping("/channels") @PreAuthorize("hasAuthority('platform:firstleg:ocean-booking:list')")
+    public ApiResponse<List<ChannelOption>> channels(@AuthenticationPrincipal AuthenticatedUser user,
+                                                      @RequestParam long originWarehouseId) {
+        FirstlegScopeGuard.platform(user); return ApiResponse.success(service.channels(originWarehouseId));
+    }
     @GetMapping("/{oceanBookingId}") @PreAuthorize("hasAuthority('platform:firstleg:ocean-booking:list')")
     public ApiResponse<Detail> detail(@AuthenticationPrincipal AuthenticatedUser user, @PathVariable @Positive long oceanBookingId) { FirstlegScopeGuard.platform(user); return ApiResponse.success(service.detail(oceanBookingId)); }
 

firstleg/src/main/java/com/baiyue/firstleg/oceanbooking/dto/OceanBookingDtos.java

@@ -42,7 +42,6 @@ public final class OceanBookingDtos {
     public record DraftData(@NotNull @Positive Long customerId,
                             @NotBlank @Size(max = 128) String customerName,
                             @NotBlank @Size(max = 64) String channelCode,
-                            @NotBlank @Size(max = 128) String channelName,
                             @NotNull @Positive Long warehouseId,
                             @NotBlank @Size(max = 128) String warehouseName,
                             @Size(max = 128) String billOfLadingNo,
@@ -92,4 +91,7 @@ public final class OceanBookingDtos {
                          List<OceanBookingContainerRequirementEntity> containerRequirements,
                          List<OceanBookingContainerAllocationEntity> containerAllocations,
                          List<OceanBookingStatusHistoryEntity> histories) {}
+
+    public record ChannelOption(Long priceBookVersionId, String channelCode, String channelName,
+                                String priceModel, List<String> pricingTaxModes) {}
 }

firstleg/src/main/java/com/baiyue/firstleg/oceanbooking/service/OceanBookingService.java

@@ -10,6 +10,9 @@ import com.baiyue.firstleg.oceanbooking.domain.OceanBookingStatus;
 import com.baiyue.firstleg.oceanbooking.dto.OceanBookingDtos.*;
 import com.baiyue.firstleg.oceanbooking.entity.*;
 import com.baiyue.firstleg.oceanbooking.repository.OceanBookingRepository;
+import com.baiyue.firstleg.repository.PriceBookQueryRepository;
+import com.baiyue.firstleg.repository.PriceBookQueryRows.ChannelRow;
+import com.baiyue.firstleg.repository.PriceBookQueryRows.ChannelTaxModeRow;
 import com.baiyue.firstleg.service.LoadingPickService;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -25,12 +28,14 @@ import java.time.LocalDateTime;
 import java.util.HashSet;
 import java.util.HexFormat;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 @Service
 public class OceanBookingService {
     private static final Set<String> PARTY_TYPES = Set.of("SHIPPER", "CONSIGNEE", "NOTIFY_PARTY");
     @Resource private OceanBookingRepository repository;
+    @Resource private PriceBookQueryRepository priceBooks;
     @Resource private ObjectMapper objectMapper;
     @Resource private LoadingPickService loadingPickService;
 
@@ -40,21 +45,36 @@ public class OceanBookingService {
         return repository.page(new Query(query.customerId(), status, trim(query.keyword()), query.page(), query.size()));
     }
 
+    public List<ChannelOption> channels(long originWarehouseId) {
+        if (originWarehouseId <= 0) throw badRequest("请选择有效起运仓");
+        Long versionId = priceBooks.activeVersionId();
+        if (versionId == null) return List.of();
+        List<ChannelRow> rows = priceBooks.channels(versionId, originWarehouseId);
+        Map<String, List<String>> taxModes = priceBooks.channelTaxModes(versionId, originWarehouseId).stream()
+            .filter(row -> row != null && StringUtils.hasText(row.getChannelCode())
+                && StringUtils.hasText(row.getPricingTaxMode()))
+            .collect(java.util.stream.Collectors.groupingBy(row -> row.getChannelCode().trim(),
+                java.util.stream.Collectors.mapping(ChannelTaxModeRow::getPricingTaxMode,
+                    java.util.stream.Collectors.toList())));
+        return rows.stream().map(row -> channelOption(row, taxModes)).toList();
+    }
+
     public Detail detail(long oceanBookingId) { return detail(required(oceanBookingId)); }
 
     @Transactional
     public Detail create(long operatorId, String operatorName, String key, CreateRequest request) {
         if (request.expectedVersion() != 0) throw concurrent();
-        validateDraft(request.data());
+        validateDraftStructure(request.data());
         String action = "CREATE";
         String hash = hash(action, null, request);
         Detail replay = claimOrReplay(null, operatorId, action, key, hash);
         if (replay != null) return replay;
+        ChannelOption channel = requireActiveChannel(request.data().warehouseId(), request.data().channelCode());
         OceanBookingEntity value = new OceanBookingEntity();
         value.setId(IdWorker.getId());
         value.setBookingNo("OB" + value.getId());
         value.setStatus(OceanBookingStatus.DRAFT.name());
-        copy(value, request.data());
+        copy(value, request.data(), channel.channelName());
         value.setCreatedBy(operatorId); value.setCreatedByName(operatorName);
         value.setUpdatedBy(operatorId); value.setUpdatedByName(operatorName); value.setVersion(0);
         repository.insert(value);
@@ -67,13 +87,14 @@ public class OceanBookingService {
     @Transactional
     public Detail updateDraft(long oceanBookingId, long operatorId, String operatorName, String key,
                               UpdateDraftRequest request) {
-        validateDraft(request.data());
+        validateDraftStructure(request.data());
         String action = "UPDATE_DRAFT";
         Detail replay = claimOrReplay(oceanBookingId, operatorId, action, key, hash(action, oceanBookingId, request));
         if (replay != null) return replay;
         OceanBookingEntity before = requiredVersion(oceanBookingId, request.expectedVersion());
         requireStatus(before, OceanBookingStatus.DRAFT);
-        OceanBookingEntity value = new OceanBookingEntity(); value.setId(oceanBookingId); copy(value, request.data());
+        ChannelOption channel = requireActiveChannel(request.data().warehouseId(), request.data().channelCode());
+        OceanBookingEntity value = new OceanBookingEntity(); value.setId(oceanBookingId); copy(value, request.data(), channel.channelName());
         if (repository.updateDraft(value, request.expectedVersion(), operatorId, operatorName) != 1) throw concurrent();
         repository.replaceParties(oceanBookingId, parties(oceanBookingId, request.data().parties()));
         repository.replaceRequirements(oceanBookingId, requirements(oceanBookingId, request.data().containerRequirements()));
@@ -90,6 +111,7 @@ public class OceanBookingService {
         if (replay != null) return replay;
         OceanBookingEntity before = requiredVersion(id, request.expectedVersion());
         requireStatus(before, OceanBookingStatus.SUBMITTED);
+        requireActiveChannel(before.getWarehouseId(), before.getChannelCode());
         validateConfirmation(before, repository.requirements(id));
         if (repository.transition(id, OceanBookingStatus.SUBMITTED.name(), OceanBookingStatus.CONFIRMED.name(),
             null, null, request.expectedVersion(), operatorId, name) != 1) throw concurrent();
@@ -263,7 +285,7 @@ public class OceanBookingService {
     private OceanBookingEntity requiredVersion(long id, int version) { OceanBookingEntity value = required(id); if (!Integer.valueOf(version).equals(value.getVersion())) throw concurrent(); return value; }
     private static void requireStatus(OceanBookingEntity value, OceanBookingStatus status) { if (!status.name().equals(value.getStatus())) throw conflict("订舱状态不允许当前操作"); }
 
-    private void validateDraft(DraftData data) {
+    private void validateDraftStructure(DraftData data) {
         if (data.estimatedSailingAt() != null || data.estimatedArrivalAt() != null
             || StringUtils.hasText(data.billOfLadingNo()) || StringUtils.hasText(data.vesselName())
             || StringUtils.hasText(data.voyageNo())) {
@@ -284,9 +306,31 @@ public class OceanBookingService {
         }
     }
     private static void validateRange(LocalDateTime from, LocalDateTime to) { if (from != null && to != null && to.isBefore(from)) throw badRequest("预计到港时间不能早于预计开船时间"); }
-    private static void copy(OceanBookingEntity v, DraftData d) {
+    private ChannelOption requireActiveChannel(Long originWarehouseId, String channelCode) {
+        if (originWarehouseId == null || originWarehouseId <= 0) throw badRequest("请选择有效起运仓");
+        String normalized = normalizeChannel(channelCode);
+        Long versionId = priceBooks.activeVersionId();
+        if (versionId == null) throw conflict("当前没有 ACTIVE 价格版本");
+        ChannelRow row = priceBooks.channels(versionId, originWarehouseId).stream()
+            .filter(value -> normalized.equals(normalizeChannel(value.getChannelCode())))
+            .findFirst().orElseThrow(() -> conflict("所选物流渠道已失效，请重新选择"));
+        if (!StringUtils.hasText(row.getChannelName())) throw conflict("所选物流渠道名称配置无效");
+        return channelOption(row, java.util.Map.of());
+    }
+
+    private static ChannelOption channelOption(ChannelRow row, java.util.Map<String, List<String>> taxModes) {
+        return new ChannelOption(row.getPriceBookVersionId(), row.getChannelCode(), row.getChannelName(),
+            row.getPriceModel(), List.copyOf(taxModes.getOrDefault(row.getChannelCode().trim(), List.of())));
+    }
+
+    private static String normalizeChannel(String value) {
+        if (!StringUtils.hasText(value)) throw badRequest("channelCode不能为空");
+        return value.trim();
+    }
+
+    private static void copy(OceanBookingEntity v, DraftData d, String resolvedChannelName) {
         v.setCustomerId(d.customerId()); v.setCustomerName(d.customerName().trim());
-        v.setChannelCode(d.channelCode().trim()); v.setChannelName(d.channelName().trim());
+        v.setChannelCode(d.channelCode().trim()); v.setChannelName(resolvedChannelName);
         v.setWarehouseId(d.warehouseId()); v.setWarehouseName(d.warehouseName().trim());
         v.setBillOfLadingNo(null);
         v.setShippingCompanyId(d.shippingCompanyId()); v.setShippingCompanyName(trim(d.shippingCompanyName()));

firstleg/src/main/resources/openapi/ocean-bookings-v1.yaml

@@ -1,6 +1,13 @@
 openapi: 3.0.3
 info: {title: Phase 3 Ocean Booking API, version: 1.1.0}
 paths:
+  /api/platform/v1/ocean-bookings/channels:
+    get:
+      summary: List logistics channels from the current ACTIVE price book for an origin warehouse
+      description: 'Requires platform:firstleg:ocean-booking:list. Returns only channels with an ACTIVE price row; the selected channel name is frozen server-side on draft save.'
+      parameters:
+        - {name: originWarehouseId, in: query, required: true, schema: {type: integer, format: int64, minimum: 1}}
+      responses: {'200': {description: Available channel options, content: {application/json: {schema: {type: array, items: {$ref: '#/components/schemas/ChannelOption'}}}}}}
   /api/platform/v1/ocean-bookings:
     post:
       summary: Create an ocean booking draft with immutable channel and warehouse snapshots
@@ -33,12 +40,11 @@ components:
         data: {$ref: '#/components/schemas/DraftData'}
     DraftData:
       type: object
-      required: [customerId, customerName, channelCode, channelName, warehouseId, warehouseName, parties, containerRequirements]
+      required: [customerId, customerName, channelCode, warehouseId, warehouseName, parties, containerRequirements]
       properties:
         customerId: {type: integer, format: int64, minimum: 1}
         customerName: {type: string, maxLength: 128}
-        channelCode: {type: string, maxLength: 64}
-        channelName: {type: string, maxLength: 128}
+        channelCode: {type: string, maxLength: 64, description: Selected from GET /api/platform/v1/ocean-bookings/channels; server validates it against the current ACTIVE price book and freezes channelName.}
         warehouseId: {type: integer, format: int64, minimum: 1}
         warehouseName: {type: string, maxLength: 128}
         billOfLadingNo: {type: string, nullable: true, deprecated: true, description: Must be omitted until release}
@@ -57,6 +63,15 @@ components:
         capacityCbm: {type: number, exclusiveMinimum: true, minimum: 0}
         maxWeightKg: {type: number, exclusiveMinimum: true, minimum: 0}
         quantity: {type: integer, minimum: 1}
+    ChannelOption:
+      type: object
+      required: [priceBookVersionId, channelCode, channelName, priceModel, pricingTaxModes]
+      properties:
+        priceBookVersionId: {type: integer, format: int64}
+        channelCode: {type: string, maxLength: 64}
+        channelName: {type: string, maxLength: 128}
+        priceModel: {type: string}
+        pricingTaxModes: {type: array, items: {type: string}}
     ActionRequest:
       type: object
       required: [expectedVersion]

firstleg/src/test/java/com/baiyue/firstleg/oceanbooking/controller/PlatformOceanBookingControllerContractTest.java

@@ -8,6 +8,8 @@ import org.springframework.web.bind.annotation.RequestMapping;
 import java.lang.reflect.Method;
 import java.util.Arrays;
 import java.util.Map;
+import java.nio.file.Files;
+import java.nio.file.Path;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -18,6 +20,7 @@ class PlatformOceanBookingControllerContractTest {
             .containsExactly("/api/platform/v1/ocean-bookings");
         Map<String, String> permissions = Map.ofEntries(
             Map.entry("page", "platform:firstleg:ocean-booking:list"),
+            Map.entry("channels", "platform:firstleg:ocean-booking:list"),
             Map.entry("detail", "platform:firstleg:ocean-booking:list"),
             Map.entry("create", "platform:firstleg:ocean-booking:create"),
             Map.entry("updateDraft", "platform:firstleg:ocean-booking:edit"),
@@ -34,7 +37,7 @@ class PlatformOceanBookingControllerContractTest {
             Method method = method(name);
             assertThat(method.getAnnotation(PreAuthorize.class).value())
                 .isEqualTo("hasAuthority('" + permission + "')");
-            if (!name.equals("page") && !name.equals("detail")) {
+            if (!name.equals("page") && !name.equals("detail") && !name.equals("channels")) {
                 assertThat(method.getAnnotation(BusinessAudit.class)).isNotNull();
             }
         });
@@ -49,6 +52,15 @@ class PlatformOceanBookingControllerContractTest {
             .allMatch(parameter -> parameter.getName().equals("oceanBookingId"))).isTrue();
     }
 
+    @Test
+    void openApiFreezesServerResolvedChannelContract() throws Exception {
+        String yaml = Files.readString(Path.of("src/main/resources/openapi/ocean-bookings-v1.yaml"));
+        assertThat(yaml).contains("/api/platform/v1/ocean-bookings/channels:",
+            "originWarehouseId", "platform:firstleg:ocean-booking:list", "ChannelOption")
+            .contains("required: [customerId, customerName, channelCode, warehouseId, warehouseName")
+            .doesNotContain("required: [customerId, customerName, channelCode, channelName");
+    }
+
     private static Method method(String name) {
         return Arrays.stream(PlatformOceanBookingController.class.getDeclaredMethods())
             .filter(method -> method.getName().equals(name)).findFirst().orElseThrow();

firstleg/src/test/java/com/baiyue/firstleg/oceanbooking/service/OceanBookingServiceTest.java

@@ -3,9 +3,14 @@ package com.baiyue.firstleg.oceanbooking.service;
 import com.baiyue.common.core.exception.BizException;
 import com.baiyue.firstleg.oceanbooking.dto.OceanBookingDtos.ActionRequest;
 import com.baiyue.firstleg.oceanbooking.dto.OceanBookingDtos.ChangeRequest;
+import com.baiyue.firstleg.oceanbooking.dto.OceanBookingDtos.ContainerRequirementRequest;
+import com.baiyue.firstleg.oceanbooking.dto.OceanBookingDtos.CreateRequest;
 import com.baiyue.firstleg.oceanbooking.dto.OceanBookingDtos.Detail;
+import com.baiyue.firstleg.oceanbooking.dto.OceanBookingDtos.DraftData;
 import com.baiyue.firstleg.oceanbooking.dto.OceanBookingDtos.AllocationRequest;
+import com.baiyue.firstleg.oceanbooking.dto.OceanBookingDtos.PartyRequest;
 import com.baiyue.firstleg.oceanbooking.dto.OceanBookingDtos.ReleaseRequest;
+import com.baiyue.firstleg.oceanbooking.dto.OceanBookingDtos.UpdateDraftRequest;
 import com.baiyue.firstleg.service.LoadingPickService;
 import com.baiyue.firstleg.entity.ContainerBookingEntity;
 import com.baiyue.firstleg.oceanbooking.entity.OceanBookingContainerAllocationEntity;
@@ -14,6 +19,8 @@ import com.baiyue.firstleg.oceanbooking.entity.OceanBookingEntity;
 import com.baiyue.firstleg.oceanbooking.entity.OceanBookingOperationEntity;
 import com.baiyue.firstleg.oceanbooking.entity.OceanBookingStatusHistoryEntity;
 import com.baiyue.firstleg.oceanbooking.repository.OceanBookingRepository;
+import com.baiyue.firstleg.repository.PriceBookQueryRepository;
+import com.baiyue.firstleg.repository.PriceBookQueryRows.ChannelRow;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -23,7 +30,9 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.MockitoAnnotations;
 
 import java.time.LocalDateTime;
+import java.math.BigDecimal;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
@@ -32,6 +41,7 @@ import static org.mockito.Mockito.*;
 
 class OceanBookingServiceTest {
     @Mock private OceanBookingRepository repository;
+    @Mock private PriceBookQueryRepository priceBooks;
     @Mock private LoadingPickService loadingPickService;
     @InjectMocks private OceanBookingService service;
 
@@ -172,12 +182,133 @@ class OceanBookingServiceTest {
         verify(repository, never()).insert(any(OceanBookingContainerAllocationEntity.class));
     }
 
+    @Test
+    void listsOnlyChannelsFromCurrentActivePriceBook() {
+        ChannelRow channel = channel("SEA-US", "美西海运");
+        when(priceBooks.activeVersionId()).thenReturn(51L);
+        when(priceBooks.channels(51L, 701L)).thenReturn(List.of(channel));
+        when(priceBooks.channelTaxModes(51L, 701L)).thenReturn(List.of());
+
+        var result = service.channels(701L);
+
+        assertThat(result).singleElement().satisfies(value -> {
+            assertThat(value.channelCode()).isEqualTo("SEA-US");
+            assertThat(value.channelName()).isEqualTo("美西海运");
+            assertThat(value.priceBookVersionId()).isEqualTo(51L);
+        });
+    }
+
+    @Test
+    void freezesAuthoritativeChannelNameWhenCreatingDraft() {
+        ChannelRow channel = channel("SEA-US", "价格簿美西海运");
+        when(priceBooks.activeVersionId()).thenReturn(51L);
+        when(priceBooks.channels(51L, 701L)).thenReturn(List.of(channel));
+        AtomicReference<OceanBookingEntity> inserted = new AtomicReference<>();
+        doAnswer(invocation -> { inserted.set(invocation.getArgument(0)); return null; })
+            .when(repository).insert(any(OceanBookingEntity.class));
+        when(repository.find(anyLong())).thenAnswer(invocation -> inserted.get());
+
+        Detail result = service.create(9L, "admin", "create-channel", new CreateRequest(0, draft()));
+
+        assertThat(result.oceanBooking().getChannelCode()).isEqualTo("SEA-US");
+        assertThat(result.oceanBooking().getChannelName()).isEqualTo("价格簿美西海运");
+    }
+
+    @Test
+    void replaysCreateAfterChannelIsNoLongerActive() throws Exception {
+        ChannelRow channel = channel("SEA-US", "价格簿美西海运");
+        CreateRequest request = new CreateRequest(0, draft());
+        when(priceBooks.activeVersionId()).thenReturn(51L, (Long) null);
+        when(priceBooks.channels(51L, 701L)).thenReturn(List.of(channel));
+        AtomicReference<OceanBookingEntity> inserted = new AtomicReference<>();
+        doAnswer(invocation -> { inserted.set(invocation.getArgument(0)); return null; })
+            .when(repository).insert(any(OceanBookingEntity.class));
+        when(repository.find(anyLong())).thenAnswer(invocation -> inserted.get());
+
+        Detail created = service.create(9L, "admin", "create-replay-channel", request);
+
+        OceanBookingOperationEntity operation = new OceanBookingOperationEntity();
+        operation.setRequestHash(hashForCreate(request)); operation.setStatus("SUCCESS");
+        operation.setResultJson(new ObjectMapper().findAndRegisterModules().writeValueAsString(created));
+        when(repository.claimOperation(isNull(), eq(9L), eq("CREATE"), eq("create-replay-channel"), anyString()))
+            .thenReturn(false);
+        when(repository.operation(9L, "CREATE", "create-replay-channel")).thenReturn(operation);
+
+        Detail replay = service.create(9L, "admin", "create-replay-channel", request);
+
+        assertThat(replay.oceanBooking().getChannelName()).isEqualTo("价格簿美西海运");
+        verify(priceBooks, times(1)).activeVersionId();
+    }
+
+    @Test
+    void replaysDraftUpdateAfterChannelIsNoLongerActive() throws Exception {
+        UpdateDraftRequest request = new UpdateDraftRequest(5, draft());
+        Detail expected = new Detail(booking("DRAFT", 6), List.of(), List.of(), List.of(), List.of());
+        OceanBookingOperationEntity operation = new OceanBookingOperationEntity();
+        operation.setRequestHash(hashForUpdate(request)); operation.setStatus("SUCCESS");
+        operation.setResultJson(new ObjectMapper().findAndRegisterModules().writeValueAsString(expected));
+        when(repository.claimOperation(eq(1L), eq(9L), eq("UPDATE_DRAFT"), eq("update-replay-channel"), anyString()))
+            .thenReturn(false);
+        when(repository.operation(9L, "UPDATE_DRAFT", "update-replay-channel")).thenReturn(operation);
+
+        Detail replay = service.updateDraft(1L, 9L, "admin", "update-replay-channel", request);
+
+        assertThat(replay.oceanBooking().getVersion()).isEqualTo(6);
+        verifyNoInteractions(priceBooks);
+        verify(repository, never()).find(anyLong());
+    }
+
+    @Test
+    void rejectsConfirmationWhenFrozenChannelIsNoLongerActive() {
+        OceanBookingEntity submitted = booking("SUBMITTED", 3);
+        submitted.setWarehouseId(701L); submitted.setWarehouseName("深圳仓"); submitted.setChannelName("美西海运");
+        OceanBookingContainerRequirementEntity requirement = new OceanBookingContainerRequirementEntity();
+        requirement.setCapacityCbm(java.math.BigDecimal.ONE); requirement.setMaxWeightKg(java.math.BigDecimal.ONE);
+        when(repository.find(1L)).thenReturn(submitted);
+        when(repository.requirements(1L)).thenReturn(List.of(requirement));
+        when(priceBooks.activeVersionId()).thenReturn(null);
+
+        assertThatThrownBy(() -> service.confirm(1L, 9L, "admin", "confirm-channel", new ActionRequest(3, "确认")))
+            .isInstanceOf(BizException.class).hasMessageContaining("ACTIVE");
+
+        verify(repository, never()).transition(anyLong(), anyString(), anyString(), any(), any(), anyInt(), anyLong(), anyString());
+    }
+
+    private static ChannelRow channel(String code, String name) {
+        ChannelRow value = new ChannelRow(); value.setPriceBookVersionId(51L); value.setChannelCode(code);
+        value.setChannelName(name); value.setPriceModel("FBA_WAREHOUSE_RATE"); return value;
+    }
+
+    private static DraftData draft() {
+        List<PartyRequest> parties = List.of(
+            new PartyRequest("SHIPPER", "发货人", null, null, null),
+            new PartyRequest("CONSIGNEE", "收货人", null, null, null),
+            new PartyRequest("NOTIFY_PARTY", "通知人", null, null, null));
+        List<ContainerRequirementRequest> requirements = List.of(
+            new ContainerRequirementRequest("40HQ", "DRY", BigDecimal.ONE, BigDecimal.TEN, 1));
+        return new DraftData(100L, "客户", "SEA-US", 701L, "深圳仓", null,
+            81L, "船公司", null, null, null, null, "CNSZX", "深圳", "USLAX", "洛杉矶",
+            null, null, null, null, null, null, parties, requirements);
+    }
+
     private String hashForSubmit() throws Exception {
         var method = OceanBookingService.class.getDeclaredMethod("hash", String.class, Long.class, Object.class);
         method.setAccessible(true);
         return (String) method.invoke(service, "SUBMIT", 1L, new ActionRequest(2, "提交"));
     }
 
+    private String hashForCreate(CreateRequest request) throws Exception {
+        var method = OceanBookingService.class.getDeclaredMethod("hash", String.class, Long.class, Object.class);
+        method.setAccessible(true);
+        return (String) method.invoke(service, "CREATE", (Long) null, request);
+    }
+
+    private String hashForUpdate(UpdateDraftRequest request) throws Exception {
+        var method = OceanBookingService.class.getDeclaredMethod("hash", String.class, Long.class, Object.class);
+        method.setAccessible(true);
+        return (String) method.invoke(service, "UPDATE_DRAFT", 1L, request);
+    }
+
     private static OceanBookingEntity booking(String status, int version) {
         OceanBookingEntity value = new OceanBookingEntity(); value.setId(1L); value.setBookingNo("OB1");
         value.setStatus(status); value.setCustomerId(100L); value.setCustomerName("客户");