fix: filter auto tune out station limits

Junjie

2026-04-27 cd04aa8b887e82ec664e42f0bc353c079be1d2c5

fix: filter auto tune out station limits

 src/main/java/com/zy/ai/service/impl/AutoTuneSnapshotServiceImpl.java

@@ -13,12 +13,14 @@
import com.zy.asrs.entity.BasDualCrnp;
import com.zy.asrs.entity.BasStation;
import com.zy.asrs.entity.DeviceConfig;
import com.zy.asrs.entity.StationFlowCapacity;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.BasCrnpService;
import com.zy.asrs.service.BasDualCrnpService;
import com.zy.asrs.service.BasStationService;
import com.zy.asrs.service.DeviceConfigService;
import com.zy.asrs.service.StationCycleCapacityService;
import com.zy.asrs.service.StationFlowCapacityService;
import com.zy.asrs.service.WrkMastService;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.SlaveType;
@@ -33,9 +35,11 @@
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.LinkedHashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

@Service("autoTuneSnapshotService")
public class AutoTuneSnapshotServiceImpl implements AutoTuneSnapshotService {
@@ -43,6 +47,7 @@
    private static final int DEFAULT_CRN_OUT_BATCH_RUNNING_LIMIT = 5;
    private static final int DEFAULT_CONVEYOR_STATION_TASK_LIMIT = 30;
    private static final int DEFAULT_AI_AUTO_TUNE_INTERVAL_MINUTES = 10;
    private static final String DIRECTION_OUT = "OUT";

    @Autowired
    private WrkMastService wrkMastService;
@@ -61,6 +66,9 @@

    @Autowired
    private BasStationService basStationService;

    @Autowired
    private StationFlowCapacityService stationFlowCapacityService;

    @Autowired
    private BasCrnpService basCrnpService;
@@ -244,11 +252,33 @@
        if (basStationService == null) {
            return result;
        }
        Set<Integer> outStationIds = loadOutStationIds();
        if (outStationIds.isEmpty()) {
            return result;
        }
        QueryWrapper<BasStation> wrapper = new QueryWrapper<>();
        wrapper.in("station_id", outStationIds);
        wrapper.orderByAsc("station_id");
        return buildStationOutTaskLimitMap(basStationService.list(wrapper));
    }

    private Set<Integer> loadOutStationIds() {
        LinkedHashSet<Integer> stationIds = new LinkedHashSet<>();
        if (stationFlowCapacityService == null) {
            return stationIds;
        }
        QueryWrapper<StationFlowCapacity> wrapper = new QueryWrapper<>();
        wrapper.eq("direction_code", DIRECTION_OUT);
        wrapper.orderByAsc("station_id");
        List<StationFlowCapacity> capacityList = safeList(stationFlowCapacityService.list(wrapper));
        for (StationFlowCapacity capacity : capacityList) {
            if (capacity != null && capacity.getStationId() != null) {
                stationIds.add(capacity.getStationId());
            }
        }
        return stationIds;
    }

    Map<String, Integer> buildStationOutTaskLimitMap(List<BasStation> stationList) {
        Map<String, Integer> result = new LinkedHashMap<>();
        for (BasStation station : safeList(stationList)) {

 src/test/java/com/zy/ai/service/impl/AutoTuneSnapshotServiceImplTest.java

@@ -2,7 +2,10 @@

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.zy.asrs.entity.BasStation;
import com.zy.asrs.entity.StationFlowCapacity;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.BasStationService;
import com.zy.asrs.service.StationFlowCapacityService;
import com.zy.asrs.service.WrkMastService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -18,6 +21,7 @@
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@@ -61,10 +65,61 @@
        assertTrue(normalizedSqlSegment.contains("OR wrk_sts IS NULL"));
    }

    @Test
    void loadStationOutTaskLimitsOnlyQueriesConfiguredOutDirectionStations() {
        BasStationService basStationService = mock(BasStationService.class);
        StationFlowCapacityService stationFlowCapacityService = mock(StationFlowCapacityService.class);
        ReflectionTestUtils.setField(service, "basStationService", basStationService);
        ReflectionTestUtils.setField(service, "stationFlowCapacityService", stationFlowCapacityService);
        when(stationFlowCapacityService.list(any(Wrapper.class))).thenReturn(Arrays.asList(
                capacity(101, "OUT"),
                capacity(102, "OUT")
        ));
        when(basStationService.list(any(Wrapper.class))).thenReturn(Arrays.asList(
                station(101, 2),
                station(102, 3)
        ));

        Map<String, Integer> result = ReflectionTestUtils.invokeMethod(service, "loadStationOutTaskLimits");

        assertEquals(2, result.size());
        assertEquals(2, result.get("101"));
        assertEquals(3, result.get("102"));

        ArgumentCaptor<Wrapper<StationFlowCapacity>> capacityWrapperCaptor = ArgumentCaptor.forClass(Wrapper.class);
        verify(stationFlowCapacityService).list(capacityWrapperCaptor.capture());
        assertTrue(capacityWrapperCaptor.getValue().getSqlSegment().contains("direction_code ="));

        ArgumentCaptor<Wrapper<BasStation>> stationWrapperCaptor = ArgumentCaptor.forClass(Wrapper.class);
        verify(basStationService).list(stationWrapperCaptor.capture());
        assertTrue(stationWrapperCaptor.getValue().getSqlSegment().contains("station_id IN"));
    }

    @Test
    void loadStationOutTaskLimitsDoesNotQueryStationsWhenNoOutCapacityExists() {
        BasStationService basStationService = mock(BasStationService.class);
        StationFlowCapacityService stationFlowCapacityService = mock(StationFlowCapacityService.class);
        ReflectionTestUtils.setField(service, "basStationService", basStationService);
        ReflectionTestUtils.setField(service, "stationFlowCapacityService", stationFlowCapacityService);
        when(stationFlowCapacityService.list(any(Wrapper.class))).thenReturn(Collections.emptyList());

        Map<String, Integer> result = ReflectionTestUtils.invokeMethod(service, "loadStationOutTaskLimits");

        assertTrue(result.isEmpty());
        verify(basStationService, never()).list(any(Wrapper.class));
    }

    private BasStation station(Integer stationId, Integer outTaskLimit) {
        BasStation station = new BasStation();
        station.setStationId(stationId);
        station.setOutTaskLimit(outTaskLimit);
        return station;
    }

    private StationFlowCapacity capacity(Integer stationId, String directionCode) {
        StationFlowCapacity capacity = new StationFlowCapacity();
        capacity.setStationId(stationId);
        capacity.setDirectionCode(directionCode);
        return capacity;
    }
}