package com.zy.ai.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.zy.ai.domain.autotune.AutoTuneParameterSnapshot;
|
import com.zy.ai.domain.autotune.AutoTuneSnapshot;
|
import com.zy.ai.domain.autotune.AutoTuneStationRuntimeItem;
|
import com.zy.ai.domain.autotune.AutoTuneTaskSnapshot;
|
import com.zy.ai.service.AutoTuneSnapshotService;
|
import com.zy.ai.service.FlowTopologySnapshotService;
|
import com.zy.asrs.domain.vo.StationCycleCapacityVo;
|
import com.zy.asrs.domain.vo.StationCycleLoopVo;
|
import com.zy.asrs.entity.BasCrnp;
|
import com.zy.asrs.entity.BasDualCrnp;
|
import com.zy.asrs.entity.BasStation;
|
import com.zy.asrs.entity.DeviceConfig;
|
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.WrkMastService;
|
import com.zy.core.cache.SlaveConnection;
|
import com.zy.core.enums.SlaveType;
|
import com.zy.core.enums.WrkStsType;
|
import com.zy.core.model.protocol.StationProtocol;
|
import com.zy.core.thread.StationThread;
|
import com.zy.system.service.ConfigService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collections;
|
import java.util.Date;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
@Service("autoTuneSnapshotService")
|
public class AutoTuneSnapshotServiceImpl implements AutoTuneSnapshotService {
|
|
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;
|
|
@Autowired
|
private WrkMastService wrkMastService;
|
|
@Autowired
|
private DeviceConfigService deviceConfigService;
|
|
@Autowired
|
private StationCycleCapacityService stationCycleCapacityService;
|
|
@Autowired
|
private FlowTopologySnapshotService flowTopologySnapshotService;
|
|
@Autowired
|
private ConfigService configService;
|
|
@Autowired
|
private BasStationService basStationService;
|
|
@Autowired
|
private BasCrnpService basCrnpService;
|
|
@Autowired
|
private BasDualCrnpService basDualCrnpService;
|
|
@Override
|
public AutoTuneSnapshot buildSnapshot() {
|
List<AutoTuneStationRuntimeItem> stationRuntimeSnapshot = buildStationRuntimeSnapshot();
|
|
AutoTuneSnapshot snapshot = new AutoTuneSnapshot();
|
snapshot.setTaskSnapshot(buildTaskSnapshot());
|
snapshot.setStationRuntimeSnapshot(stationRuntimeSnapshot);
|
snapshot.setCycleLoadSnapshot(buildCycleLoadSnapshot());
|
snapshot.setFlowTopologySnapshot(flowTopologySnapshotService.buildSnapshot(stationRuntimeSnapshot));
|
snapshot.setCurrentParameterSnapshot(buildCurrentParameterSnapshot());
|
snapshot.setSnapshotTime(new Date());
|
return snapshot;
|
}
|
|
private AutoTuneTaskSnapshot buildTaskSnapshot() {
|
List<WrkMast> activeTasks = loadActiveTasks();
|
|
AutoTuneTaskSnapshot snapshot = new AutoTuneTaskSnapshot();
|
snapshot.setActiveTaskCount(activeTasks.size());
|
snapshot.setByTargetStation(countByTargetStation(activeTasks));
|
snapshot.setByBatch(countByBatch(activeTasks));
|
snapshot.setByCrn(countByCrn(activeTasks));
|
snapshot.setByDualCrn(countByDualCrn(activeTasks));
|
snapshot.setByIoType(countByIoType(activeTasks));
|
return snapshot;
|
}
|
|
private List<WrkMast> loadActiveTasks() {
|
if (wrkMastService == null) {
|
return Collections.emptyList();
|
}
|
QueryWrapper<WrkMast> wrapper = new QueryWrapper<>();
|
wrapper.notIn("wrk_sts", Arrays.asList(
|
WrkStsType.COMPLETE_INBOUND.sts,
|
WrkStsType.SETTLE_INBOUND.sts,
|
WrkStsType.COMPLETE_OUTBOUND.sts,
|
WrkStsType.SETTLE_OUTBOUND.sts,
|
WrkStsType.COMPLETE_LOC_MOVE.sts,
|
WrkStsType.COMPLETE_CRN_MOVE.sts
|
));
|
return safeList(wrkMastService.list(wrapper));
|
}
|
|
private List<AutoTuneStationRuntimeItem> buildStationRuntimeSnapshot() {
|
if (deviceConfigService == null) {
|
return Collections.emptyList();
|
}
|
QueryWrapper<DeviceConfig> wrapper = new QueryWrapper<>();
|
wrapper.eq("device_type", String.valueOf(SlaveType.Devp));
|
wrapper.orderByAsc("device_no");
|
List<DeviceConfig> deviceConfigList = safeList(deviceConfigService.list(wrapper));
|
Map<Integer, AutoTuneStationRuntimeItem> runtimeMap = new LinkedHashMap<>();
|
for (DeviceConfig deviceConfig : deviceConfigList) {
|
appendStationRuntime(runtimeMap, deviceConfig);
|
}
|
return new ArrayList<>(runtimeMap.values());
|
}
|
|
private void appendStationRuntime(Map<Integer, AutoTuneStationRuntimeItem> runtimeMap, DeviceConfig deviceConfig) {
|
if (deviceConfig == null || deviceConfig.getDeviceNo() == null) {
|
return;
|
}
|
StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, deviceConfig.getDeviceNo());
|
if (stationThread == null || stationThread.getStatusMap() == null) {
|
return;
|
}
|
for (StationProtocol protocol : stationThread.getStatusMap().values()) {
|
AutoTuneStationRuntimeItem runtimeItem = toRuntimeItem(protocol);
|
if (runtimeItem != null) {
|
runtimeMap.put(runtimeItem.getStationId(), runtimeItem);
|
}
|
}
|
}
|
|
private AutoTuneStationRuntimeItem toRuntimeItem(StationProtocol protocol) {
|
if (protocol == null || protocol.getStationId() == null) {
|
return null;
|
}
|
AutoTuneStationRuntimeItem item = new AutoTuneStationRuntimeItem();
|
item.setStationId(protocol.getStationId());
|
item.setAutoing(protocol.isAutoing() ? 1 : 0);
|
item.setLoading(protocol.isLoading() ? 1 : 0);
|
item.setTaskNo(protocol.getTaskNo() == null ? 0 : protocol.getTaskNo());
|
item.setIoMode(protocol.getIoMode() == null ? null : String.valueOf(protocol.getIoMode()));
|
return item;
|
}
|
|
private Map<String, Object> buildCycleLoadSnapshot() {
|
if (stationCycleCapacityService == null) {
|
return new LinkedHashMap<>();
|
}
|
return toCycleLoadMap(stationCycleCapacityService.getLatestSnapshot());
|
}
|
|
private Map<String, Object> toCycleLoadMap(StationCycleCapacityVo cycleCapacityVo) {
|
Map<String, Object> result = new LinkedHashMap<>();
|
if (cycleCapacityVo == null) {
|
return result;
|
}
|
result.put("loopList", toLoopMapList(cycleCapacityVo.getLoopList()));
|
result.put("loopCount", cycleCapacityVo.getLoopCount());
|
result.put("totalStationCount", cycleCapacityVo.getTotalStationCount());
|
result.put("taskStationCount", cycleCapacityVo.getTaskStationCount());
|
result.put("manualStationCount", cycleCapacityVo.getManualStationCount());
|
result.put("occupiedStationCount", cycleCapacityVo.getOccupiedStationCount());
|
result.put("currentLoad", cycleCapacityVo.getCurrentLoad());
|
result.put("refreshTime", cycleCapacityVo.getRefreshTime());
|
return result;
|
}
|
|
private List<Map<String, Object>> toLoopMapList(List<StationCycleLoopVo> loopList) {
|
List<Map<String, Object>> result = new ArrayList<>();
|
for (StationCycleLoopVo loopVo : safeList(loopList)) {
|
if (loopVo == null) {
|
continue;
|
}
|
Map<String, Object> loopMap = new LinkedHashMap<>();
|
loopMap.put("loopNo", loopVo.getLoopNo());
|
loopMap.put("stationIdList", loopVo.getStationIdList());
|
loopMap.put("workNoList", loopVo.getWorkNoList());
|
loopMap.put("stationCount", loopVo.getStationCount());
|
loopMap.put("taskCount", loopVo.getTaskCount());
|
loopMap.put("manualStationCount", loopVo.getManualStationCount());
|
loopMap.put("occupiedStationCount", loopVo.getOccupiedStationCount());
|
loopMap.put("currentLoad", loopVo.getCurrentLoad());
|
result.add(loopMap);
|
}
|
return result;
|
}
|
|
private AutoTuneParameterSnapshot buildCurrentParameterSnapshot() {
|
AutoTuneParameterSnapshot snapshot = new AutoTuneParameterSnapshot();
|
snapshot.setCrnOutBatchRunningLimit(readConfigInt(
|
"crnOutBatchRunningLimit",
|
DEFAULT_CRN_OUT_BATCH_RUNNING_LIMIT
|
));
|
snapshot.setConveyorStationTaskLimit(readConfigInt(
|
"conveyorStationTaskLimit",
|
DEFAULT_CONVEYOR_STATION_TASK_LIMIT
|
));
|
snapshot.setAiAutoTuneIntervalMinutes(readConfigInt(
|
"aiAutoTuneIntervalMinutes",
|
DEFAULT_AI_AUTO_TUNE_INTERVAL_MINUTES
|
));
|
List<BasCrnp> crnList = loadCrnList();
|
List<BasDualCrnp> dualCrnList = loadDualCrnList();
|
snapshot.setStationOutTaskLimits(loadStationOutTaskLimits());
|
snapshot.setCrnMaxOutTask(buildCrnMaxOutTask(crnList));
|
snapshot.setCrnMaxInTask(buildCrnMaxInTask(crnList));
|
snapshot.setDualCrnMaxOutTask(buildDualCrnMaxOutTask(dualCrnList));
|
snapshot.setDualCrnMaxInTask(buildDualCrnMaxInTask(dualCrnList));
|
return snapshot;
|
}
|
|
private int readConfigInt(String code, int defaultValue) {
|
if (configService == null) {
|
return defaultValue;
|
}
|
String value = configService.getConfigValue(code, String.valueOf(defaultValue));
|
if (value == null || value.trim().isEmpty()) {
|
return defaultValue;
|
}
|
try {
|
return Integer.parseInt(value.trim());
|
} catch (NumberFormatException exception) {
|
return defaultValue;
|
}
|
}
|
|
private Map<String, Integer> loadStationOutTaskLimits() {
|
Map<String, Integer> result = new LinkedHashMap<>();
|
if (basStationService == null) {
|
return result;
|
}
|
QueryWrapper<BasStation> wrapper = new QueryWrapper<>();
|
wrapper.orderByAsc("station_id");
|
return buildStationOutTaskLimitMap(basStationService.list(wrapper));
|
}
|
|
Map<String, Integer> buildStationOutTaskLimitMap(List<BasStation> stationList) {
|
Map<String, Integer> result = new LinkedHashMap<>();
|
for (BasStation station : safeList(stationList)) {
|
if (station != null && station.getStationId() != null) {
|
result.put(String.valueOf(station.getStationId()), station.getOutTaskLimit());
|
}
|
}
|
return result;
|
}
|
|
private Map<String, Integer> buildCrnMaxOutTask(List<BasCrnp> crnList) {
|
Map<String, Integer> result = new LinkedHashMap<>();
|
for (BasCrnp crn : safeList(crnList)) {
|
if (crn == null || crn.getCrnNo() == null) {
|
continue;
|
}
|
result.put(String.valueOf(crn.getCrnNo()), defaultInt(crn.getMaxOutTask()));
|
}
|
return result;
|
}
|
|
private Map<String, Integer> buildCrnMaxInTask(List<BasCrnp> crnList) {
|
Map<String, Integer> result = new LinkedHashMap<>();
|
for (BasCrnp crn : safeList(crnList)) {
|
if (crn == null || crn.getCrnNo() == null) {
|
continue;
|
}
|
result.put(String.valueOf(crn.getCrnNo()), defaultInt(crn.getMaxInTask()));
|
}
|
return result;
|
}
|
|
private Map<String, Integer> buildDualCrnMaxOutTask(List<BasDualCrnp> dualCrnList) {
|
Map<String, Integer> result = new LinkedHashMap<>();
|
for (BasDualCrnp dualCrn : safeList(dualCrnList)) {
|
if (dualCrn == null || dualCrn.getCrnNo() == null) {
|
continue;
|
}
|
result.put(String.valueOf(dualCrn.getCrnNo()), defaultInt(dualCrn.getMaxOutTask()));
|
}
|
return result;
|
}
|
|
private Map<String, Integer> buildDualCrnMaxInTask(List<BasDualCrnp> dualCrnList) {
|
Map<String, Integer> result = new LinkedHashMap<>();
|
for (BasDualCrnp dualCrn : safeList(dualCrnList)) {
|
if (dualCrn == null || dualCrn.getCrnNo() == null) {
|
continue;
|
}
|
result.put(String.valueOf(dualCrn.getCrnNo()), defaultInt(dualCrn.getMaxInTask()));
|
}
|
return result;
|
}
|
|
private List<BasCrnp> loadCrnList() {
|
if (basCrnpService == null) {
|
return Collections.emptyList();
|
}
|
QueryWrapper<BasCrnp> wrapper = new QueryWrapper<>();
|
wrapper.orderByAsc("crn_no");
|
return safeList(basCrnpService.list(wrapper));
|
}
|
|
private List<BasDualCrnp> loadDualCrnList() {
|
if (basDualCrnpService == null) {
|
return Collections.emptyList();
|
}
|
QueryWrapper<BasDualCrnp> wrapper = new QueryWrapper<>();
|
wrapper.orderByAsc("crn_no");
|
return safeList(basDualCrnpService.list(wrapper));
|
}
|
|
private Map<String, Integer> countByTargetStation(List<WrkMast> activeTasks) {
|
Map<String, Integer> result = new LinkedHashMap<>();
|
for (WrkMast task : activeTasks) {
|
increment(result, task == null ? null : task.getStaNo());
|
}
|
return result;
|
}
|
|
private Map<String, Integer> countByBatch(List<WrkMast> activeTasks) {
|
Map<String, Integer> result = new LinkedHashMap<>();
|
for (WrkMast task : activeTasks) {
|
String batch = task == null ? null : task.getBatch();
|
if (batch != null && !batch.trim().isEmpty()) {
|
increment(result, batch.trim());
|
}
|
}
|
return result;
|
}
|
|
private Map<String, Integer> countByCrn(List<WrkMast> activeTasks) {
|
Map<String, Integer> result = new LinkedHashMap<>();
|
for (WrkMast task : activeTasks) {
|
increment(result, task == null ? null : task.getCrnNo());
|
}
|
return result;
|
}
|
|
private Map<String, Integer> countByDualCrn(List<WrkMast> activeTasks) {
|
Map<String, Integer> result = new LinkedHashMap<>();
|
for (WrkMast task : activeTasks) {
|
increment(result, task == null ? null : task.getDualCrnNo());
|
}
|
return result;
|
}
|
|
private Map<String, Integer> countByIoType(List<WrkMast> activeTasks) {
|
Map<String, Integer> result = new LinkedHashMap<>();
|
for (WrkMast task : activeTasks) {
|
increment(result, task == null ? null : task.getIoType());
|
}
|
return result;
|
}
|
|
private void increment(Map<String, Integer> result, Integer key) {
|
if (key == null) {
|
return;
|
}
|
increment(result, String.valueOf(key));
|
}
|
|
private void increment(Map<String, Integer> result, String key) {
|
if (key == null || key.trim().isEmpty()) {
|
return;
|
}
|
String normalizedKey = key.trim();
|
result.put(normalizedKey, result.getOrDefault(normalizedKey, 0) + 1);
|
}
|
|
private int defaultInt(Integer value) {
|
return value == null ? 0 : value;
|
}
|
|
private <T> List<T> safeList(List<T> value) {
|
return value == null ? Collections.emptyList() : value;
|
}
|
}
|
