package com.zy.asrs.service.impl;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONObject;
|
import com.alibaba.fastjson.TypeReference;
|
import com.alibaba.fastjson.serializer.SerializerFeature;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.core.common.Cools;
|
import com.core.exception.CoolException;
|
import com.zy.asrs.domain.BasMapEditorDoc;
|
import com.zy.asrs.domain.BasMapEditorElement;
|
import com.zy.asrs.entity.BasDevp;
|
import com.zy.asrs.entity.BasMap;
|
import com.zy.asrs.entity.BasStation;
|
import com.zy.asrs.entity.DeviceConfig;
|
import com.zy.asrs.service.BasDevpService;
|
import com.zy.asrs.service.BasMapEditorService;
|
import com.zy.asrs.service.BasMapService;
|
import com.zy.asrs.service.BasStationService;
|
import com.zy.asrs.service.DeviceConfigService;
|
import com.zy.asrs.utils.MapExcelUtils;
|
import com.zy.common.utils.RedisUtil;
|
import com.zy.core.enums.RedisKeyType;
|
import com.zy.core.enums.SlaveType;
|
import com.zy.core.model.StationObjModel;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.io.IOException;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collections;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.LinkedHashMap;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.TreeSet;
|
|
@Service("basMapEditorService")
|
public class BasMapEditorServiceImpl implements BasMapEditorService {
|
|
private static final String FREE_EDITOR_MODE = "free-v1";
|
private static final Set<String> RUNTIME_TYPES = new HashSet<>(Arrays.asList(
|
"shelf", "crn", "dualCrn", "devp", "rgv"
|
));
|
private static final int DEFAULT_ROW_HEIGHT = 200;
|
private static final int DEFAULT_COL_WIDTH = 1000;
|
private static final double DEFAULT_CANVAS_WIDTH = 4200D;
|
private static final double DEFAULT_CANVAS_HEIGHT = 5200D;
|
private static final int X_SCALE = 40;
|
private static final int Y_SCALE = 8;
|
|
@Autowired
|
private BasMapService basMapService;
|
@Autowired
|
private BasDevpService basDevpService;
|
@Autowired
|
private DeviceConfigService deviceConfigService;
|
@Autowired
|
private BasStationService basStationService;
|
@Autowired
|
private MapExcelUtils mapExcelUtils;
|
@Autowired
|
private RedisUtil redisUtil;
|
|
@Override
|
public BasMapEditorDoc getEditorDoc(Integer lev) {
|
BasMap basMap = basMapService.getOne(new QueryWrapper<BasMap>().eq("lev", lev));
|
if (basMap == null) {
|
return null;
|
}
|
BasMapEditorDoc editorDoc = parseEditorDocJson(lev, basMap.getOriginData());
|
if (editorDoc != null) {
|
return editorDoc;
|
}
|
if (Cools.isEmpty(basMap.getData())) {
|
return null;
|
}
|
return toFreeEditorDoc(lev, parseStoredMapData(basMap.getData()));
|
}
|
|
@Override
|
public List<BasMapEditorDoc> importExcelToEditorDocs(String filePath) throws IOException {
|
HashMap<Integer, List<List<HashMap<String, Object>>>> rawDataMap = mapExcelUtils.readExcel(filePath);
|
List<Integer> levList = new ArrayList<>(rawDataMap.keySet());
|
Collections.sort(levList);
|
|
List<BasMapEditorDoc> result = new ArrayList<>();
|
for (Integer lev : levList) {
|
List<List<HashMap<String, Object>>> storedData = convertRawExcelData(rawDataMap.get(lev));
|
result.add(toFreeEditorDoc(lev, storedData));
|
}
|
return result;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void importExcelAndPersist(String filePath) throws IOException {
|
HashMap<Integer, List<List<HashMap<String, Object>>>> rawDataMap = mapExcelUtils.readExcel(filePath);
|
List<Integer> levList = new ArrayList<>(rawDataMap.keySet());
|
Collections.sort(levList);
|
for (Integer lev : levList) {
|
List<List<HashMap<String, Object>>> storedData = convertRawExcelData(rawDataMap.get(lev));
|
persistFloorMap(lev, storedData, toFreeEditorDoc(lev, storedData));
|
}
|
rebuildDeviceAndStationSync();
|
clearMapCaches();
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void saveEditorDoc(BasMapEditorDoc doc) {
|
BasMapEditorDoc normalizedDoc = normalizeFreeDoc(doc);
|
List<List<HashMap<String, Object>>> storedData = compileToStoredMapData(normalizedDoc);
|
persistFloorMap(normalizedDoc.getLev(), storedData, normalizedDoc);
|
rebuildDeviceAndStationSync();
|
clearMapCaches();
|
}
|
|
private void persistFloorMap(Integer lev,
|
List<List<HashMap<String, Object>>> storedData,
|
BasMapEditorDoc editorDoc) {
|
if (lev == null || lev <= 0) {
|
throw new CoolException("楼层不能为空");
|
}
|
String dataJson = JSON.toJSONString(storedData);
|
String editorJson = JSON.toJSONString(editorDoc);
|
BasMap basMap = basMapService.getOne(new QueryWrapper<BasMap>().eq("lev", lev));
|
Date now = new Date();
|
if (basMap == null) {
|
basMap = new BasMap();
|
basMap.setCreateTime(now);
|
} else {
|
basMap.setLastData(basMap.getData());
|
}
|
basMap.setLev(lev);
|
basMap.setData(dataJson);
|
basMap.setOriginData(editorJson);
|
basMap.setUpdateTime(now);
|
basMapService.saveOrUpdate(basMap);
|
}
|
|
private BasMapEditorDoc parseEditorDocJson(Integer lev, String json) {
|
if (Cools.isEmpty(json)) {
|
return null;
|
}
|
try {
|
JSONObject object = JSON.parseObject(json);
|
if (object == null || !FREE_EDITOR_MODE.equals(object.getString("editorMode"))) {
|
return null;
|
}
|
BasMapEditorDoc doc = JSON.toJavaObject(object, BasMapEditorDoc.class);
|
if (doc == null) {
|
return null;
|
}
|
if (doc.getLev() == null || doc.getLev() <= 0) {
|
doc.setLev(lev);
|
}
|
return normalizeFreeDoc(doc);
|
} catch (Exception ignore) {
|
return null;
|
}
|
}
|
|
private BasMapEditorDoc toFreeEditorDoc(Integer lev, List<List<HashMap<String, Object>>> storedData) {
|
BasMapEditorDoc doc = new BasMapEditorDoc();
|
doc.setLev(lev);
|
doc.setEditorMode(FREE_EDITOR_MODE);
|
doc.setElements(new ArrayList<>());
|
if (storedData == null) {
|
doc.setCanvasWidth(DEFAULT_CANVAS_WIDTH);
|
doc.setCanvasHeight(DEFAULT_CANVAS_HEIGHT);
|
return doc;
|
}
|
|
int rowCount = storedData.size();
|
int colCount = 0;
|
for (List<HashMap<String, Object>> row : storedData) {
|
if (row != null && row.size() > colCount) {
|
colCount = row.size();
|
}
|
}
|
|
List<Integer> rowHeights = new ArrayList<>();
|
for (int r = 0; r < rowCount; r++) {
|
rowHeights.add(extractRowHeight(storedData, r));
|
}
|
List<Integer> colWidths = new ArrayList<>();
|
for (int c = 0; c < colCount; c++) {
|
colWidths.add(extractColWidth(storedData, c));
|
}
|
|
int[] yOffsets = new int[rowCount];
|
int[] xOffsets = new int[colCount];
|
int totalHeight = 0;
|
for (int r = 0; r < rowCount; r++) {
|
yOffsets[r] = totalHeight;
|
totalHeight += rowHeights.get(r);
|
}
|
int totalWidth = 0;
|
for (int c = 0; c < colCount; c++) {
|
xOffsets[c] = totalWidth;
|
totalWidth += colWidths.get(c);
|
}
|
|
List<BasMapEditorElement> elements = new ArrayList<>();
|
for (int r = 0; r < rowCount; r++) {
|
List<HashMap<String, Object>> row = storedData.get(r);
|
if (row == null) {
|
continue;
|
}
|
for (int c = 0; c < row.size(); c++) {
|
HashMap<String, Object> cell = row.get(c);
|
String type = normalizeType(getString(cell, "type", "none"));
|
if (!RUNTIME_TYPES.contains(type)) {
|
continue;
|
}
|
int rowSpan = Math.max(1, toInt(cell == null ? null : cell.get("rowSpan"), 1));
|
int colSpan = Math.max(1, toInt(cell == null ? null : cell.get("colSpan"), 1));
|
int widthRaw = 0;
|
for (int cc = c; cc < Math.min(c + colSpan, colWidths.size()); cc++) {
|
widthRaw += colWidths.get(cc);
|
}
|
int heightRaw = 0;
|
for (int rr = r; rr < Math.min(r + rowSpan, rowHeights.size()); rr++) {
|
heightRaw += rowHeights.get(rr);
|
}
|
BasMapEditorElement element = new BasMapEditorElement();
|
element.setId("el_" + r + "_" + c);
|
element.setType(type);
|
element.setX(xOffsets[c] / (double) X_SCALE);
|
element.setY(yOffsets[r] / (double) Y_SCALE);
|
element.setWidth(widthRaw / (double) X_SCALE);
|
element.setHeight(heightRaw / (double) Y_SCALE);
|
element.setValue(stringifyValue(cell == null ? null : cell.get("value")));
|
elements.add(element);
|
}
|
}
|
|
doc.setElements(elements);
|
doc.setCanvasWidth(Math.max(DEFAULT_CANVAS_WIDTH, totalWidth / (double) X_SCALE + 120D));
|
doc.setCanvasHeight(Math.max(DEFAULT_CANVAS_HEIGHT, totalHeight / (double) Y_SCALE + 120D));
|
return normalizeFreeDoc(doc);
|
}
|
|
private BasMapEditorDoc normalizeFreeDoc(BasMapEditorDoc source) {
|
if (source == null || source.getLev() == null || source.getLev() <= 0) {
|
throw new CoolException("楼层不能为空");
|
}
|
BasMapEditorDoc doc = new BasMapEditorDoc();
|
doc.setLev(source.getLev());
|
doc.setEditorMode(FREE_EDITOR_MODE);
|
doc.setCanvasWidth(toPositiveCanvasValue(source.getCanvasWidth(), DEFAULT_CANVAS_WIDTH, "画布宽度"));
|
doc.setCanvasHeight(toPositiveCanvasValue(source.getCanvasHeight(), DEFAULT_CANVAS_HEIGHT, "画布高度"));
|
|
List<BasMapEditorElement> elements = new ArrayList<>();
|
List<BasMapEditorElement> sourceElements = source.getElements();
|
if (sourceElements != null) {
|
for (int i = 0; i < sourceElements.size(); i++) {
|
elements.add(normalizeElement(sourceElements.get(i), i + 1));
|
}
|
}
|
ensureNoRectOverlap(elements);
|
doc.setElements(elements);
|
return doc;
|
}
|
|
private BasMapEditorElement normalizeElement(BasMapEditorElement source, int index) {
|
BasMapEditorElement element = new BasMapEditorElement();
|
element.setId(Cools.isEmpty(source == null ? null : source.getId()) ? "el_" + index : source.getId().trim());
|
element.setType(normalizeType(source == null ? null : source.getType()));
|
if (!RUNTIME_TYPES.contains(element.getType())) {
|
throw new CoolException("存在不支持的节点类型: " + element.getType());
|
}
|
double x = toNonNegativeDouble(source == null ? null : source.getX(), "元素 X 坐标");
|
double y = toNonNegativeDouble(source == null ? null : source.getY(), "元素 Y 坐标");
|
double width = toPositiveCanvasValue(source == null ? null : source.getWidth(), 0D, "元素宽度");
|
double height = toPositiveCanvasValue(source == null ? null : source.getHeight(), 0D, "元素高度");
|
element.setX(x);
|
element.setY(y);
|
element.setWidth(width);
|
element.setHeight(height);
|
element.setValue(stringifyValue(source == null ? null : source.getValue()));
|
if ("devp".equals(element.getType())) {
|
validateDevpValue(element.getValue(), index);
|
}
|
return element;
|
}
|
|
private void ensureNoRectOverlap(List<BasMapEditorElement> elements) {
|
for (int i = 0; i < elements.size(); i++) {
|
BasMapEditorElement a = elements.get(i);
|
for (int j = i + 1; j < elements.size(); j++) {
|
BasMapEditorElement b = elements.get(j);
|
if (rectanglesOverlap(a, b)) {
|
throw new CoolException("元素存在重叠: " + a.getId() + " 与 " + b.getId());
|
}
|
}
|
}
|
}
|
|
private boolean rectanglesOverlap(BasMapEditorElement a, BasMapEditorElement b) {
|
int aLeft = toRawWidth(a.getX());
|
int aTop = toRawHeight(a.getY());
|
int aRight = toRawWidth(safeDouble(a.getX()) + safeDouble(a.getWidth()));
|
int aBottom = toRawHeight(safeDouble(a.getY()) + safeDouble(a.getHeight()));
|
int bLeft = toRawWidth(b.getX());
|
int bTop = toRawHeight(b.getY());
|
int bRight = toRawWidth(safeDouble(b.getX()) + safeDouble(b.getWidth()));
|
int bBottom = toRawHeight(safeDouble(b.getY()) + safeDouble(b.getHeight()));
|
return aLeft < bRight && aRight > bLeft && aTop < bBottom && aBottom > bTop;
|
}
|
|
private List<List<HashMap<String, Object>>> compileToStoredMapData(BasMapEditorDoc doc) {
|
List<BasMapEditorElement> elements = doc.getElements() == null ? new ArrayList<BasMapEditorElement>() : doc.getElements();
|
if (elements.isEmpty()) {
|
return buildEmptyStoredMapData(doc);
|
}
|
|
TreeSet<Integer> xBounds = new TreeSet<>();
|
TreeSet<Integer> yBounds = new TreeSet<>();
|
xBounds.add(0);
|
yBounds.add(0);
|
List<CompiledRect> rects = new ArrayList<>();
|
for (BasMapEditorElement element : elements) {
|
CompiledRect rect = toCompiledRect(element);
|
rects.add(rect);
|
xBounds.add(rect.left);
|
xBounds.add(rect.right);
|
yBounds.add(rect.top);
|
yBounds.add(rect.bottom);
|
}
|
|
List<Integer> xList = new ArrayList<>(xBounds);
|
List<Integer> yList = new ArrayList<>(yBounds);
|
if (xList.size() < 2 || yList.size() < 2) {
|
return buildEmptyStoredMapData(doc);
|
}
|
|
int rowCount = yList.size() - 1;
|
int colCount = xList.size() - 1;
|
String[][] occupancy = new String[rowCount][colCount];
|
Map<String, Integer> xIndexMap = buildBoundaryIndexMap(xList);
|
Map<String, Integer> yIndexMap = buildBoundaryIndexMap(yList);
|
|
List<List<HashMap<String, Object>>> stored = new ArrayList<>();
|
for (int r = 0; r < rowCount; r++) {
|
List<HashMap<String, Object>> row = new ArrayList<>();
|
int cellHeight = yList.get(r + 1) - yList.get(r);
|
for (int c = 0; c < colCount; c++) {
|
int cellWidth = xList.get(c + 1) - xList.get(c);
|
row.add(createStoredCell("none", "", cellWidth, cellHeight, 1, 1, ""));
|
}
|
stored.add(row);
|
}
|
|
for (CompiledRect rect : rects) {
|
Integer rowStart = yIndexMap.get(String.valueOf(rect.top));
|
Integer rowEndIndex = yIndexMap.get(String.valueOf(rect.bottom));
|
Integer colStart = xIndexMap.get(String.valueOf(rect.left));
|
Integer colEndIndex = xIndexMap.get(String.valueOf(rect.right));
|
if (rowStart == null || rowEndIndex == null || colStart == null || colEndIndex == null) {
|
throw new CoolException("地图编译失败: 元素边界无法映射到网格");
|
}
|
int rowSpan = rowEndIndex - rowStart;
|
int colSpan = colEndIndex - colStart;
|
if (rowSpan <= 0 || colSpan <= 0) {
|
throw new CoolException("地图编译失败: 元素尺寸无效 " + rect.id);
|
}
|
|
for (int r = rowStart; r < rowStart + rowSpan; r++) {
|
for (int c = colStart; c < colStart + colSpan; c++) {
|
if (occupancy[r][c] != null) {
|
throw new CoolException("地图编译失败: 元素重叠 " + rect.id + " 与 " + occupancy[r][c]);
|
}
|
occupancy[r][c] = rect.id;
|
}
|
}
|
|
stored.get(rowStart).set(colStart, createStoredCell(
|
rect.type,
|
rect.value,
|
xList.get(colStart + 1) - xList.get(colStart),
|
yList.get(rowStart + 1) - yList.get(rowStart),
|
rowSpan,
|
colSpan,
|
""
|
));
|
for (int r = rowStart; r < rowStart + rowSpan; r++) {
|
for (int c = colStart; c < colStart + colSpan; c++) {
|
if (r == rowStart && c == colStart) {
|
continue;
|
}
|
stored.get(r).set(c, createStoredCell(
|
"merge",
|
rect.value,
|
xList.get(c + 1) - xList.get(c),
|
yList.get(r + 1) - yList.get(r),
|
1,
|
1,
|
rect.type
|
));
|
}
|
}
|
}
|
return stored;
|
}
|
|
private List<List<HashMap<String, Object>>> buildEmptyStoredMapData(BasMapEditorDoc doc) {
|
int widthRaw = Math.max(DEFAULT_COL_WIDTH, toRawWidth(doc == null ? null : doc.getCanvasWidth()));
|
int heightRaw = Math.max(DEFAULT_ROW_HEIGHT, toRawHeight(doc == null ? null : doc.getCanvasHeight()));
|
List<List<HashMap<String, Object>>> stored = new ArrayList<>();
|
List<HashMap<String, Object>> row = new ArrayList<>();
|
row.add(createStoredCell("none", "", widthRaw, heightRaw, 1, 1, ""));
|
stored.add(row);
|
return stored;
|
}
|
|
private CompiledRect toCompiledRect(BasMapEditorElement element) {
|
CompiledRect rect = new CompiledRect();
|
rect.id = element.getId();
|
rect.type = element.getType();
|
rect.value = normalizeCellValue(element.getType(), element.getValue());
|
rect.left = toRawWidth(element.getX());
|
rect.top = toRawHeight(element.getY());
|
rect.right = toRawWidth(safeDouble(element.getX()) + safeDouble(element.getWidth()));
|
rect.bottom = toRawHeight(safeDouble(element.getY()) + safeDouble(element.getHeight()));
|
if (rect.right <= rect.left || rect.bottom <= rect.top) {
|
throw new CoolException("元素尺寸无效: " + element.getId());
|
}
|
return rect;
|
}
|
|
private Map<String, Integer> buildBoundaryIndexMap(List<Integer> bounds) {
|
Map<String, Integer> result = new LinkedHashMap<>();
|
for (int i = 0; i < bounds.size(); i++) {
|
result.put(String.valueOf(bounds.get(i)), i);
|
}
|
return result;
|
}
|
|
private HashMap<String, Object> createStoredCell(String type,
|
String value,
|
int cellWidth,
|
int cellHeight,
|
int rowSpan,
|
int colSpan,
|
String mergeType) {
|
HashMap<String, Object> cell = new HashMap<>();
|
cell.put("type", normalizeType(type));
|
cell.put("value", stringifyValue(value));
|
cell.put("cellWidth", Math.max(1, cellWidth));
|
cell.put("cellHeight", Math.max(1, cellHeight));
|
cell.put("rowSpan", Math.max(1, rowSpan));
|
cell.put("colSpan", Math.max(1, colSpan));
|
if ("merge".equals(type)) {
|
cell.put("mergeType", normalizeType(mergeType));
|
}
|
return cell;
|
}
|
|
private List<List<HashMap<String, Object>>> parseStoredMapData(String json) {
|
if (Cools.isEmpty(json)) {
|
return new ArrayList<>();
|
}
|
List<List<HashMap<String, Object>>> data = JSON.parseObject(json, new TypeReference<List<List<HashMap<String, Object>>>>() {});
|
return data == null ? new ArrayList<List<HashMap<String, Object>>>() : data;
|
}
|
|
private List<List<HashMap<String, Object>>> convertRawExcelData(List<List<HashMap<String, Object>>> rawData) {
|
List<List<HashMap<String, Object>>> result = new ArrayList<>();
|
if (rawData == null) {
|
return result;
|
}
|
for (List<HashMap<String, Object>> row : rawData) {
|
List<HashMap<String, Object>> rowResult = new ArrayList<>();
|
if (row != null) {
|
for (HashMap<String, Object> cell : row) {
|
rowResult.add(convertRawExcelCell(cell));
|
}
|
}
|
result.add(rowResult);
|
}
|
return result;
|
}
|
|
private HashMap<String, Object> convertRawExcelCell(HashMap<String, Object> rawCell) {
|
HashMap<String, Object> target = new HashMap<>();
|
String nodeType = getString(rawCell, "nodeType", "none");
|
String normalizedType;
|
if ("shelf".equals(nodeType)) {
|
normalizedType = "shelf";
|
} else if ("crn".equals(nodeType)) {
|
normalizedType = "crn";
|
} else if ("dualCrn".equals(nodeType) || "dualcrn".equals(nodeType)) {
|
normalizedType = "dualCrn";
|
} else if ("devp".equals(nodeType)) {
|
normalizedType = "devp";
|
} else if ("rgv".equals(nodeType)) {
|
normalizedType = "rgv";
|
} else if ("merge".equals(nodeType)) {
|
normalizedType = "merge";
|
} else {
|
normalizedType = "none";
|
}
|
target.put("type", normalizedType);
|
target.put("value", stringifyValue(rawCell == null ? null : rawCell.get("value")));
|
target.put("cellWidth", Math.max(1, toInt(rawCell == null ? null : rawCell.get("cellWidth"), DEFAULT_COL_WIDTH)));
|
target.put("cellHeight", Math.max(1, toInt(rawCell == null ? null : rawCell.get("cellHeight"), DEFAULT_ROW_HEIGHT)));
|
target.put("rowSpan", Math.max(1, toInt(rawCell == null ? null : rawCell.get("rowSpan"), 1)));
|
target.put("colSpan", Math.max(1, toInt(rawCell == null ? null : rawCell.get("colSpan"), 1)));
|
if ("merge".equals(normalizedType)) {
|
target.put("mergeType", normalizeType(getString(rawCell, "mergeType", "none")));
|
}
|
return target;
|
}
|
|
private int extractRowHeight(List<List<HashMap<String, Object>>> storedData, int rowIndex) {
|
List<HashMap<String, Object>> row = storedData.get(rowIndex);
|
if (row == null) {
|
return DEFAULT_ROW_HEIGHT;
|
}
|
for (HashMap<String, Object> cell : row) {
|
int height = toInt(cell == null ? null : cell.get("cellHeight"), 0);
|
if (height > 0) {
|
return height;
|
}
|
}
|
return DEFAULT_ROW_HEIGHT;
|
}
|
|
private int extractColWidth(List<List<HashMap<String, Object>>> storedData, int colIndex) {
|
for (List<HashMap<String, Object>> row : storedData) {
|
if (row == null || colIndex >= row.size()) {
|
continue;
|
}
|
HashMap<String, Object> cell = row.get(colIndex);
|
int width = toInt(cell == null ? null : cell.get("cellWidth"), 0);
|
if (width > 0) {
|
return width;
|
}
|
}
|
return DEFAULT_COL_WIDTH;
|
}
|
|
private void validateDevpValue(String value, int elementIndex) {
|
if (Cools.isEmpty(value)) {
|
throw new CoolException("输送线节点缺少配置: 元素#" + elementIndex);
|
}
|
JSONObject jsonObject;
|
try {
|
jsonObject = JSON.parseObject(value);
|
} catch (Exception ex) {
|
throw new CoolException("输送线节点配置不是合法JSON: 元素#" + elementIndex);
|
}
|
if (jsonObject == null || jsonObject.getInteger("stationId") == null || jsonObject.getInteger("deviceNo") == null) {
|
throw new CoolException("输送线节点必须包含stationId和deviceNo: 元素#" + elementIndex);
|
}
|
Integer isInStation = jsonObject.getInteger("isInStation");
|
Integer isBarcodeStation = jsonObject.getInteger("isBarcodeStation");
|
Integer barcodeIdx = jsonObject.getInteger("barcodeIdx");
|
Integer barcodeStation = jsonObject.getInteger("barcodeStation");
|
Integer barcodeStationDeviceNo = jsonObject.getInteger("barcodeStationDeviceNo");
|
Integer backStation = jsonObject.getInteger("backStation");
|
Integer backStationDeviceNo = jsonObject.getInteger("backStationDeviceNo");
|
|
if (isInStation != null && isInStation == 1) {
|
if (!isPositiveInteger(barcodeStation) || !isPositiveInteger(barcodeStationDeviceNo)) {
|
throw new CoolException("入站点必须包含barcodeStation和barcodeStationDeviceNo: 元素#" + elementIndex);
|
}
|
}
|
if (isBarcodeStation != null && isBarcodeStation == 1) {
|
if (!isPositiveInteger(barcodeIdx) || !isPositiveInteger(backStation) || !isPositiveInteger(backStationDeviceNo)) {
|
throw new CoolException("条码站必须包含barcodeIdx、backStation和backStationDeviceNo: 元素#" + elementIndex);
|
}
|
}
|
}
|
|
private boolean isPositiveInteger(Integer value) {
|
return value != null && value > 0;
|
}
|
|
private double toPositiveCanvasValue(Double rawValue, double defaultValue, String fieldLabel) {
|
double value = safeDouble(rawValue);
|
if (value <= 0) {
|
if (defaultValue > 0) {
|
return defaultValue;
|
}
|
throw new CoolException(fieldLabel + "必须大于0");
|
}
|
return value;
|
}
|
|
private double toNonNegativeDouble(Double rawValue, String fieldLabel) {
|
double value = safeDouble(rawValue);
|
if (value < 0) {
|
throw new CoolException(fieldLabel + "不能小于0");
|
}
|
return value;
|
}
|
|
private int toRawWidth(Double displayValue) {
|
return Math.max(0, (int) Math.round(safeDouble(displayValue) * X_SCALE));
|
}
|
|
private int toRawHeight(Double displayValue) {
|
return Math.max(0, (int) Math.round(safeDouble(displayValue) * Y_SCALE));
|
}
|
|
private double safeDouble(Double value) {
|
return value == null ? 0D : value;
|
}
|
|
private void rebuildDeviceAndStationSync() {
|
SyncContext context = new SyncContext();
|
List<BasMap> basMapList = basMapService.list(new QueryWrapper<BasMap>().orderByAsc("lev"));
|
for (BasMap basMap : basMapList) {
|
collectStationsFromMap(context, basMap.getLev(), parseStoredMapData(basMap.getData()));
|
}
|
|
basStationService.remove(new QueryWrapper<BasStation>());
|
syncBasDevp(context);
|
syncBasStation(context);
|
}
|
|
private void collectStationsFromMap(SyncContext context, Integer lev, List<List<HashMap<String, Object>>> storedData) {
|
if (storedData == null) {
|
return;
|
}
|
for (List<HashMap<String, Object>> row : storedData) {
|
if (row == null) {
|
continue;
|
}
|
for (HashMap<String, Object> cell : row) {
|
String type = normalizeType(getString(cell, "type", "none"));
|
if (!"devp".equals(type)) {
|
continue;
|
}
|
JSONObject value = parseJsonObject(stringifyValue(cell.get("value")));
|
if (value == null) {
|
continue;
|
}
|
Integer deviceNo = value.getInteger("deviceNo");
|
Integer stationId = value.getInteger("stationId");
|
if (deviceNo == null || stationId == null) {
|
continue;
|
}
|
|
StationObjModel stationObjModel = new StationObjModel();
|
stationObjModel.setDeviceNo(deviceNo);
|
stationObjModel.setStationId(stationId);
|
stationObjModel.setStationLev(lev);
|
addStationModel(context.deviceStationMap, context.deviceStationDedup, deviceNo, buildStationKey(deviceNo, stationId, lev), stationObjModel);
|
context.stationRegistry.put(stationId, stationObjModel);
|
|
Integer isBarcodeStation = value.getInteger("isBarcodeStation");
|
if (isBarcodeStation != null && isBarcodeStation == 1) {
|
StationObjModel barcodeStationModel = new StationObjModel();
|
barcodeStationModel.setDeviceNo(deviceNo);
|
barcodeStationModel.setStationId(stationId);
|
barcodeStationModel.setBarcodeIdx(value.getInteger("barcodeIdx"));
|
if (value.getInteger("backStation") != null) {
|
StationObjModel backStation = new StationObjModel();
|
backStation.setDeviceNo(value.getInteger("backStationDeviceNo"));
|
backStation.setStationId(value.getInteger("backStation"));
|
barcodeStationModel.setBackStation(backStation);
|
}
|
addStationModel(context.barcodeStationMap, context.barcodeStationDedup, deviceNo, buildStationKey(deviceNo, stationId, lev), barcodeStationModel);
|
}
|
|
Integer isInStation = value.getInteger("isInStation");
|
if (isInStation != null && isInStation == 1) {
|
StationObjModel inStationModel = new StationObjModel();
|
inStationModel.setDeviceNo(deviceNo);
|
inStationModel.setStationId(stationId);
|
StationObjModel barcodeStation = new StationObjModel();
|
barcodeStation.setDeviceNo(value.getInteger("barcodeStationDeviceNo"));
|
barcodeStation.setStationId(value.getInteger("barcodeStation"));
|
inStationModel.setBarcodeStation(barcodeStation);
|
addStationModel(context.inStationMap, context.inStationDedup, deviceNo, buildStationKey(deviceNo, stationId, lev), inStationModel);
|
}
|
|
Integer isOutStation = value.getInteger("isOutStation");
|
if (isOutStation != null && isOutStation == 1) {
|
addStationModel(context.outStationMap, context.outStationDedup, deviceNo, buildStationKey(deviceNo, stationId, lev), cloneStationModel(stationObjModel));
|
}
|
|
Integer runBlockReassign = value.getInteger("runBlockReassign");
|
if (runBlockReassign != null && runBlockReassign == 1) {
|
addStationModel(context.runBlockReassignStationMap, context.runBlockReassignDedup, deviceNo, buildStationKey(deviceNo, stationId, lev), cloneStationModel(stationObjModel));
|
}
|
|
Integer isOutOrder = value.getInteger("isOutOrder");
|
if (isOutOrder != null && isOutOrder == 1) {
|
addStationModel(context.outOrderStationMap, context.outOrderDedup, deviceNo, buildStationKey(deviceNo, stationId, lev), cloneStationModel(stationObjModel));
|
}
|
|
Integer isLiftTransfer = value.getInteger("isLiftTransfer");
|
if (isLiftTransfer != null && isLiftTransfer == 1) {
|
addStationModel(context.liftTransferStationMap, context.liftTransferDedup, deviceNo, buildStationKey(deviceNo, stationId, lev), cloneStationModel(stationObjModel));
|
}
|
}
|
}
|
}
|
|
private void syncBasDevp(SyncContext context) {
|
Map<Integer, BasDevp> existingMap = new LinkedHashMap<>();
|
List<BasDevp> existingList = basDevpService.list();
|
for (BasDevp basDevp : existingList) {
|
existingMap.put(basDevp.getDevpNo(), basDevp);
|
}
|
|
Set<Integer> allDeviceNos = new LinkedHashSet<>();
|
allDeviceNos.addAll(existingMap.keySet());
|
allDeviceNos.addAll(context.deviceStationMap.keySet());
|
Date now = new Date();
|
|
for (Integer deviceNo : allDeviceNos) {
|
BasDevp basDevp = existingMap.get(deviceNo);
|
if (basDevp == null) {
|
basDevp = new BasDevp();
|
basDevp.setDevpNo(deviceNo);
|
basDevp.setStatus(1);
|
basDevp.setCreateTime(now);
|
}
|
|
List<StationObjModel> stationList = context.deviceStationMap.get(deviceNo);
|
List<StationObjModel> barcodeStationList = context.barcodeStationMap.get(deviceNo);
|
List<StationObjModel> inStationList = context.inStationMap.get(deviceNo);
|
List<StationObjModel> outStationList = context.outStationMap.get(deviceNo);
|
List<StationObjModel> runBlockReassignStationList = context.runBlockReassignStationMap.get(deviceNo);
|
List<StationObjModel> outOrderStationList = context.outOrderStationMap.get(deviceNo);
|
List<StationObjModel> liftTransferStationList = context.liftTransferStationMap.get(deviceNo);
|
|
basDevp.setStationList(toJsonOrNull(stationList));
|
basDevp.setBarcodeStationList(toJsonOrNull(barcodeStationList));
|
basDevp.setInStationList(toJsonOrNull(inStationList));
|
basDevp.setOutStationList(toJsonOrNull(outStationList));
|
basDevp.setRunBlockReassignLocStationList(toJsonOrNull(runBlockReassignStationList));
|
basDevp.setIsOutOrderList(toJsonOrNull(outOrderStationList));
|
basDevp.setIsLiftTransferList(toJsonOrNull(liftTransferStationList));
|
basDevp.setUpdateTime(now);
|
basDevpService.saveOrUpdate(basDevp);
|
|
DeviceConfig deviceConfig = deviceConfigService.getOne(new QueryWrapper<DeviceConfig>()
|
.eq("device_no", deviceNo)
|
.eq("device_type", String.valueOf(SlaveType.Devp)));
|
if (deviceConfig != null) {
|
deviceConfig.setFakeInitStatus(toJsonOrNull(stationList));
|
deviceConfigService.updateById(deviceConfig);
|
}
|
}
|
}
|
|
private void syncBasStation(SyncContext context) {
|
Date now = new Date();
|
for (StationObjModel stationObjModel : context.stationRegistry.values()) {
|
BasStation basStation = new BasStation();
|
basStation.setStationId(stationObjModel.getStationId());
|
basStation.setDeviceNo(stationObjModel.getDeviceNo());
|
basStation.setStationLev(stationObjModel.getStationLev());
|
basStation.setCreateTime(now);
|
basStation.setStatus(1);
|
basStationService.save(basStation);
|
}
|
}
|
|
private void addStationModel(Map<Integer, List<StationObjModel>> targetMap,
|
Map<Integer, Set<String>> dedupMap,
|
Integer deviceNo,
|
String dedupKey,
|
StationObjModel stationObjModel) {
|
Set<String> set = dedupMap.get(deviceNo);
|
if (set == null) {
|
set = new LinkedHashSet<>();
|
dedupMap.put(deviceNo, set);
|
}
|
if (!set.add(dedupKey)) {
|
return;
|
}
|
List<StationObjModel> list = targetMap.get(deviceNo);
|
if (list == null) {
|
list = new ArrayList<>();
|
targetMap.put(deviceNo, list);
|
}
|
list.add(stationObjModel);
|
}
|
|
private StationObjModel cloneStationModel(StationObjModel source) {
|
StationObjModel clone = new StationObjModel();
|
clone.setDeviceNo(source.getDeviceNo());
|
clone.setStationId(source.getStationId());
|
clone.setStationLev(source.getStationLev());
|
clone.setBarcodeIdx(source.getBarcodeIdx());
|
clone.setDeviceBay(source.getDeviceBay());
|
clone.setDeviceLev(source.getDeviceLev());
|
clone.setDeviceRow(source.getDeviceRow());
|
clone.setDualCrnExecuteStation(source.getDualCrnExecuteStation());
|
clone.setBarcodeStation(source.getBarcodeStation());
|
clone.setBackStation(source.getBackStation());
|
return clone;
|
}
|
|
private String toJsonOrNull(List<StationObjModel> list) {
|
if (list == null || list.isEmpty()) {
|
return null;
|
}
|
return JSON.toJSONString(list, SerializerFeature.DisableCircularReferenceDetect);
|
}
|
|
private void clearMapCaches() {
|
redisUtil.del(RedisKeyType.LOC_MAP_BASE.key);
|
redisUtil.del(RedisKeyType.LOC_MAST_MAP_LIST.key);
|
}
|
|
private String normalizeType(String type) {
|
if (type == null) {
|
return "none";
|
}
|
String value = String.valueOf(type).trim();
|
if ("dualcrn".equalsIgnoreCase(value)) {
|
return "dualCrn";
|
}
|
if (Cools.isEmpty(value)) {
|
return "none";
|
}
|
return value;
|
}
|
|
private String normalizeCellValue(String type, String value) {
|
if ("none".equals(type)) {
|
return "";
|
}
|
return stringifyValue(value);
|
}
|
|
private String stringifyValue(Object value) {
|
if (value == null) {
|
return "";
|
}
|
if (value instanceof String) {
|
return (String) value;
|
}
|
if (value instanceof JSONObject || value instanceof Map || value instanceof List) {
|
return JSON.toJSONString(value);
|
}
|
return String.valueOf(value);
|
}
|
|
private String getString(Map<String, Object> map, String key, String defaultValue) {
|
if (map == null || !map.containsKey(key) || map.get(key) == null) {
|
return defaultValue;
|
}
|
String value = stringifyValue(map.get(key));
|
return Cools.isEmpty(value) ? defaultValue : value;
|
}
|
|
private int toInt(Object value, int defaultValue) {
|
if (value == null) {
|
return defaultValue;
|
}
|
if (value instanceof Number) {
|
return ((Number) value).intValue();
|
}
|
try {
|
return (int) Math.round(Double.parseDouble(String.valueOf(value)));
|
} catch (Exception ignore) {
|
return defaultValue;
|
}
|
}
|
|
private JSONObject parseJsonObject(String json) {
|
if (Cools.isEmpty(json)) {
|
return null;
|
}
|
try {
|
return JSON.parseObject(json);
|
} catch (Exception ignore) {
|
return null;
|
}
|
}
|
|
private String buildStationKey(Integer deviceNo, Integer stationId, Integer lev) {
|
return deviceNo + "_" + stationId + "_" + lev;
|
}
|
|
private static class CompiledRect {
|
private String id;
|
private String type;
|
private String value;
|
private int left;
|
private int top;
|
private int right;
|
private int bottom;
|
}
|
|
private static class SyncContext {
|
private final Map<Integer, List<StationObjModel>> deviceStationMap = new LinkedHashMap<>();
|
private final Map<Integer, List<StationObjModel>> barcodeStationMap = new LinkedHashMap<>();
|
private final Map<Integer, List<StationObjModel>> inStationMap = new LinkedHashMap<>();
|
private final Map<Integer, List<StationObjModel>> outStationMap = new LinkedHashMap<>();
|
private final Map<Integer, List<StationObjModel>> runBlockReassignStationMap = new LinkedHashMap<>();
|
private final Map<Integer, List<StationObjModel>> outOrderStationMap = new LinkedHashMap<>();
|
private final Map<Integer, List<StationObjModel>> liftTransferStationMap = new LinkedHashMap<>();
|
private final Map<Integer, StationObjModel> stationRegistry = new LinkedHashMap<>();
|
|
private final Map<Integer, Set<String>> deviceStationDedup = new LinkedHashMap<>();
|
private final Map<Integer, Set<String>> barcodeStationDedup = new LinkedHashMap<>();
|
private final Map<Integer, Set<String>> inStationDedup = new LinkedHashMap<>();
|
private final Map<Integer, Set<String>> outStationDedup = new LinkedHashMap<>();
|
private final Map<Integer, Set<String>> runBlockReassignDedup = new LinkedHashMap<>();
|
private final Map<Integer, Set<String>> outOrderDedup = new LinkedHashMap<>();
|
private final Map<Integer, Set<String>> liftTransferDedup = new LinkedHashMap<>();
|
}
|
}
|
