优化

firstleg/src/test/java/com/baiyue/firstleg/client/WarehousePalletLocationClientContractTest.java

@@ -0,0 +1,37 @@
+package com.baiyue.firstleg.client;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+
+import java.lang.reflect.Method;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class WarehousePalletLocationClientContractTest {
+    @Test
+    void consumesTheWarehousePalletSnapshotContractExactly() throws Exception {
+        FeignClient client = WarehousePalletLocationClient.class.getAnnotation(FeignClient.class);
+        assertThat(client.path()).isEqualTo("/internal/warehouse/v1");
+
+        Method method = WarehousePalletLocationClient.class.getDeclaredMethod(
+            "palletSnapshots", String.class, long.class);
+        assertThat(method.getAnnotation(GetMapping.class).value())
+            .containsExactly("/pallets/snapshots");
+        assertThat(method.getParameters()[1].getAnnotation(RequestParam.class).value())
+            .isEqualTo("warehouseId");
+
+        var snapshot = new WarehousePalletLocationClient.PalletSnapshot(
+            101L, "PLT-101", "STANDARD", new java.math.BigDecimal("2.0000"),
+            new java.math.BigDecimal("18.500"));
+        assertThat(snapshot).extracting(
+            WarehousePalletLocationClient.PalletSnapshot::palletId,
+            WarehousePalletLocationClient.PalletSnapshot::palletCode,
+            WarehousePalletLocationClient.PalletSnapshot::palletType,
+            WarehousePalletLocationClient.PalletSnapshot::capacityCbm,
+            WarehousePalletLocationClient.PalletSnapshot::tareWeightKg)
+            .containsExactly(101L, "PLT-101", "STANDARD",
+                new java.math.BigDecimal("2.0000"), new java.math.BigDecimal("18.500"));
+    }
+}

firstleg/src/test/java/com/baiyue/firstleg/controller/PlatformInboundMeasurementControllerContractTest.java

