优化提交

2026-09-14 09:58:30 +08:00
parent 5ffd6c0118
commit 8cf7c4b9c9
93 changed files with 2945 additions and 188 deletions
@@ -31,6 +31,7 @@ import com.baiyue.lastleg.inventory.entity.InventoryPosition;
 import com.baiyue.lastleg.inventory.entity.InventoryBalance;
 import com.baiyue.lastleg.inventory.mapper.InventoryPositionMapper;
 import com.baiyue.lastleg.inventory.mapper.InventoryBalanceMapper;
+import com.baiyue.lastleg.transfer.mapper.WarehouseTransferPalletMapper;
 import com.baiyue.lastleg.dropship.entity.DropshipOrderProfile;
 import com.baiyue.lastleg.dropship.entity.DropshipCarton;
 import com.baiyue.lastleg.dropship.mapper.DropshipOrderProfileMapper;
@@ -83,6 +84,7 @@ class DeliveryTransferServiceTest {
    @Mock DropshipOrderProfileMapper dropshipProfiles;
    @Mock DropshipCartonMapper dropshipCartons;
    @Mock DropshipSkuInventoryMapper dropshipSkuInventory;
+    @Mock WarehouseTransferPalletMapper warehouseTransferPallets;

    private DeliveryTransferService service;

@@ -110,6 +112,7 @@ class DeliveryTransferServiceTest {
        ReflectionTestUtils.setField(service, "dropshipProfiles", dropshipProfiles);
        ReflectionTestUtils.setField(service, "dropshipCartons", dropshipCartons);
        ReflectionTestUtils.setField(service, "dropshipSkuInventory", dropshipSkuInventory);
+        ReflectionTestUtils.setField(service, "warehouseTransferPallets", warehouseTransferPallets);
    }

    @Test
@@ -15,7 +15,7 @@ class DispatchCandidateMapperContractTest {
        "planNo", "orderType", "volumeWeightKg", "containerNo", "appointmentAt", "expectedLoadingAt",
        "overseasWarehouseId", "overseasWarehouseName", "orderNo", "orderRefs", "inboundCode", "palletNo",
        "destinationWarehouseId", "destinationWarehouseCode", "destinationWarehouseName", "fbaWarehouseCode",
-        "packageCount", "volumeCbm", "sourceStage", "cartonMarks"
+        "packageCount", "volumeCbm", "sourceStage", "cartonMarks", "relabelCartonMarks"
    );

    @Test
@@ -24,6 +24,8 @@ class DispatchCandidateMapperContractTest {
            String.class, List.class, String.class, String.class, String.class, String.class));
        assertConstructorColumnOrder(DispatchCandidateMapper.class.getMethod("lockSelected",
            String.class, List.class));
+        assertConstructorColumnOrder(DispatchCandidateMapper.class.getMethod("relabelAvailable",
+            String.class, String.class, String.class));
    }

    @Test
@@ -49,6 +51,20 @@ class DispatchCandidateMapperContractTest {
        }
    }

