package com.zy.ai.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.zy.ai.domain.autotune.AutoTuneFlowTopologyItem;
|
import com.zy.ai.domain.autotune.AutoTuneStationRuntimeItem;
|
import com.zy.ai.service.FlowTopologySnapshotService;
|
import com.zy.asrs.entity.StationFlowCapacity;
|
import com.zy.asrs.service.StationFlowCapacityService;
|
import com.zy.common.utils.NavigateUtils;
|
import lombok.Data;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
@Service("flowTopologySnapshotService")
|
public class FlowTopologySnapshotServiceImpl implements FlowTopologySnapshotService {
|
|
@Autowired
|
private StationFlowCapacityService stationFlowCapacityService;
|
|
@Autowired
|
private NavigateUtils navigateUtils;
|
|
@Override
|
public List<AutoTuneFlowTopologyItem> buildSnapshot(List<AutoTuneStationRuntimeItem> stationRuntimeSnapshot) {
|
List<StationFlowCapacity> capacities = loadCapacityList();
|
Map<Integer, List<Integer>> adjacencyMap = loadSortedAdjacencyMap();
|
List<AutoTuneFlowTopologyItem> itemList = new ArrayList<>();
|
for (StationFlowCapacity capacity : capacities) {
|
if (capacity == null || capacity.getStationId() == null) {
|
continue;
|
}
|
itemList.add(buildTopologyItem(capacity, adjacencyMap, stationRuntimeSnapshot));
|
}
|
return itemList;
|
}
|
|
public AutoTuneFlowTopologyItem buildTopologyItem(StationFlowCapacity capacity,
|
Map<Integer, List<Integer>> adjacencyMap,
|
List<AutoTuneStationRuntimeItem> stationRuntimeSnapshot) {
|
Integer targetStationId = capacity.getStationId();
|
Integer bufferCapacity = defaultInt(capacity.getBufferCapacity());
|
List<Integer> adjacentStationIds = sortedList(adjacencyMap == null ? null : adjacencyMap.get(targetStationId));
|
List<Integer> flowStationIds = buildFlowStationIds(targetStationId, adjacentStationIds);
|
List<AutoTuneStationRuntimeItem> flowRuntimeItems = filterRuntimeByStationIds(stationRuntimeSnapshot, flowStationIds);
|
RuntimeCount runtimeCount = calculateRuntimeCount(flowRuntimeItems);
|
|
AutoTuneFlowTopologyItem item = new AutoTuneFlowTopologyItem();
|
item.setTargetStationId(targetStationId);
|
item.setDirection(capacity.getDirectionCode());
|
// 当前只有后端无向站点图可用，保守地把排序相邻站同时作为上下游候选。
|
item.setUpstreamStationIds(adjacentStationIds);
|
item.setDownstreamStationIds(adjacentStationIds);
|
item.setFlowStationIds(flowStationIds);
|
item.setBufferCapacity(bufferCapacity);
|
item.setOccupiedCount(runtimeCount.getOccupiedCount());
|
item.setFreeCount(Math.max(0, bufferCapacity - runtimeCount.getOccupiedCount()));
|
item.setNonAutoingCount(runtimeCount.getNonAutoingCount());
|
item.setLoadingCount(runtimeCount.getLoadingCount());
|
item.setTaskHoldingCount(runtimeCount.getTaskHoldingCount());
|
return item;
|
}
|
|
public RuntimeCount calculateRuntimeCount(List<AutoTuneStationRuntimeItem> runtimeItems) {
|
RuntimeCount count = new RuntimeCount();
|
if (runtimeItems == null || runtimeItems.isEmpty()) {
|
return count;
|
}
|
for (AutoTuneStationRuntimeItem runtimeItem : runtimeItems) {
|
if (runtimeItem == null) {
|
continue;
|
}
|
boolean autoing = Objects.equals(runtimeItem.getAutoing(), 1);
|
boolean loading = Objects.equals(runtimeItem.getLoading(), 1);
|
boolean taskHolding = runtimeItem.getTaskNo() != null && runtimeItem.getTaskNo() > 0;
|
if (!autoing) {
|
count.nonAutoingCount++;
|
}
|
if (loading) {
|
count.loadingCount++;
|
}
|
if (taskHolding) {
|
count.taskHoldingCount++;
|
}
|
if (loading || taskHolding) {
|
count.occupiedCount++;
|
}
|
}
|
return count;
|
}
|
|
public StationFlowCapacity findCapacity(List<StationFlowCapacity> capacities,
|
Integer stationId,
|
String directionCode) {
|
if (capacities == null || stationId == null || directionCode == null) {
|
return null;
|
}
|
for (StationFlowCapacity capacity : capacities) {
|
if (capacity == null) {
|
continue;
|
}
|
if (Objects.equals(capacity.getStationId(), stationId)
|
&& directionCode.equals(capacity.getDirectionCode())) {
|
return capacity;
|
}
|
}
|
return null;
|
}
|
|
private List<StationFlowCapacity> loadCapacityList() {
|
if (stationFlowCapacityService == null) {
|
return Collections.emptyList();
|
}
|
QueryWrapper<StationFlowCapacity> wrapper = new QueryWrapper<>();
|
wrapper.orderByAsc("station_id", "direction_code");
|
List<StationFlowCapacity> capacityList = stationFlowCapacityService.list(wrapper);
|
return capacityList == null ? Collections.emptyList() : capacityList;
|
}
|
|
private Map<Integer, List<Integer>> loadSortedAdjacencyMap() {
|
if (navigateUtils == null) {
|
return Collections.emptyMap();
|
}
|
Map<Integer, Set<Integer>> graph = navigateUtils.loadUndirectedStationGraphSnapshot();
|
if (graph == null || graph.isEmpty()) {
|
return Collections.emptyMap();
|
}
|
return graph.entrySet().stream()
|
.filter(entry -> entry.getKey() != null)
|
.collect(Collectors.toMap(
|
Map.Entry::getKey,
|
entry -> sortedList(entry.getValue())
|
));
|
}
|
|
private List<Integer> buildFlowStationIds(Integer targetStationId,
|
List<Integer> adjacentStationIds) {
|
LinkedHashSet<Integer> stationIds = new LinkedHashSet<>();
|
if (targetStationId != null) {
|
stationIds.add(targetStationId);
|
}
|
stationIds.addAll(sortedList(adjacentStationIds));
|
return new ArrayList<>(stationIds);
|
}
|
|
private List<AutoTuneStationRuntimeItem> filterRuntimeByStationIds(List<AutoTuneStationRuntimeItem> runtimeItems,
|
List<Integer> stationIds) {
|
if (runtimeItems == null || runtimeItems.isEmpty() || stationIds == null || stationIds.isEmpty()) {
|
return Collections.emptyList();
|
}
|
Set<Integer> stationIdSet = new LinkedHashSet<>(stationIds);
|
return runtimeItems.stream()
|
.filter(item -> item != null && stationIdSet.contains(item.getStationId()))
|
.collect(Collectors.toList());
|
}
|
|
private static List<Integer> sortedList(Iterable<Integer> values) {
|
if (values == null) {
|
return new ArrayList<>();
|
}
|
List<Integer> result = new ArrayList<>();
|
for (Integer value : values) {
|
if (value != null) {
|
result.add(value);
|
}
|
}
|
result.sort(Comparator.naturalOrder());
|
return result;
|
}
|
|
private int defaultInt(Integer value) {
|
return value == null ? 0 : value;
|
}
|
|
@Data
|
public static class RuntimeCount {
|
private int occupiedCount;
|
private int nonAutoingCount;
|
private int loadingCount;
|
private int taskHoldingCount;
|
}
|
}
|
