package com.zy.asrs.service.impl;
|
|
import com.alibaba.fastjson.JSON;
|
import com.zy.asrs.domain.enums.CrnStatusType;
|
import com.zy.asrs.domain.enums.StationStatusType;
|
import com.zy.asrs.domain.vo.CrnLatestDataVo;
|
import com.zy.asrs.domain.vo.RgvLatestDataVo;
|
import com.zy.asrs.domain.vo.StationLatestDataVo;
|
import com.zy.asrs.entity.BasCrnpErr;
|
import com.zy.asrs.entity.DeviceDataLog;
|
import com.zy.asrs.entity.WrkLastno;
|
import com.zy.asrs.entity.WrkMast;
|
import com.zy.asrs.service.BasCrnpErrService;
|
import com.zy.asrs.service.DeviceLogReplayNormalizer;
|
import com.zy.asrs.service.WrkLastnoService;
|
import com.zy.asrs.service.WrkMastService;
|
import com.zy.core.enums.CrnModeType;
|
import com.zy.core.enums.DualCrnModeType;
|
import com.zy.core.enums.RgvStatusType;
|
import com.zy.core.enums.SlaveType;
|
import com.zy.core.enums.WrkIoType;
|
import com.zy.core.model.protocol.CrnProtocol;
|
import com.zy.core.model.protocol.DualCrnProtocol;
|
import com.zy.core.model.protocol.RgvProtocol;
|
import com.zy.core.model.protocol.StationProtocol;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.concurrent.ConcurrentHashMap;
|
|
@Service
|
public class DeviceLogReplayNormalizerImpl implements DeviceLogReplayNormalizer {
|
|
private static final int MAX_WRK_MAST_CACHE_SIZE = 4096;
|
|
@Autowired
|
private WrkMastService wrkMastService;
|
@Autowired
|
private WrkLastnoService wrkLastnoService;
|
@Autowired
|
private BasCrnpErrService basCrnpErrService;
|
|
private final Map<Integer, WrkMast> wrkMastCache = new ConcurrentHashMap<>();
|
private final Map<Integer, WrkLastno> wrkLastnoCache = new ConcurrentHashMap<>();
|
private final Map<Integer, BasCrnpErr> basCrnpErrCache = new ConcurrentHashMap<>();
|
|
@Override
|
public Object normalizeState(DeviceDataLog logItem) {
|
if (logItem == null || logItem.getType() == null || logItem.getWcsData() == null || logItem.getWcsData().isBlank()) {
|
return null;
|
}
|
SlaveType slaveType = SlaveType.findInstance(logItem.getType());
|
if (slaveType == null) {
|
return null;
|
}
|
if (slaveType == SlaveType.Crn) {
|
return normalizeCrn(logItem);
|
}
|
if (slaveType == SlaveType.DualCrn) {
|
return normalizeDualCrn(logItem);
|
}
|
if (slaveType == SlaveType.Rgv) {
|
return normalizeRgv(logItem);
|
}
|
if (slaveType == SlaveType.Devp) {
|
return normalizeStation(logItem);
|
}
|
return null;
|
}
|
|
@Override
|
public Map<String, Object> buildFrame(Long timestamp, Long sampleSeq, Map<String, Object> stateByStream) {
|
List<StationLatestDataVo> stationStates = new ArrayList<>();
|
List<CrnLatestDataVo> crnStates = new ArrayList<>();
|
List<CrnLatestDataVo> dualCrnStates = new ArrayList<>();
|
List<RgvLatestDataVo> rgvStates = new ArrayList<>();
|
List<Map<String, Object>> abnormalList = new ArrayList<>();
|
|
for (Map.Entry<String, Object> entry : stateByStream.entrySet()) {
|
Object state = entry.getValue();
|
StreamIdentity identity = parseStreamIdentity(entry.getKey());
|
if (state instanceof StationLatestDataVo) {
|
StationLatestDataVo stationState = (StationLatestDataVo) state;
|
stationStates.add(compactStationState(stationState));
|
collectStationAbnormal(abnormalList, stationState, identity);
|
continue;
|
}
|
if (state instanceof CrnLatestDataVo) {
|
CrnLatestDataVo crnState = (CrnLatestDataVo) state;
|
if (entry.getKey() != null && entry.getKey().contains("|DualCrn|")) {
|
dualCrnStates.add(compactDualCrnState(crnState));
|
} else {
|
crnStates.add(compactCrnState(crnState));
|
}
|
collectCrnAbnormal(abnormalList, crnState);
|
continue;
|
}
|
if (state instanceof RgvLatestDataVo) {
|
RgvLatestDataVo rgvState = (RgvLatestDataVo) state;
|
rgvStates.add(compactRgvState(rgvState));
|
collectRgvAbnormal(abnormalList, rgvState);
|
}
|
}
|
|
Map<String, Object> frame = new LinkedHashMap<>();
|
frame.put("timestamp", timestamp);
|
frame.put("sampleSeq", sampleSeq);
|
frame.put("stationStates", stationStates);
|
frame.put("crnStates", crnStates);
|
frame.put("dualCrnStates", dualCrnStates);
|
frame.put("rgvStates", rgvStates);
|
frame.put("abnormalList", abnormalList);
|
frame.put("summary", buildSummary(stationStates, crnStates, dualCrnStates, rgvStates, abnormalList));
|
return frame;
|
}
|
|
@Override
|
public Map<String, Object> buildCompactFrame(Long timestamp, Long sampleSeq, Map<String, Object> stateByStream) {
|
int stationCount = 0;
|
int crnCount = 0;
|
int dualCrnCount = 0;
|
int rgvCount = 0;
|
List<Map<String, Object>> abnormalList = new ArrayList<>();
|
|
for (Map.Entry<String, Object> entry : stateByStream.entrySet()) {
|
Object state = entry.getValue();
|
StreamIdentity identity = parseStreamIdentity(entry.getKey());
|
if (state instanceof StationLatestDataVo) {
|
stationCount++;
|
collectStationAbnormal(abnormalList, (StationLatestDataVo) state, identity);
|
continue;
|
}
|
if (state instanceof CrnLatestDataVo) {
|
if (entry.getKey() != null && entry.getKey().contains("|DualCrn|")) {
|
dualCrnCount++;
|
} else {
|
crnCount++;
|
}
|
collectCrnAbnormal(abnormalList, (CrnLatestDataVo) state);
|
continue;
|
}
|
if (state instanceof RgvLatestDataVo) {
|
rgvCount++;
|
collectRgvAbnormal(abnormalList, (RgvLatestDataVo) state);
|
}
|
}
|
|
Map<String, Object> summary = new LinkedHashMap<>();
|
summary.put("stationCount", stationCount);
|
summary.put("crnCount", crnCount);
|
summary.put("dualCrnCount", dualCrnCount);
|
summary.put("rgvCount", rgvCount);
|
summary.put("abnormalCount", abnormalList.size());
|
summary.put("errorCount", abnormalList.stream().filter(item -> "ERROR".equals(item.get("level"))).count());
|
summary.put("blockCount", abnormalList.stream().filter(item -> "BLOCK".equals(item.get("level"))).count());
|
|
Map<String, Object> frame = new LinkedHashMap<>();
|
frame.put("timestamp", timestamp);
|
frame.put("sampleSeq", sampleSeq);
|
frame.put("abnormalList", abnormalList);
|
frame.put("summary", summary);
|
return frame;
|
}
|
|
private StationLatestDataVo compactStationState(StationLatestDataVo stationState) {
|
StationLatestDataVo compact = new StationLatestDataVo();
|
compact.setStationId(stationState.getStationId());
|
compact.setTaskNo(stationState.getTaskNo());
|
compact.setTargetStaNo(stationState.getTargetStaNo());
|
compact.setAutoing(stationState.isAutoing());
|
compact.setLoading(stationState.isLoading());
|
compact.setInEnable(stationState.isInEnable());
|
compact.setOutEnable(stationState.isOutEnable());
|
compact.setEmptyMk(stationState.isEmptyMk());
|
compact.setFullPlt(stationState.isFullPlt());
|
compact.setRunBlock(stationState.isRunBlock());
|
compact.setInBarcodeError(stationState.isInBarcodeError());
|
compact.setPalletHeight(stationState.getPalletHeight());
|
compact.setError(stationState.getError());
|
compact.setBarcode(stationState.getBarcode());
|
compact.setStationStatus(stationState.getStationStatus());
|
return compact;
|
}
|
|
private CrnLatestDataVo compactCrnState(CrnLatestDataVo crnState) {
|
CrnLatestDataVo compact = new CrnLatestDataVo();
|
compact.setCrnId(crnState.getCrnId());
|
compact.setCrnNo(crnState.getCrnNo());
|
compact.setCrnStatusType(crnState.getCrnStatusType());
|
compact.setBay(crnState.getBay());
|
compact.setLev(crnState.getLev());
|
compact.setTaskNo(crnState.getTaskNo());
|
compact.setWorkNo(crnState.getWorkNo());
|
compact.setMode(crnState.getMode());
|
compact.setStatus(crnState.getStatus());
|
compact.setLoading(crnState.getLoading());
|
compact.setForkOffset(crnState.getForkOffset());
|
compact.setLiftPos(crnState.getLiftPos());
|
compact.setWalkPos(crnState.getWalkPos());
|
compact.setTaskReceive(crnState.getTaskReceive());
|
compact.setSourceLocNo(crnState.getSourceLocNo());
|
compact.setLocNo(crnState.getLocNo());
|
compact.setDeviceStatus(crnState.getDeviceStatus());
|
return compact;
|
}
|
|
private CrnLatestDataVo compactDualCrnState(CrnLatestDataVo crnState) {
|
CrnLatestDataVo compact = new CrnLatestDataVo();
|
compact.setCrnId(crnState.getCrnId());
|
compact.setCrnNo(crnState.getCrnNo());
|
compact.setCrnStatusType(crnState.getCrnStatusType());
|
compact.setBay(crnState.getBay());
|
compact.setLev(crnState.getLev());
|
compact.setTaskNo(crnState.getTaskNo());
|
compact.setTaskNoTwo(crnState.getTaskNoTwo());
|
compact.setMode(crnState.getMode());
|
compact.setStatus(crnState.getStatus());
|
compact.setStatusTwo(crnState.getStatusTwo());
|
compact.setLoading(crnState.getLoading());
|
compact.setLoadingTwo(crnState.getLoadingTwo());
|
compact.setForkOffset(crnState.getForkOffset());
|
compact.setForkOffsetTwo(crnState.getForkOffsetTwo());
|
compact.setLiftPos(crnState.getLiftPos());
|
compact.setWalkPos(crnState.getWalkPos());
|
compact.setTaskReceive(crnState.getTaskReceive());
|
compact.setTaskReceiveTwo(crnState.getTaskReceiveTwo());
|
compact.setDeviceStatus(crnState.getDeviceStatus());
|
return compact;
|
}
|
|
private RgvLatestDataVo compactRgvState(RgvLatestDataVo rgvState) {
|
RgvLatestDataVo compact = new RgvLatestDataVo();
|
compact.setRgvNo(rgvState.getRgvNo());
|
compact.setTaskNo(rgvState.getTaskNo());
|
compact.setTrackSiteNo(rgvState.getTrackSiteNo());
|
compact.setRgvStatusType(rgvState.getRgvStatusType());
|
return compact;
|
}
|
|
private CrnLatestDataVo normalizeCrn(DeviceDataLog logItem) {
|
CrnProtocol protocol = JSON.parseObject(logItem.getWcsData(), CrnProtocol.class);
|
if (protocol == null) {
|
return null;
|
}
|
CrnLatestDataVo vo = new CrnLatestDataVo();
|
vo.setCrnId(protocol.getCrnNo());
|
vo.setCrnNo(protocol.getCrnNo());
|
vo.setOffset(protocol.getBay() == null ? 0D : Double.valueOf(protocol.getBay()));
|
vo.setBay(protocol.getBay());
|
vo.setLev(protocol.getLevel());
|
vo.setTaskNo(protocol.getTaskNo());
|
vo.setWorkNo(protocol.getTaskNo());
|
vo.setMode(resolveCrnMode(protocol));
|
vo.setStatus(resolveCrnStatus(protocol));
|
vo.setLoading(protocol.getLoaded() != null && protocol.getLoaded() == 1 ? "有物" : "无物");
|
vo.setForkOffset(resolveCrnForkOffset(protocol));
|
vo.setLiftPos(resolveCrnLiftPos(protocol));
|
vo.setWalkPos(protocol.getWalkPos() != null && protocol.getWalkPos() == 1 ? "不在定位" : "在定位");
|
vo.setTaskReceive(protocol.getTaskReceive() == null ? "-" : String.valueOf(protocol.getTaskReceive()));
|
vo.setXspeed(formatDecimal(protocol.getXSpeed()));
|
vo.setYspeed(formatDecimal(protocol.getYSpeed()));
|
vo.setZspeed(formatDecimal(protocol.getZSpeed()));
|
vo.setWeight(protocol.getWeight());
|
vo.setBarcode(protocol.getBarcode());
|
vo.setWarnCode(protocol.getAlarm() == null ? "-" : String.valueOf(protocol.getAlarm()));
|
vo.setAlarm(resolveCrnAlarm(protocol.getAlarm()));
|
vo.setLaserValue(protocol.getLaserValue());
|
vo.setExtend(protocol.getExtend());
|
vo.setDeviceStatus(resolveCrnDeviceStatus(protocol));
|
if (protocol.getAlarm() != null && protocol.getAlarm() > 0) {
|
vo.setCrnStatus(CrnStatusType.MACHINE_ERROR);
|
return vo;
|
}
|
if (protocol.getTaskNo() != null && protocol.getTaskNo() > 0) {
|
WrkMast wrkMast = getWrkMast(protocol.getTaskNo());
|
if (wrkMast != null) {
|
vo.setSourceLocNo(wrkMast.getSourceLocNo());
|
vo.setLocNo(wrkMast.getLocNo());
|
vo.setCrnStatus(CrnStatusType.process(wrkMast.getIoType()));
|
return vo;
|
}
|
}
|
vo.setCrnStatus(protocol.getModeType() == CrnModeType.AUTO
|
? CrnStatusType.MACHINE_AUTO
|
: CrnStatusType.MACHINE_UN_AUTO);
|
return vo;
|
}
|
|
private CrnLatestDataVo normalizeDualCrn(DeviceDataLog logItem) {
|
DualCrnProtocol protocol = JSON.parseObject(logItem.getWcsData(), DualCrnProtocol.class);
|
if (protocol == null) {
|
return null;
|
}
|
CrnLatestDataVo vo = new CrnLatestDataVo();
|
vo.setCrnId(protocol.getCrnNo() == null ? logItem.getDeviceNo() : protocol.getCrnNo());
|
vo.setCrnNo(vo.getCrnId());
|
Integer bay = protocol.getBay() != null ? protocol.getBay() : protocol.getBayTwo();
|
Integer taskNo = protocol.getTaskNo() != null && protocol.getTaskNo() > 0
|
? protocol.getTaskNo()
|
: protocol.getTaskNoTwo();
|
vo.setBay(bay);
|
vo.setOffset(bay == null ? 0D : Double.valueOf(bay));
|
vo.setTaskNo(taskNo);
|
vo.setTaskNoTwo(protocol.getTaskNoTwo());
|
vo.setDeviceTaskNo(protocol.getDeviceTaskNo());
|
vo.setDeviceTaskNoTwo(protocol.getDeviceTaskNoTwo());
|
vo.setMode(resolveDualCrnMode(protocol));
|
vo.setStatus(resolveDualCrnStatus(protocol));
|
vo.setStatusTwo(resolveDualCrnStatusTwo(protocol));
|
vo.setLoading(protocol.getLoaded() != null && protocol.getLoaded() == 1 ? "有物" : "无物");
|
vo.setLoadingTwo(protocol.getLoadedTwo() != null && protocol.getLoadedTwo() == 1 ? "有物" : "无物");
|
vo.setLev(protocol.getLevel());
|
vo.setForkOffset(resolveDualCrnForkOffset(protocol));
|
vo.setForkOffsetTwo(resolveDualCrnForkOffsetTwo(protocol));
|
vo.setLiftPos(resolveDualCrnLiftPos(protocol));
|
vo.setWalkPos(protocol.getWalkPos() != null && protocol.getWalkPos() == 0 ? "在定位" : "不在定位");
|
vo.setTaskReceive(protocol.getTaskReceive() == null ? "-" : String.valueOf(protocol.getTaskReceive()));
|
vo.setTaskReceiveTwo(protocol.getTaskReceiveTwo() == null ? "-" : String.valueOf(protocol.getTaskReceiveTwo()));
|
vo.setTaskSend(protocol.getTaskSend() == null ? "-" : String.valueOf(protocol.getTaskSend()));
|
vo.setTaskSendTwo(protocol.getTaskSendTwo() == null ? "-" : String.valueOf(protocol.getTaskSendTwo()));
|
vo.setXspeed(formatDecimal(protocol.getXSpeed()));
|
vo.setYspeed(formatDecimal(protocol.getYSpeed()));
|
vo.setZspeed(formatDecimal(protocol.getZSpeed()));
|
vo.setWarnCode(protocol.getAlarm() == null ? "-" : String.valueOf(protocol.getAlarm()));
|
vo.setExtend(protocol.getExtend());
|
vo.setDeviceStatus(resolveDualCrnDeviceStatus(protocol));
|
if (protocol.getAlarm() != null && protocol.getAlarm() > 0) {
|
vo.setCrnStatus(CrnStatusType.MACHINE_ERROR);
|
} else {
|
vo.setCrnStatus(protocol.getModeType() == DualCrnModeType.AUTO
|
? CrnStatusType.MACHINE_AUTO
|
: CrnStatusType.MACHINE_UN_AUTO);
|
}
|
return vo;
|
}
|
|
private RgvLatestDataVo normalizeRgv(DeviceDataLog logItem) {
|
RgvProtocol protocol = JSON.parseObject(logItem.getWcsData(), RgvProtocol.class);
|
if (protocol == null) {
|
return null;
|
}
|
RgvLatestDataVo vo = new RgvLatestDataVo();
|
vo.setRgvNo(protocol.getRgvNo());
|
vo.setTaskNo(protocol.getTaskNo());
|
vo.setTrackSiteNo(String.valueOf(protocol.getRgvPos()));
|
vo.setRgvStatus(RgvStatusType.get(protocol.getStatus()));
|
return vo;
|
}
|
|
private StationLatestDataVo normalizeStation(DeviceDataLog logItem) {
|
StationProtocol protocol = JSON.parseObject(logItem.getWcsData(), StationProtocol.class);
|
if (protocol == null) {
|
return null;
|
}
|
WrkLastno inTaskRange = getWrkLastno(WrkIoType.IN.id);
|
WrkLastno outTaskRange = getWrkLastno(WrkIoType.OUT.id);
|
|
StationLatestDataVo vo = new StationLatestDataVo();
|
vo.setStationId(protocol.getStationId());
|
vo.setTaskNo(protocol.getTaskNo());
|
vo.setTargetStaNo(protocol.getTargetStaNo());
|
vo.setAutoing(protocol.isAutoing());
|
vo.setLoading(protocol.isLoading());
|
vo.setInEnable(protocol.isInEnable());
|
vo.setOutEnable(protocol.isOutEnable());
|
vo.setEmptyMk(protocol.isEmptyMk());
|
vo.setFullPlt(protocol.isFullPlt());
|
vo.setRunBlock(protocol.isRunBlock());
|
vo.setEnableIn(protocol.isEnableIn());
|
vo.setInBarcodeError(protocol.isInBarcodeError());
|
vo.setPalletHeight(protocol.getPalletHeight());
|
vo.setError(protocol.getError());
|
vo.setErrorMsg(protocol.getErrorMsg());
|
vo.setBarcode(protocol.getBarcode());
|
vo.setSystemWarning(protocol.getSystemWarning());
|
vo.setWeight(protocol.getWeight());
|
vo.setIoMode(protocol.getIoMode());
|
vo.setTaskWriteIdx(protocol.getTaskWriteIdx());
|
vo.setTaskBufferItems(protocol.getTaskBufferItems());
|
StationStatusType statusType = StationStatusType.process(protocol);
|
String stationStatus = statusType == null ? "site-unauto" : statusType.toString().toLowerCase().replaceAll("_", "-");
|
if (protocol.isAutoing() && protocol.isLoading() && protocol.getTaskNo() != null && protocol.getTaskNo() > 0 && !protocol.isRunBlock()) {
|
String taskClass = getStationTaskClass(protocol.getTaskNo(), inTaskRange, outTaskRange);
|
if (taskClass != null) {
|
stationStatus = taskClass;
|
}
|
}
|
vo.setStationStatus(stationStatus);
|
return vo;
|
}
|
|
private String getStationTaskClass(Integer taskNo, WrkLastno inTaskRange, WrkLastno outTaskRange) {
|
if (taskNo == null || taskNo <= 0) {
|
return null;
|
}
|
if (isInRange(taskNo, inTaskRange)) {
|
return "machine-pakin";
|
}
|
if (isInRange(taskNo, outTaskRange)) {
|
return "machine-pakout";
|
}
|
return null;
|
}
|
|
private boolean isInRange(Integer taskNo, WrkLastno taskRange) {
|
if (taskRange == null || taskRange.getsNo() == null || taskRange.geteNo() == null) {
|
return false;
|
}
|
return taskNo >= taskRange.getsNo() && taskNo <= taskRange.geteNo();
|
}
|
|
private void collectStationAbnormal(List<Map<String, Object>> abnormalList, StationLatestDataVo stationState, StreamIdentity identity) {
|
if (stationState.getError() != null && stationState.getError() > 0) {
|
abnormalList.add(buildAbnormal("Devp", identity.deviceNo, stationState.getStationId(), "ERROR",
|
"站点故障", stationState.getErrorMsg()));
|
return;
|
}
|
if (stationState.isRunBlock()) {
|
abnormalList.add(buildAbnormal("Devp", identity.deviceNo, stationState.getStationId(), "BLOCK",
|
"站点堵塞", "任务号 " + stationState.getTaskNo()));
|
return;
|
}
|
if (!stationState.isAutoing()) {
|
abnormalList.add(buildAbnormal("Devp", identity.deviceNo, stationState.getStationId(), "MANUAL",
|
"站点手动", "当前不在自动模式"));
|
}
|
}
|
|
private void collectCrnAbnormal(List<Map<String, Object>> abnormalList, CrnLatestDataVo crnState) {
|
if (crnState.getCrnStatus() != null && "machine-error".equals(crnState.getCrnStatus())) {
|
abnormalList.add(buildAbnormal("Crn", crnState.getCrnId(), null, "ERROR",
|
"堆垛机故障", "任务号 " + crnState.getTaskNo()));
|
}
|
}
|
|
private void collectRgvAbnormal(List<Map<String, Object>> abnormalList, RgvLatestDataVo rgvState) {
|
if ("none".equals(rgvState.getRgvStatus())) {
|
abnormalList.add(buildAbnormal("Rgv", rgvState.getRgvNo(), null, "OFFLINE",
|
"RGV离线", "轨道位 " + rgvState.getTrackSiteNo()));
|
}
|
}
|
|
private Map<String, Object> buildSummary(List<StationLatestDataVo> stationStates,
|
List<CrnLatestDataVo> crnStates,
|
List<CrnLatestDataVo> dualCrnStates,
|
List<RgvLatestDataVo> rgvStates,
|
List<Map<String, Object>> abnormalList) {
|
Map<String, Object> summary = new LinkedHashMap<>();
|
summary.put("stationCount", stationStates.size());
|
summary.put("crnCount", crnStates.size());
|
summary.put("dualCrnCount", dualCrnStates.size());
|
summary.put("rgvCount", rgvStates.size());
|
summary.put("abnormalCount", abnormalList.size());
|
summary.put("errorCount", abnormalList.stream().filter(item -> "ERROR".equals(item.get("level"))).count());
|
summary.put("blockCount", abnormalList.stream().filter(item -> "BLOCK".equals(item.get("level"))).count());
|
return summary;
|
}
|
|
private Map<String, Object> buildAbnormal(String type, Integer deviceNo, Integer stationId, String level, String title, String detail) {
|
Map<String, Object> abnormal = new LinkedHashMap<>();
|
abnormal.put("type", type);
|
abnormal.put("deviceNo", deviceNo);
|
abnormal.put("stationId", stationId);
|
abnormal.put("level", level);
|
abnormal.put("title", title);
|
abnormal.put("detail", detail);
|
return abnormal;
|
}
|
|
private Map<String, Object> buildTarget(String type, Integer deviceNo, Integer stationId, String title, String detail) {
|
Map<String, Object> target = new LinkedHashMap<>();
|
target.put("type", type);
|
target.put("deviceNo", deviceNo);
|
target.put("stationId", stationId);
|
target.put("title", title);
|
target.put("detail", detail);
|
return target;
|
}
|
|
private StreamIdentity parseStreamIdentity(String streamId) {
|
StreamIdentity identity = new StreamIdentity();
|
if (streamId == null || streamId.isBlank()) {
|
return identity;
|
}
|
String[] parts = streamId.split("\\|");
|
if (parts.length >= 3) {
|
identity.type = parts[1];
|
identity.deviceNo = parseInteger(parts[2]);
|
}
|
if (parts.length >= 4) {
|
identity.stationId = parseInteger(parts[3]);
|
}
|
return identity;
|
}
|
|
private Integer parseInteger(String value) {
|
try {
|
return value == null || value.isBlank() ? null : Integer.parseInt(value);
|
} catch (Exception e) {
|
return null;
|
}
|
}
|
|
private String resolveCrnMode(CrnProtocol protocol) {
|
if (protocol == null || protocol.getModeType() == null) {
|
return "-";
|
}
|
return protocol.getModeType().desc;
|
}
|
|
private String resolveCrnStatus(CrnProtocol protocol) {
|
if (protocol == null || protocol.getStatusType() == null) {
|
return "-";
|
}
|
return protocol.getStatusType().desc;
|
}
|
|
private String resolveCrnForkOffset(CrnProtocol protocol) {
|
if (protocol == null || protocol.getForkPosType() == null) {
|
return "-";
|
}
|
return protocol.getForkPosType().desc;
|
}
|
|
private String resolveCrnLiftPos(CrnProtocol protocol) {
|
if (protocol == null || protocol.getLiftPosType() == null) {
|
return "-";
|
}
|
return protocol.getLiftPosType().desc;
|
}
|
|
private String resolveDualCrnMode(DualCrnProtocol protocol) {
|
if (protocol == null || protocol.getModeType() == null) {
|
return "-";
|
}
|
return protocol.getModeType().desc;
|
}
|
|
private String resolveDualCrnStatus(DualCrnProtocol protocol) {
|
if (protocol == null || protocol.getStatusType() == null) {
|
return "-";
|
}
|
return protocol.getStatusType().desc;
|
}
|
|
private String resolveDualCrnStatusTwo(DualCrnProtocol protocol) {
|
if (protocol == null || protocol.getStatusTypeTwo() == null) {
|
return "-";
|
}
|
return protocol.getStatusTypeTwo().desc;
|
}
|
|
private String resolveDualCrnForkOffset(DualCrnProtocol protocol) {
|
if (protocol == null || protocol.getForkPosType() == null) {
|
return "-";
|
}
|
return protocol.getForkPosType().desc;
|
}
|
|
private String resolveDualCrnForkOffsetTwo(DualCrnProtocol protocol) {
|
if (protocol == null || protocol.getForkPosTypeTwo() == null) {
|
return "-";
|
}
|
return protocol.getForkPosTypeTwo().desc;
|
}
|
|
private String resolveDualCrnLiftPos(DualCrnProtocol protocol) {
|
if (protocol == null || protocol.getLiftPosType() == null) {
|
return "-";
|
}
|
return protocol.getLiftPosType().desc;
|
}
|
|
private String formatDecimal(Number value) {
|
if (value == null) {
|
return "-";
|
}
|
return String.format("%.2f", value.doubleValue());
|
}
|
|
private String resolveCrnAlarm(Integer alarmCode) {
|
if (alarmCode == null || alarmCode <= 0) {
|
return "-";
|
}
|
BasCrnpErr alarm = getBasCrnpErr(alarmCode);
|
return alarm == null ? "未知异常" : alarm.getErrName();
|
}
|
|
private WrkMast getWrkMast(Integer taskNo) {
|
if (taskNo == null || taskNo <= 0) {
|
return null;
|
}
|
if (wrkMastCache.size() > MAX_WRK_MAST_CACHE_SIZE) {
|
wrkMastCache.clear();
|
}
|
return wrkMastCache.computeIfAbsent(taskNo, wrkMastService::getById);
|
}
|
|
private WrkLastno getWrkLastno(Integer id) {
|
if (id == null || id <= 0) {
|
return null;
|
}
|
return wrkLastnoCache.computeIfAbsent(id, wrkLastnoService::getById);
|
}
|
|
private BasCrnpErr getBasCrnpErr(Integer alarmCode) {
|
if (alarmCode == null || alarmCode <= 0) {
|
return null;
|
}
|
return basCrnpErrCache.computeIfAbsent(alarmCode, basCrnpErrService::getById);
|
}
|
|
private String resolveCrnDeviceStatus(CrnProtocol protocol) {
|
if (protocol == null) {
|
return "OFFLINE";
|
}
|
if (protocol.getAlarm() != null && protocol.getAlarm() > 0) {
|
return "ERROR";
|
}
|
if (protocol.getTaskNo() != null && protocol.getTaskNo() > 0) {
|
return "WORKING";
|
}
|
if (protocol.getModeType() == CrnModeType.AUTO) {
|
return "AUTO";
|
}
|
return "OFFLINE";
|
}
|
|
private String resolveDualCrnDeviceStatus(DualCrnProtocol protocol) {
|
if (protocol == null) {
|
return "OFFLINE";
|
}
|
if (protocol.getAlarm() != null && protocol.getAlarm() > 0) {
|
return "ERROR";
|
}
|
boolean hasTask = protocol.getTaskNo() != null && protocol.getTaskNo() > 0
|
|| protocol.getTaskNoTwo() != null && protocol.getTaskNoTwo() > 0;
|
if (hasTask) {
|
return "WORKING";
|
}
|
if (protocol.getModeType() == DualCrnModeType.AUTO) {
|
return "AUTO";
|
}
|
return "OFFLINE";
|
}
|
|
private static class StreamIdentity {
|
private String type;
|
private Integer deviceNo;
|
private Integer stationId;
|
}
|
}
|