+    @Test
+    void candidateMarksFollowPdaRelabelPalletBinding() throws Exception {
+        for (Method method : List.of(
+            DispatchCandidateMapper.class.getMethod("available", String.class, List.class, String.class,
+                String.class, String.class, String.class),
+            DispatchCandidateMapper.class.getMethod("lockSelected", String.class, List.class))) {
+            String sql = String.join(" ", method.getAnnotation(Select.class).value());
+            assertTrue(sql.contains("rp.id=ri.source_inventory_position_id"));
+            assertTrue(sql.contains("rp.pallet_id=p.warehouse_pallet_id"));
+            assertTrue(sql.contains("ri.fba_carton_mark"));
+            assertTrue(sql.contains("AS relabelCartonMarks"));
+        }
+    }
+
    private void assertConstructorColumnOrder(Method method) {
        String sql = String.join(" ", method.getAnnotation(Select.class).value());
        int previous = -1;
@@ -226,6 +226,34 @@ class DispatchPdaWorkflowServiceTest {
        verify(outboundOrders, never()).updateById((OutboundOrder) any());
    }

+    @Test
+    void successfulDepartureRecordsActualDepartureTime() {
+        DispatchOrder order = order("100", "DSP-1", "WH-1", "READY_TO_DEPART");
+        order.setVehiclePlate("CA-100");
+        DispatchPdaTask task = task(11L, "100", "WH-1", "COMPLETED");
+        DispatchItem item = item(21L, "100", 6);
+        DispatchPdaPick pick = new DispatchPdaPick();
+        pick.setPackages(6L);
+        OutboundOrder outbound = new OutboundOrder();
+        outbound.setOutboundNo("OB-1");
+        outbound.setStatus("WAIT_OUTBOUND");
+        when(orders.findGlobalByDispatchNo("DSP-1")).thenReturn(order);
+        when(orders.lockById("100", 1L)).thenReturn(order);
+        when(outboundOrders.lockByDispatch("100", 1L)).thenReturn(outbound);
+        when(tasks.lockByDispatch("100", 1L)).thenReturn(task);
+        when(items.findByDispatchOrder("100", 1L)).thenReturn(List.of(item));
+        when(picks.totalItem("100", 11L, 21L)).thenReturn(6L);
+        when(picks.listTask("100", 11L)).thenReturn(List.of(pick));
+
+        DispatchPdaResponses.Departed result = service.depart("WH-1", "DSP-1", "7",
+            new DispatchPdaRequests.Depart("depart-success", null));
+
+        assertEquals("DEPARTED", result.status());
+        assertEquals("DEPARTED", order.getStatus());
+        assertTrue(order.getDepartAt() != null);
+        assertEquals("OUTBOUNDED", outbound.getStatus());
+    }
+
    @Test
    void exactDepartRetryReturnsPersistedResultAfterStatusChanged() throws Exception {
        DispatchOrder order = order("100", "DSP-1", "WH-1", "DEPARTED");
@@ -20,6 +20,7 @@ import com.baiyue.lastleg.dispatch.pda.entity.DispatchPdaTask;
 import com.baiyue.lastleg.dispatch.pda.mapper.DispatchPdaTaskMapper;
 import com.baiyue.lastleg.entity.LastlegOrder;
 import com.baiyue.lastleg.mapper.LastlegOrderMapper;
+import com.baiyue.lastleg.delivery.mapper.OutboundOrderMapper;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -55,6 +56,7 @@ class DispatchServiceTest {
    @Mock DispatchDraftContainerMapper draftContainers;
    @Mock DispatchPdaTaskMapper pdaTasks;
    @Mock LastlegOrderMapper tailOrders;
+    @Mock OutboundOrderMapper outboundOrders;
    private DispatchService service;

    @BeforeEach
@@ -68,6 +70,7 @@ class DispatchServiceTest {
        ReflectionTestUtils.setField(service, "draftContainers", draftContainers);
        ReflectionTestUtils.setField(service, "pdaTasks", pdaTasks);
        ReflectionTestUtils.setField(service, "tailOrders", tailOrders);
+        ReflectionTestUtils.setField(service, "outboundOrders", outboundOrders);
        ReflectionTestUtils.setField(service, "orderNoGenerator", new com.baiyue.lastleg.service.LastlegOrderNoGenerator());
        lenient().when(items.findByDispatchOrder(any(), any())).thenReturn(List.of());
        lenient().when(tailOrders.selectList(any())).thenReturn(List.of());
@@ -181,7 +184,7 @@ class DispatchServiceTest {
    }

    @Test
-    void preArrangeConvertsOwnedDraftLockInsteadOfInsertingAnotherLock() {
+    void preArrangeKeepsVirtualVehicleAndItsLocksEditableUntilOutboundExists() {
        when(candidates.lockSelected("100", List.of(10L))).thenReturn(List.of(candidate(10L, null, "ONT8")));
        DispatchPalletLock lock = new DispatchPalletLock();
        lock.setDraftToken("draft-1"); lock.setDraftContainerId(21L); lock.setOperatorId("7"); lock.setStatus("ACTIVE"); lock.setActiveKey("PLAN:10");
@@ -193,16 +196,40 @@ class DispatchServiceTest {
        service.preArrange("100", "7", new DispatchRequests.PreArrange(List.of(10L), null, null, null, null, "draft-1"));

        assertNotNull(lock.getDispatchOrderId());
-        assertNull(lock.getDraftToken());
-        assertNull(lock.getDraftContainerId());
-        assertEquals("RELEASED", draft.getStatus());
-        assertNotNull(draft.getReleasedAt());
+        assertEquals("draft-1", lock.getDraftToken());
+        assertEquals(21L, lock.getDraftContainerId());
+        assertEquals("ACTIVE", draft.getStatus());
+        assertNull(draft.getExpiresAt());
        verify(locks).updateById(lock);
        verify(locks, never()).insert(any(DispatchPalletLock.class));
-        verify(draftContainers).delete(any(LambdaQueryWrapper.class));
        verify(drafts).updateById(draft);
    }

+    @Test
+    void removingUnpickedPalletReleasesLockAndRefreshesDispatchTotals() {
+        DispatchOrder dispatch = new DispatchOrder();
+        dispatch.setId(1L); dispatch.setCustomerId("100"); dispatch.setDispatchNo("PC1");
+        dispatch.setStatus(DispatchService.PENDING_DEPARTURE); dispatch.setPickedPackageCount(0);
+        DispatchItem removed = new DispatchItem();
+        removed.setId(11L); removed.setPlanPalletId(10L); removed.setWarehousePalletId(20L);
+        DispatchItem remaining = new DispatchItem();
+        remaining.setId(12L); remaining.setPlanPalletId(12L); remaining.setPackageCount(7);
+        DispatchPalletLock lock = new DispatchPalletLock();
+        lock.setPlanPalletId(10L); lock.setStatus("ACTIVE"); lock.setActiveKey("PLAN:10");
+        when(orders.lockGlobalByDispatchNo("PC1")).thenReturn(dispatch);
+        when(items.lockById("100", 1L, 11L)).thenReturn(removed);
+        when(locks.selectList(any())).thenReturn(List.of(lock));
+        when(items.findByDispatchOrder("100", 1L)).thenReturn(List.of(remaining));
+
+        DispatchResponse result = service.removeItem("PC1", 11L);
+
+        assertEquals(1, result.palletCount());
+        assertEquals(7, result.packageCount());
+        assertEquals("RELEASED", lock.getStatus());
+        verify(items).deleteById(11L);
+        verify(orders).updateById(dispatch);
+    }
+
    @Test
    void activeDraftOnlyRestoresLocksStillOwnedByThatDraft() {
        DispatchDraft draft = new DispatchDraft();
@@ -24,7 +24,8 @@ class PdaPalletOperationControllerContractTest {
            .map(Method::getDeclaredAnnotations).flatMap(Arrays::stream)
            .filter(PostMapping.class::isInstance).map(PostMapping.class::cast)
            .flatMap(annotation -> Arrays.stream(annotation.value())).collect(Collectors.toSet());
-        assertEquals(Set.of("/pallets/resolve", "/assemble", "/disassemble", "/relabel-disassemble", "/swap", "/unbind"), paths);
+        assertEquals(Set.of("/pallets/resolve", "/relabel-pallet-label", "/assemble", "/disassemble",
+            "/relabel-disassemble", "/swap", "/unbind"), paths);
    }

    @Test void palletContentAnnotationUsesNativeGreaterThanOperator() throws Exception {
@@ -85,6 +85,22 @@ class PdaPalletOperationServiceTest {
        verifyNoInteractions(mapper);
    }

+    @Test void createsPrintableRelabelPalletForConfirmedApplication() {
+        RelabelApplication application = new RelabelApplication(); application.setRelabelNo("RL-1");
+        application.setStatus("READY_FOR_OUTBOUND"); application.setOverseasWarehouseId("88");
+        when(relabelApplications.findAnyByRelabelNo("RL-1")).thenReturn(application);
+        when(physical.ensureRelabelPallet(88L, "RL-1:new-pallet-1")).thenReturn(
+            new PalletPhysicalGateway.PalletReference(30L, "PAL-NEW-1", 88L, 1030L, "IDLE", null, 0));
+
+        var result = service.createRelabelPallet(identity(),
+            new PalletOperationRequests.NewRelabelPallet("RL-1", "new-pallet-1"));
+
+        assertEquals("PAL-NEW-1", result.palletCode());
+        assertEquals(0, result.palletVersion());
+        assertTrue(result.printableHtml().contains("托盘标签"));
+        assertTrue(result.printableHtml().contains("RL-1"));
+    }
+
    @Test void localConcurrencyFailureCompensatesEveryAppliedPhysicalTransitionInReverseSafeForm() {
        var source = new PalletPhysicalGateway.PalletReference(20L, "SOURCE", 88L, 1020L,
            "OCCUPIED", null, 1);
@@ -168,17 +184,14 @@ class PdaPalletOperationServiceTest {
        verifyNoInteractions(physical);
    }

-    @Test void relabelDisassembleMovesOnlySelectedHeldCarton() {
-        var sourcePallet = new PalletPhysicalGateway.PalletReference(20L, "SOURCE", 88L, 1020L,
+    @Test void relabelDisassembleMovesOnlySelectedHeldCartonWithoutRequiringLocations() {
+        var sourcePallet = new PalletPhysicalGateway.PalletReference(20L, "SOURCE", 88L, null,
            "OCCUPIED", null, 1);
-        var targetPallet = new PalletPhysicalGateway.PalletReference(10L, "TARGET", 88L, 1010L,
+        var targetPallet = new PalletPhysicalGateway.PalletReference(10L, "TARGET", 88L, null,
            "IDLE", null, 2);
        when(physical.resolve("SOURCE")).thenReturn(sourcePallet);
        when(physical.resolve("TARGET")).thenReturn(targetPallet);
-        when(physical.resolveLocation(eq(88L), anyLong())).thenAnswer(invocation ->
-            new PalletPhysicalGateway.LocationReference(invocation.getArgument(1), "LOC-" + invocation.getArgument(1),
-                "STORAGE", "ACTIVE"));
-        when(physical.apply(eq(88L), any(), anyString(), anyLong(), anyString(), any()))
+        when(physical.apply(eq(88L), any(), anyString(), isNull(), anyString(), any()))
            .thenAnswer(invocation -> transition(invocation.getArgument(1), invocation.getArgument(2)));

        RelabelApplication application = new RelabelApplication(); application.setId(600L);
@@ -219,10 +232,18 @@ class PdaPalletOperationServiceTest {
        assertEquals(1L, source.getHoldPackages());
        assertEquals(0L, source.getAvailablePackages());
        assertNotNull(target.get()); assertEquals(1L, target.get().getHoldPackages());
+        assertNull(target.get().getWarehouseLocationId());
+        assertNull(target.get().getWarehouseLocationCode());
+        verify(physical, never()).resolveLocation(anyLong(), anyLong());
        verify(relabelPalletMutations).moveSelectedItems(eq(application), anyMap(), argThat(targets ->
            targets.size() == 1 && targets.get(100L) == target.get()));
        verify(balances, never()).updateById(any(InventoryBalance.class));
        assertEquals("RELABEL_PALLET_DISASSEMBLE", operation.get().getOperationType());
+        ArgumentCaptor<InventoryLedger> ledger = ArgumentCaptor.forClass(InventoryLedger.class);
+        verify(ledgers, times(2)).insert(ledger.capture());
+        assertTrue(ledger.getAllValues().stream().allMatch(value -> "换标拆托：split".equals(value.getRemark())));
+        assertTrue(ledger.getAllValues().stream().anyMatch(value -> value.getDeltaPackages() == -1));
+        assertTrue(ledger.getAllValues().stream().anyMatch(value -> value.getDeltaPackages() == 1));
    }

    @Test void relabelDisassembleReplayDoesNotRevalidateChangedInventoryOrPallets() throws Exception {
@@ -28,6 +28,8 @@ import com.baiyue.lastleg.delivery.entity.OutboundPdaTask;
 import com.baiyue.lastleg.delivery.mapper.OutboundOrderMapper;
 import com.baiyue.lastleg.delivery.mapper.OutboundPalletItemMapper;
 import com.baiyue.lastleg.delivery.mapper.OutboundPdaTaskMapper;
+import com.baiyue.lastleg.transfer.entity.WarehouseTransferOrder;
+import com.baiyue.lastleg.transfer.mapper.WarehouseTransferOrderMapper;
 import com.baiyue.lastleg.financefee.entity.OverseasFeeSource;
 import com.baiyue.lastleg.financefee.service.OverseasFeeSourceService;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -71,6 +73,7 @@ class RelabelApplicationServiceTest {
    @Mock OutboundOrderMapper outboundOrders;
    @Mock OutboundPalletItemMapper outboundItems;
    @Mock OutboundPdaTaskMapper outboundTasks;
+    @Mock WarehouseTransferOrderMapper warehouseTransfers;
    @Mock OverseasFeeSourceService feeSources;
    @Spy LastlegOrderNoGenerator orderNoGenerator = new LastlegOrderNoGenerator();

@@ -92,6 +95,7 @@ class RelabelApplicationServiceTest {
        ReflectionTestUtils.setField(service, "outboundOrders", outboundOrders);
        ReflectionTestUtils.setField(service, "outboundItems", outboundItems);
        ReflectionTestUtils.setField(service, "outboundTasks", outboundTasks);
+        ReflectionTestUtils.setField(service, "warehouseTransfers", warehouseTransfers);
        ReflectionTestUtils.setField(service, "objectMapper", mapper());
        lenient().when(walletCommands.publish(any(), any(Long.class), any(), any(), any(), any(), any(Long.class))).thenReturn("wallet-event-1");
        lenient().when(inventoryPositions.findTenantPosition(any(), any())).thenAnswer(invocation -> {
@@ -363,6 +367,7 @@ class RelabelApplicationServiceTest {
    void completedReturnRelabelOrderEntersPendingAssignment() {
        RelabelApplication application = application(11L, "FBR-1", "10001", "key-1", "hash", RelabelApplicationService.READY_FOR_OUTBOUND);
        application.setLastlegOrderId(21L);
+        application.setFulfillmentStatus("PRE_DISPATCH_CREATED");
        LastlegOrder order = order(21L, "10001", "LMO-RELABEL-1", "PROCESSING");
        order.setOrderType("RETURN_RELABEL");
        when(applications.lockNo("10001", "FBR-1")).thenReturn(application);
@@ -373,6 +378,7 @@ class RelabelApplicationServiceTest {
            new RelabelRequests.ChangeStatus("COMPLETED", "finished"));

        assertEquals("COMPLETED", application.getStatus());
+        assertEquals("OUTBOUNDED", application.getFulfillmentStatus());
        assertEquals("PENDING_ASSIGNMENT", order.getCurrentStatus());
        assertEquals("COMPLETED", order.getRelabelStatus());
    }
@@ -416,6 +422,29 @@ class RelabelApplicationServiceTest {
        verify(applications, times(1)).updateById(application);
    }

+    @Test
+    void transferRelabelConfirmationReleasesTransferForDispatch() {
+        RelabelApplication application = confirmationApplication("TRUCK", false);
+        WarehouseTransferOrder transfer = new WarehouseTransferOrder();
+        transfer.setId(77L); transfer.setCustomerId("10001"); transfer.setRelabelNo("FBR-1");
+        transfer.setStatus("WAIT_RELABEL"); transfer.setLastlegOrderId(88L);
+        LastlegOrder transferOrder = order(88L, "10001", "LMO-TRANSFER-1", "WAIT_RELABEL");
+        when(applications.lockNo("10001", "FBR-1")).thenReturn(application);
+        stubDetail(application);
+        when(warehouseTransfers.lockByRelabelNo("10001", "FBR-1")).thenReturn(transfer);
+        when(orders.selectById(88L)).thenReturn(transferOrder);
+
+        service.confirmCompletion("10001", "FBR-1", "customer-1",
+            new RelabelRequests.CustomerConfirm("confirm-transfer", "accepted"));
+
+        assertEquals("READY_FOR_DISPATCH", transfer.getStatus());
+        assertNotNull(transfer.getRelabelCompletedAt());
+        assertEquals("READY_FOR_DISPATCH", transferOrder.getCurrentStatus());
+        assertEquals(RelabelApplicationService.READY_FOR_OUTBOUND, transferOrder.getRelabelStatus());
+        verify(warehouseTransfers).updateById(transfer);
+        verify(orders).updateById(transferOrder);
+    }
+
    @Test
    void expressCustomerConfirmationRequiresShippingLabelWhenWarehousePrintingIsSelected() {
        RelabelApplication application = confirmationApplication("EXPRESS", true);
@@ -0,0 +1,35 @@
+package com.baiyue.lastleg.transfer.controller;
+
+import com.baiyue.common.security.AuthenticatedUser;
+import com.baiyue.lastleg.security.OverseasPermissions;
+import com.baiyue.lastleg.transfer.dto.WarehouseTransferRequests;
+import org.junit.jupiter.api.Test;
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class WarehouseTransferControllerPermissionTest {
+    @Test
+    void readEndpointsAndReviewUseTheirDedicatedAuthorities() throws Exception {
+        PreAuthorize page = WarehouseTransferController.class
+            .getMethod("page", AuthenticatedUser.class, String.class, WarehouseTransferRequests.Query.class)
+            .getAnnotation(PreAuthorize.class);
+        PreAuthorize detail = WarehouseTransferController.class
+            .getMethod("detail", AuthenticatedUser.class, String.class, String.class)
+            .getAnnotation(PreAuthorize.class);
+        PreAuthorize cartonLabel = WarehouseTransferController.class
+            .getMethod("cartonLabel", AuthenticatedUser.class, String.class, String.class)
+            .getAnnotation(PreAuthorize.class);
+        PreAuthorize review = WarehouseTransferController.class
+            .getMethod("review", AuthenticatedUser.class, String.class, String.class,
+                WarehouseTransferRequests.Review.class)
+            .getAnnotation(PreAuthorize.class);
+
+        String readAuthority = "hasAuthority('" + OverseasPermissions.LAST_MILE_ORDER_LIST + "')";
+        assertThat(page.value()).isEqualTo(readAuthority);
+        assertThat(detail.value()).isEqualTo(readAuthority);
+        assertThat(cartonLabel.value()).isEqualTo(readAuthority);
+        assertThat(review.value()).isEqualTo(
+            "hasAuthority('" + OverseasPermissions.WAREHOUSE_TRANSFER_APPROVE + "')");
+    }
+}
@@ -0,0 +1,38 @@
+package com.baiyue.lastleg.transfer.dto;
+
+import jakarta.validation.Validation;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class WarehouseTransferPalletValidationTest {
+    @Test
+    void palletAcceptsDirectTotalVolumeAndWeightWithoutCartonDimensions() {
+        try (var factory = Validation.buildDefaultValidatorFactory()) {
+            var validator = factory.getValidator();
+            var pallet = new WarehouseTransferRequests.Pallet("PALLET-1", 5,
+                new BigDecimal("1.250000"), new BigDecimal("420.50"),
+                List.of(new WarehouseTransferRequests.PalletItem(101L, 5)));
+
+            assertTrue(validator.validate(pallet).isEmpty());
+            assertEquals(new BigDecimal("1.250000"), pallet.volumeCbm());
+            assertEquals(new BigDecimal("420.50"), pallet.grossWeightKg());
+        }
+    }
+
+    @Test
+    void palletRejectsNonPositiveTotalVolume() {
+        try (var factory = Validation.buildDefaultValidatorFactory()) {
+            var validator = factory.getValidator();
+            var pallet = new WarehouseTransferRequests.Pallet("PALLET-1", 5,
+                BigDecimal.ZERO, new BigDecimal("420.50"),
+                List.of(new WarehouseTransferRequests.PalletItem(101L, 5)));
+
+            assertEquals(1, validator.validate(pallet).size());
+        }
+    }
+}