@@ -17,6 +17,10 @@ class PlatformInboundMeasurementControllerContractTest {
     void everyMeasurementOperationUsesDedicatedButtonPermission() throws Exception {
         assertAuthority("detail", "hasAuthority('platform:firstleg:inbound:measure:view')",
             AuthenticatedUser.class, long.class, long.class);
+        assertAuthority("weightPalletOptions",
+            "hasAnyAuthority('platform:firstleg:inbound:measure:view',"
+                + " 'platform:firstleg:inbound:weight:edit')",
+            AuthenticatedUser.class, long.class, long.class);
         assertAuthority("saveDraft", "hasAuthority('platform:firstleg:inbound:measure:edit')",
             AuthenticatedUser.class, long.class, long.class,
             InboundMeasurementRequests.SaveDraftRequest.class);

firstleg/src/test/java/com/baiyue/firstleg/dto/CreateWeightResultRequestValidationTest.java

@@ -0,0 +1,34 @@
+package com.baiyue.firstleg.dto;
+
+import jakarta.validation.Validation;
+import jakarta.validation.Validator;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class CreateWeightResultRequestValidationTest {
+    private final Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
+
+    @Test
+    void requiresAValidFileAndPalletBinding() {
+        var valid = request(120L, 501L);
+        var missingPallet = request(120L, null);
+        var invalidPallet = request(120L, 0L);
+
+        assertThat(validator.validate(valid)).isEmpty();
+        assertThat(validator.validate(missingPallet))
+            .extracting(violation -> violation.getPropertyPath().toString())
+            .contains("palletId");
+        assertThat(validator.validate(invalidPallet))
+            .extracting(violation -> violation.getPropertyPath().toString())
+            .contains("palletId");
+    }
+
+    private InboundMeasurementRequests.CreateWeightResultRequest request(Long fileId, Long palletId) {
+        return new InboundMeasurementRequests.CreateWeightResultRequest(
+            fileId, palletId, "FILE_WEIGHT_OCR", "30.000 KG", new BigDecimal("30.000"),
+            "KG", new BigDecimal("0.99000"));
+    }
+}

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

@@ -63,4 +63,26 @@ class InboundWorkflowSqlContractTest {
             .contains("uk_measure_box_code")
             .contains("单箱当前测量字段未完整创建");
     }
+
+    @Test
+    @DisplayName("称重结果固化托盘快照、毛重和净重并允许托盘主数据复用")
+    void shouldPersistWeightPalletSnapshotsAndNetWeight() throws Exception {
+        String schema = new ClassPathResource("db/phase2-inbound-schema.sql")
+            .getContentAsString(StandardCharsets.UTF_8);
+        String unified = Files.readString(Path.of("..", "deploy", "sql", "头程数据库统一增量-MySQL8.sql"));
+
+        assertThat(schema)
+            .contains("pallet_tare_weight_kg DECIMAL(18,3) NOT NULL")
+            .contains("gross_weight_kg DECIMAL(18,3) NULL")
+            .contains("net_weight_kg DECIMAL(18,3) NULL")
+            .contains("idx_weight_inbound_pallet")
+            .doesNotContain("final_weight_kg")
+            .doesNotContain("uk_pallet_allocation_pallet");
+        assertThat(unified)
+            .contains("CALL phase2_measure_add_column('fl_inbound_weight_result', 'pallet_id'")
+            .contains("ALTER TABLE fl_inbound_weight_result DROP COLUMN final_weight_kg")
+            .contains("ALTER TABLE fl_inbound_pallet_allocation DROP INDEX uk_pallet_allocation_pallet")
+            .contains("称重托盘快照或毛重净重字段未正确收敛")
+            .contains("同票托盘唯一约束仍阻止托盘主数据复用");
+    }
 }

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

@@ -10,6 +10,7 @@ import com.baiyue.firstleg.entity.CustomerDimensionConfigEntity;
 import com.baiyue.firstleg.entity.InboundMeasurementEntity;
 import com.baiyue.firstleg.entity.InboundMeasurementItemEntity;
 import com.baiyue.firstleg.entity.InboundOrderEntity;
+import com.baiyue.firstleg.entity.InboundWeightResultEntity;
 import com.baiyue.firstleg.repository.InboundMeasurementRepository;
 import com.baiyue.firstleg.repository.CustomerDimensionConfigRepository;
 import org.junit.jupiter.api.BeforeEach;
@@ -248,7 +249,7 @@ class CartonMeasurementServiceTest {
     }
 
     @Test
-    void confirmedPackageCountSynchronizesActualWeightAndVolumeForPricingAfterSubmission() {
+    void confirmedPackageCountUsesCartonWeightAsFallbackWhenNoConfirmedImageExists() {
         InboundOrderEntity inbound = inbound("MEASURE_PENDING");
         InboundMeasurementEntity measurement = measurement(30001L, "SUBMITTED", 2);
         measurement.setTotalPackageCount(1);
@@ -266,6 +267,7 @@ class CartonMeasurementServiceTest {
         when(repository.findMeasurement(10001L, 70001L, 30001L)).thenReturn(measurement);
         when(repository.updateItem(item)).thenReturn(true);
         when(repository.listItems(10001L, 30001L)).thenReturn(List.of(item));
+        when(repository.listWeights(10001L, 70001L)).thenReturn(List.of());
         when(repository.updateMeasurement(measurement)).thenReturn(true);
         when(repository.updateInbound(inbound)).thenReturn(true);
 
@@ -278,6 +280,41 @@ class CartonMeasurementServiceTest {
         verify(repository).updateInbound(inbound);
     }
 
+    @Test
+    void cartonMeasurementAfterConfirmedWeightKeepsNetWeightAndUpdatesVolume() {
+        InboundOrderEntity inbound = inbound("MEASURE_PENDING");
+        inbound.setActualGrossWeightKg(new BigDecimal("11.500"));
+        InboundMeasurementEntity measurement = measurement(30001L, "SUBMITTED", 2);
+        measurement.setTotalPackageCount(1);
+        measurement.setTotalVolumeCbm(new BigDecimal("0.0600"));
+        measurement.setVolumeWeightKg(new BigDecimal("10.020"));
+        InboundMeasurementItemEntity item = item(40001L, 30001L, 1, 99001L);
+        item.setUnitWeightKg(new BigDecimal("10.880"));
+        item.setOuterLengthCm(new BigDecimal("50"));
+        item.setOuterWidthCm(new BigDecimal("40"));
+        item.setOuterHeightCm(new BigDecimal("30"));
+        item.setUnitVolumeCbm(new BigDecimal("0.1496"));
+        item.setCalculationRuleVersion("ACTUAL_DIMENSION_V1");
+        InboundWeightResultEntity confirmedWeight = new InboundWeightResultEntity();
+        confirmedWeight.setRecognitionStatus("CONFIRMED");
+        confirmedWeight.setNetWeightKg(new BigDecimal("11.500"));
+        when(repository.findInbound(10001L, 70001L)).thenReturn(inbound);
+        when(repository.findItem(10001L, 40001L)).thenReturn(item);
+        when(repository.findMeasurement(10001L, 70001L, 30001L)).thenReturn(measurement);
+        when(repository.updateItem(item)).thenReturn(true);
+        when(repository.listItems(10001L, 30001L)).thenReturn(List.of(item));
+        when(repository.listWeights(10001L, 70001L)).thenReturn(List.of(confirmedWeight));
+        when(repository.updateMeasurement(measurement)).thenReturn(true);
+        when(repository.updateInbound(inbound)).thenReturn(true);
+
+        service.updateConfirmedPackageCount(10001L, 70001L, 40001L, 2, 5);
+
+        assertThat(inbound.getActualGrossWeightKg()).isEqualByComparingTo("11.500");
+        assertThat(inbound.getActualVolumeCbm()).isEqualByComparingTo("0.7480");
+        assertThat(inbound.getVolumeWeightKg()).isEqualByComparingTo("124.916");
+        verify(repository).updateInbound(inbound);
+    }
+
     private CartonMeasurementCommand command() {
         return new CartonMeasurementCommand("RK-001#5-1", new BigDecimal("59.100"),
             new BigDecimal("40.200"), new BigDecimal("30.300"), new BigDecimal("12.500"),

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

@@ -4,6 +4,7 @@ import com.baiyue.common.core.exception.BizException;
 import com.baiyue.common.core.api.ApiResponse;
 import com.baiyue.firstleg.client.OrderCargoClient;
 import com.baiyue.firstleg.client.MeasurementImageClient;
+import com.baiyue.firstleg.client.WarehousePalletLocationClient;
 import com.baiyue.firstleg.dto.InboundMeasurementRequests;
 import com.baiyue.firstleg.dto.MeasurementBatchCommand;
 import com.baiyue.firstleg.dto.InboundMeasurementResponses;
@@ -49,8 +50,15 @@ class InboundMeasurementServiceTest {
     @MockBean private MeasurementBatchService batchService;
     @MockBean private OrderCargoClient orderCargoClient;
     @MockBean private MeasurementImageClient imageClient;
+    @MockBean private WarehousePalletLocationClient warehousePallets;
     @Resource private InboundMeasurementService service;
 
+    @BeforeEach
+    void stubWarehousePalletSnapshots() {
+        when(warehousePallets.palletSnapshots("internal-token", 100L)).thenReturn(
+            ApiResponse.success(List.of(palletSnapshot())));
+    }
+
     @Test
     void customerCannotReadAnotherCustomersMeasurement() {
         assertThatThrownBy(() -> service.detail(2L, 10L))
@@ -90,7 +98,8 @@ class InboundMeasurementServiceTest {
         InboundOrderEntity inbound = inbound("MEASURING");
         inbound.setActualGrossWeightKg(new BigDecimal("12.500"));
         InboundWeightResultEntity weight = weight(20L, "12.500", "KG", "CONFIRMED", 4);
-        weight.setFinalWeightKg(new BigDecimal("12.500"));
+        weight.setGrossWeightKg(new BigDecimal("12.500"));
+        weight.setNetWeightKg(new BigDecimal("12.500"));
         when(repository.findInbound(1L, 10L)).thenReturn(inbound);
         when(repository.findWeight(1L, 10L, 20L)).thenReturn(weight);
         when(repository.updateWeight(weight)).thenReturn(true);
@@ -102,7 +111,8 @@ class InboundMeasurementServiceTest {
                 4, new BigDecimal("13.200"), "KG", "秤面显示修正"));
 
         assertThat(weight.getRecognitionStatus()).isEqualTo("PENDING_CONFIRM");
-        assertThat(weight.getFinalWeightKg()).isNull();
+        assertThat(weight.getGrossWeightKg()).isNull();
+        assertThat(weight.getNetWeightKg()).isNull();
         assertThat(inbound.getActualGrossWeightKg()).isNull();
         verify(repository).updateInboundWeightSummary(inbound);
     }
@@ -134,22 +144,55 @@ class InboundMeasurementServiceTest {
         InboundMeasurementResponses.WeightResult result = service.createWeightResult(
             1L, 10L, 9L,
             new InboundMeasurementRequests.CreateWeightResultRequest(
-                120L, "FILE_WEIGHT_OCR", "285.5", new BigDecimal("285.500"), "KG",
+                120L, 501L, "FILE_WEIGHT_OCR", "285.5", new BigDecimal("285.500"), "KG",
                 new BigDecimal("0.5097191334")));
 
         ArgumentCaptor<InboundWeightResultEntity> saved =
             ArgumentCaptor.forClass(InboundWeightResultEntity.class);
         verify(repository).insertWeight(saved.capture());
         assertThat(saved.getValue().getConfidence()).isEqualByComparingTo("0.50972");
+        assertThat(saved.getValue().getPalletId()).isEqualTo(501L);
+        assertThat(saved.getValue().getPalletCode()).isEqualTo("PLT-501");
+        assertThat(saved.getValue().getPalletTareWeightKg()).isEqualByComparingTo("18.500");
         assertThat(result.confidence()).isEqualByComparingTo("0.50972");
     }
 
+    @Test
+    void weightPalletOptionsUsesInboundWarehouseWithoutCustomerScope() {
+        InboundOrderEntity inbound = inbound("WAIT_MEASURE");
+        when(repository.findInbound(1L, 10L)).thenReturn(inbound);
+
+        List<InboundMeasurementResponses.PalletSnapshot> result =
+            service.weightPalletOptions(1L, 10L);
+
+        assertThat(result).singleElement().satisfies(snapshot -> {
+            assertThat(snapshot.palletId()).isEqualTo(501L);
+            assertThat(snapshot.tareWeightKg()).isEqualByComparingTo("18.500");
+        });
+        verify(warehousePallets).palletSnapshots("internal-token", 100L);
+    }
+
+    @Test
+    void creatingWeightResultRejectsPalletOutsideTheInboundWarehouse() {
+        InboundOrderEntity inbound = inbound("WAIT_MEASURE");
+        when(repository.findInbound(1L, 10L)).thenReturn(inbound);
+
+        assertThatThrownBy(() -> service.createWeightResult(1L, 10L, 9L,
+            new InboundMeasurementRequests.CreateWeightResultRequest(
+                120L, 999L, "FILE_WEIGHT_OCR", "20.0 KG", new BigDecimal("20.000"),
+                "KG", new BigDecimal("0.99"))))
+            .isInstanceOf(BizException.class)
+            .hasMessageContaining("不属于当前入库仓库");
+
+        verify(repository, never()).insertWeight(any());
+    }
+
     @Test
     void confirmingLbWeightConvertsToKgAndRecalculatesOnlyConfirmedImages() {
         InboundOrderEntity inbound = inbound("WAIT_MEASURE");
         InboundWeightResultEntity current = weight(20L, "10.000", "LB", "PENDING_CONFIRM", 0);
         InboundWeightResultEntity previous = weight(21L, "2.000", "KG", "CONFIRMED", 1);
-        previous.setFinalWeightKg(new BigDecimal("2.000"));
+        previous.setNetWeightKg(new BigDecimal("2.000"));
         when(repository.findInbound(1L, 10L)).thenReturn(inbound);
         when(repository.findWeight(1L, 10L, 20L)).thenReturn(current);
         when(repository.updateWeight(current)).thenReturn(true);
@@ -160,12 +203,58 @@ class InboundMeasurementServiceTest {
             1L, 10L, 20L, 9L, "操作员",
             new InboundMeasurementRequests.ConfirmWeightResultRequest(0, null, null, null));
 
-        assertThat(response.finalWeightKg()).isEqualByComparingTo("4.536");
+        assertThat(response.grossWeightKg()).isEqualByComparingTo("4.536");
+        assertThat(response.netWeightKg()).isEqualByComparingTo("4.536");
         assertThat(inbound.getActualGrossWeightKg()).isEqualByComparingTo("6.536");
         assertThat(inbound.getProcessStatus()).isEqualTo("MEASURING");
         verify(repository).insertRevision(any(InboundWeightRevisionEntity.class));
     }
 
+    @Test
+    void confirmingWeightAfterCartonMeasurementReplacesFallbackWithNetWeight() {
+        InboundOrderEntity inbound = inbound("WAIT_MEASURE");
+        inbound.setActualGrossWeightKg(new BigDecimal("54.400"));
+        InboundWeightResultEntity weight = weight(20L, "30.000", "KG", "PENDING_CONFIRM", 0);
+        weight.setPalletTareWeightKg(new BigDecimal("18.500"));
+        when(repository.findInbound(1L, 10L)).thenReturn(inbound);
+        when(repository.findWeight(1L, 10L, 20L)).thenReturn(weight);
+        when(repository.updateWeight(weight)).thenReturn(true);
+        when(repository.listWeights(1L, 10L)).thenReturn(List.of(weight));
+        when(repository.updateInboundWeightSummary(inbound)).thenReturn(true);
+
+        InboundMeasurementResponses.WeightResult response = service.confirmWeightResult(
+            1L, 10L, 20L, 9L, "操作员",
+            new InboundMeasurementRequests.ConfirmWeightResultRequest(0, null, null, null));
+
+        assertThat(response.grossWeightKg()).isEqualByComparingTo("30.000");
+        assertThat(response.netWeightKg()).isEqualByComparingTo("11.500");
+        assertThat(inbound.getActualGrossWeightKg()).isEqualByComparingTo("11.500");
+        ArgumentCaptor<InboundWeightRevisionEntity> revision =
+            ArgumentCaptor.forClass(InboundWeightRevisionEntity.class);
+        verify(repository).insertRevision(revision.capture());
+        assertThat(revision.getValue().getGrossWeightKg()).isEqualByComparingTo("30.000");
+        assertThat(revision.getValue().getNetWeightKg()).isEqualByComparingTo("11.500");
+    }
+
+    @Test
+    void confirmingWeightRejectsGrossWeightNotAboveFrozenTare() {
+        InboundOrderEntity inbound = inbound("WAIT_MEASURE");
+        InboundWeightResultEntity weight = weight(20L, "18.500", "KG", "PENDING_CONFIRM", 0);
+        weight.setPalletTareWeightKg(new BigDecimal("18.500"));
+        when(repository.findInbound(1L, 10L)).thenReturn(inbound);
+        when(repository.findWeight(1L, 10L, 20L)).thenReturn(weight);
+
+        assertThatThrownBy(() -> service.confirmWeightResult(
+            1L, 10L, 20L, 9L, "操作员",
+            new InboundMeasurementRequests.ConfirmWeightResultRequest(0, null, null, null)))
+            .isInstanceOf(BizException.class)
+            .hasMessageContaining("毛重必须大于托盘皮重");
+
+        verify(repository, never()).updateWeight(any());
+        verify(repository, never()).insertRevision(any());
+        verify(repository, never()).updateInboundWeightSummary(any());
+    }
+
     @ParameterizedTest
     @CsvSource({
         "kg,2.000",
@@ -190,7 +279,8 @@ class InboundMeasurementServiceTest {
 
         assertThat(response.adjustedWeightUnit()).isEqualTo(
             unit.trim().toUpperCase().startsWith("LB") ? "LB" : "KG");
-        assertThat(response.finalWeightKg()).isEqualByComparingTo(expectedKg);
+        assertThat(response.grossWeightKg()).isEqualByComparingTo(expectedKg);
+        assertThat(response.netWeightKg()).isEqualByComparingTo(expectedKg);
         assertThat(response.version()).isEqualTo(2);
     }
 
@@ -208,7 +298,7 @@ class InboundMeasurementServiceTest {
             1L, 10L, 20L, 9L, "操作员",
             new InboundMeasurementRequests.ConfirmWeightResultRequest(0, null, null, null));
 
-        assertThat(response.finalWeightKg()).isEqualByComparingTo("0.001");
+        assertThat(response.netWeightKg()).isEqualByComparingTo("0.001");
         assertThat(inbound.getActualGrossWeightKg()).isEqualByComparingTo("0.001");
     }
 
@@ -283,7 +373,8 @@ class InboundMeasurementServiceTest {
                 0, new BigDecimal("286.125"), "kg", "OCR 原值 285.500 KG，人工确认 286.125 KG"));
 
         assertThat(response.adjustedWeightValue()).isEqualByComparingTo("286.125");
-        assertThat(response.finalWeightKg()).isEqualByComparingTo("286.125");
+        assertThat(response.grossWeightKg()).isEqualByComparingTo("286.125");
+        assertThat(response.netWeightKg()).isEqualByComparingTo("286.125");
         assertThat(response.recognitionStatus()).isEqualTo("CONFIRMED");
         assertThat(response.version()).isEqualTo(2);
         assertThat(inbound.getActualGrossWeightKg()).isEqualByComparingTo("286.125");
@@ -344,7 +435,8 @@ class InboundMeasurementServiceTest {
     void confirmingAnAlreadyConfirmedWeightWithCurrentVersionIsIdempotent() {
         InboundOrderEntity inbound = inbound("MEASURING");
         InboundWeightResultEntity weight = weight(20L, "285.500", "KG", "CONFIRMED", 2);
-        weight.setFinalWeightKg(new BigDecimal("285.500"));
+        weight.setGrossWeightKg(new BigDecimal("285.500"));
+        weight.setNetWeightKg(new BigDecimal("285.500"));
         when(repository.findInbound(1L, 10L)).thenReturn(inbound);
         when(repository.findWeight(1L, 10L, 20L)).thenReturn(weight);
 
@@ -363,7 +455,8 @@ class InboundMeasurementServiceTest {
     void confirmingWithStaleVersionDoesNotTreatRequestAsIdempotent() {
         InboundOrderEntity inbound = inbound("MEASURING");
         InboundWeightResultEntity weight = weight(20L, "285.500", "KG", "CONFIRMED", 2);
-        weight.setFinalWeightKg(new BigDecimal("285.500"));
+        weight.setGrossWeightKg(new BigDecimal("285.500"));
+        weight.setNetWeightKg(new BigDecimal("285.500"));
         when(repository.findInbound(1L, 10L)).thenReturn(inbound);
         when(repository.findWeight(1L, 10L, 20L)).thenReturn(weight);
 
@@ -420,7 +513,8 @@ class InboundMeasurementServiceTest {
         InboundOrderEntity inbound = inbound("MEASURING");
         inbound.setActualGrossWeightKg(new BigDecimal("285.500"));
         InboundWeightResultEntity weight = weight(20L, "285.500", "KG", "CONFIRMED", 2);
-        weight.setFinalWeightKg(new BigDecimal("285.500"));
+        weight.setGrossWeightKg(new BigDecimal("285.500"));
+        weight.setNetWeightKg(new BigDecimal("285.500"));
         when(repository.findInbound(1L, 10L)).thenReturn(inbound);
         when(repository.findWeight(1L, 10L, 20L)).thenReturn(weight);
         when(repository.deleteWeight(1L, 10L, 20L, 2)).thenReturn(true);
@@ -440,9 +534,9 @@ class InboundMeasurementServiceTest {
         InboundOrderEntity inbound = inbound("MEASURING");
         inbound.setActualGrossWeightKg(new BigDecimal("15.000"));
         InboundWeightResultEntity deleted = weight(20L, "10.000", "KG", "CONFIRMED", 2);
-        deleted.setFinalWeightKg(new BigDecimal("10.000"));
+        deleted.setNetWeightKg(new BigDecimal("10.000"));
         InboundWeightResultEntity remaining = weight(21L, "5.000", "KG", "CONFIRMED", 1);
-        remaining.setFinalWeightKg(new BigDecimal("5.000"));
+        remaining.setNetWeightKg(new BigDecimal("5.000"));
         when(repository.findInbound(1L, 10L)).thenReturn(inbound);
         when(repository.findWeight(1L, 10L, 20L)).thenReturn(deleted);
         when(repository.deleteWeight(1L, 10L, 20L, 2)).thenReturn(true);
@@ -488,7 +582,7 @@ class InboundMeasurementServiceTest {
         item.setPackageCount(3);
         item.setSourceImageFileId(500L);
         InboundWeightResultEntity weight = weight(20L, "20.000", "KG", "CONFIRMED", 1);
-        weight.setFinalWeightKg(new BigDecimal("20.000"));
+        weight.setNetWeightKg(new BigDecimal("20.000"));
         when(repository.findInbound(1L, 10L)).thenReturn(inbound);
         when(repository.findMeasurement(1L, 10L, 30L)).thenReturn(measurement);
         when(repository.listItems(1L, 30L)).thenReturn(List.of(item));
@@ -592,6 +686,7 @@ class InboundMeasurementServiceTest {
         InboundOrderEntity inbound = new InboundOrderEntity();
         inbound.setId(10L);
         inbound.setTenantId(1L);
+        inbound.setWarehouseId(100L);
         inbound.setProcessStatus(status);
         inbound.setTotalPackageCount(3);
         inbound.setVersion(0);
@@ -605,10 +700,21 @@ class InboundMeasurementServiceTest {
         weight.setTenantId(1L);
         weight.setInboundId(10L);
         weight.setFileId(id + 100L);
+        weight.setPalletId(501L);
+        weight.setPalletCode("PLT-501");
+        weight.setPalletType("STANDARD");
+        weight.setPalletCapacityCbm(new BigDecimal("2.0000"));
+        weight.setPalletTareWeightKg(BigDecimal.ZERO.setScale(3));
         weight.setOcrWeightValue(new BigDecimal(value));
         weight.setOcrWeightUnit(unit);
         weight.setRecognitionStatus(status);
         weight.setVersion(version);
         return weight;
     }
+
+    private WarehousePalletLocationClient.PalletSnapshot palletSnapshot() {
+        return new WarehousePalletLocationClient.PalletSnapshot(
+            501L, "PLT-501", "STANDARD", new BigDecimal("2.0000"),
+            new BigDecimal("18.500"));
+    }
 }