From 0a31d5f715701b1491a471f3187b66331e78cd3b Mon Sep 17 00:00:00 2001
From: xyc <jc_xiong@hotmail.com>
Date: 星期二, 10 九月 2024 11:53:02 +0800
Subject: [PATCH] 新增可靠性评定后台
---
modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/service/ModelLineService.java | 660 ++++++++++++++++++++++++++++++++++++++++++++++-------------
1 files changed, 516 insertions(+), 144 deletions(-)
diff --git a/modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/service/ModelLineService.java b/modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/service/ModelLineService.java
index 01bd97e..7ad020c 100644
--- a/modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/service/ModelLineService.java
+++ b/modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/service/ModelLineService.java
@@ -11,20 +11,17 @@
import com.zt.life.modules.mainPart.basicInfo.model.ProductImg;
import com.zt.life.modules.mainPart.basicInfo.model.XhProductModel;
import com.zt.life.modules.mainPart.taskReliability.dao.*;
-import com.zt.life.modules.mainPart.taskReliability.dto.ModelLinePair;
+import com.zt.life.modules.mainPart.taskReliability.dto.ModelLinePairDto;
import com.zt.life.modules.mainPart.taskReliability.model.*;
import org.apache.commons.lang3.StringUtils;
-import org.dom4j.DocumentHelper;
-import org.dom4j.Document;
import org.dom4j.Element;
-import org.dom4j.io.OutputFormat;
-import org.dom4j.io.XMLWriter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.zt.common.db.query.QueryFilter;
import org.springframework.transaction.annotation.Transactional;
-import java.io.StringWriter;
import java.util.*;
import java.util.stream.Collectors;
@@ -37,6 +34,42 @@
*/
@Service
public class ModelLineService extends BaseService<ModelLineDao, ModelLine> {
+ private static final Logger logger = LoggerFactory.getLogger(ModelLineService.class);
+
+ // 杩愮畻
+ public static final String OPE_TYPE_SERIES = "series";
+ public static final String OPE_TYPE_PARALLEL = "parallel";
+ public static final String OPE_TYPE_SWITCH = "switch";
+ public static final String OPE_TYPE_VOTE = "vote";
+ public static final String OPE_TYPE_BRIDGE = "bridge";
+
+ // 鑺傜偣
+ /* 鑷姩甯冨眬锛歴tart涓巈nd鐨勫ぇ灏� */
+ public static final int LAYOUT_START_END_SIZE_X = 60;
+ public static final int LAYOUT_START_END_SIZE_Y = 40;
+ /* 鑷姩甯冨眬锛氳櫄妗嗙殑澶у皬 */
+ public static final int LAYOUT_DASHED_BOX_SIZE_X = 60;
+ public static final int LAYOUT_DASHED_BOX_SIZE_Y = 40;
+ /* 鑷姩甯冨眬锛氶�昏緫杩愮畻绗︾殑澶у皬 */
+ public static final int LAYOUT_OPE_NODE_SIZE_X = 50;
+ public static final int LAYOUT_OPE_NODE_SIZE_Y = 50;
+ /* 鑷姩甯冨眬锛氳澶囪妭鐐圭殑澶у皬 */
+ public static final int LAYOUT_DEVICE_NODE_SIZE_X = 60;
+ public static final int LAYOUT_DEVICE_NODE_SIZE_Y = 60;
+ /* 鑷姩甯冨眬锛歝onnect鐨勫ぇ灏� */
+ public static final int LAYOUT_CONNECT_SIZE_X = 10;
+ public static final int LAYOUT_CONNECT_SIZE_Y = 10;
+
+ // 鍗曞厓鏍硷紙瀛樻斁鑺傜偣锛�
+ /* 鑷姩甯冨眬锛氬崟鍏冩牸澶у皬 */
+ public static final int LAYOUT_CELL_SIZE_X = 120;
+ public static final int LAYOUT_CELL_SIZE_Y = 120;
+ /* 鑷姩甯冨眬锛氳妭鐐瑰崰鎹崟鍏冩牸鏁伴噺 */
+ public static final int LAYOUT_CELL_NUM_NODE_X = 1;
+ public static final int LAYOUT_CELL_NUM_NODE_Y = 1;
+ public static final int LAYOUT_CELL_NUM_CONNECT_X = 1;
+ public static final int LAYOUT_CELL_NUM_CONNECT_Y = 1;
+
@Autowired
private ModelLineDao modelLineDao;
@Autowired
@@ -102,6 +135,448 @@
modelRbdDao.insert(modelRbd);
}
+ // 鑷姩鎺掔増RBD
+ @Transactional(rollbackFor = Exception.class)
+ public boolean layout(ModelRbd modelRbd) {
+ boolean result = true;
+ if (modelRbd==null) return result;
+ Long modelId = modelRbd.getId();
+ result = layoutRbd(modelRbd);
+ return result;
+ }
+
+ private boolean layoutRbd(ModelRbd modelRbd) {
+ boolean result = true;
+ String rbdsonStr = modelRbd.getContent();
+
+ JSONArray rbdJsonArray = new JSONObject(rbdsonStr).getJSONArray("cells");
+ if (rbdJsonArray == null) return result;
+
+ // 瑙ｆ瀽缁撴灉瀛樻斁list
+ List<ModelNode> modelNodeList = new ArrayList<>();
+ List<ModelLine> modelLineList = new ArrayList<>();
+ List<Algorithm> algorithmList = new ArrayList<>();
+ List<ProductImg> productImgList = new ArrayList<>(); // 鏆備笉浣跨敤锛堣�屼娇鐢ㄦ暟鎹簱涓殑鍙潬鎬у弬鏁帮級
+
+ // 1. 瑙ｆ瀽鍑鸿妭鐐逛笌杈�
+ getNodeAndLineFromRbd(modelRbd.getId(), rbdJsonArray, modelNodeList, modelLineList, productImgList);
+ // 2. 瀵逛簬鏈夊鏍瑰叆鍙ｇ嚎鐨勪骇鍝佽妭鐐癸紝灏嗗叾涓婄殑琛ㄥ喅銆佹梺鑱斿叧绯诲墺绂绘垚杩愮畻绗﹁妭鐐癸紝娣诲姞鍒拌鑺傜偣鐨勫墠闈紝骞舵坊鍔犵浉搴旂殑杈�
+ peelOperationFromProductNode(modelRbd.getId(), modelNodeList, modelLineList);
+ // 3. 璁＄畻鎵�鏈夎妭鐐圭殑鍏ュ彛绾挎暟鍙婂嚭鍙ｇ嚎鏁�
+ calcInOutLineNumAllNode(modelNodeList, modelLineList);
+ // 4. 澶嶅埗浜у搧鑺傜偣(node)鍒發ist
+ List<ModelNode> modelNodeAndVnodeList = modelNodeList.stream().filter(item ->
+ "node".equals(item.getNodeType())).collect(Collectors.toList());
+ // 5. 涓嶆柇灏嗗熀鏈ā鍨嬶紙涓茶仈銆佸苟鑱斻�佹梺鑱斻�佽〃鍐炽�佹ˉ鑱旓級鏇挎崲涓鸿櫄鑺傜偣鑰岀畝鍖栧浘褰紝鐩磋嚦鏃犳硶绠�鍖栦负姝€��
+ result = getAlgorithmFromRbd(modelRbd, modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList);
+
+ // 6. 閫掑綊璁＄畻RBD鐨勫竷灞�绌洪棿澶у皬
+ calcLayoutSize(modelRbd, algorithmList, modelNodeAndVnodeList);
+ // 7. 閫掑綊璁＄畻RBD鐨勫竷灞�绌洪棿鍙傛暟锛坸銆亂鍧愭爣锛�
+ calcLayoutPosition(modelRbd, algorithmList, modelNodeAndVnodeList);
+
+ // 8. 淇濆瓨鑷姩甯冨眬妯″瀷
+ // 鏇存柊RBD鏁版嵁
+// modelRbd.setAutoLayoutContent("娴嬭瘯鏂囧瓧");
+ modelRbdDao.updateById(modelRbd);
+
+ return result;
+ }
+
+ /**
+ * 鏍规嵁椤跺眰RBD鐨勪綅缃紙x锛寉锛夛紝鑷《鍚戜笅閫掑綊璁＄畻鍚勪釜鑺傜偣鐨勪綅缃紙x锛寉锛�
+ * @param modelRbd
+ * @param algorithmList
+ * @param modelNodeAndVnodeList
+ */
+ private void calcLayoutPosition(ModelRbd modelRbd,
+ List<Algorithm> algorithmList,
+ List<ModelNode> modelNodeAndVnodeList) {
+ String rbdsonStr = modelRbd.getContent();
+ JSONArray rbdJsonArray = new JSONObject(rbdsonStr).getJSONArray("cells");
+ Algorithm endAlgo = algorithmList.stream().filter(item ->
+ "end".equals(item.getAlgorithmType())).collect(Collectors.toList()).get(0);
+ ModelNode topNode = modelNodeAndVnodeList.stream().filter(item ->
+ endAlgo.getComputerList().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ Algorithm topAlgo = algorithmList.stream().filter(item ->
+ endAlgo.getComputerList().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ // 灏唗oNode鐨勪腑蹇冨潗鏍囧畾涓�(0锛�0)锛屽弽绠楁墍鏈夎妭鐐圭殑鍧愭爣
+ // 1. 璁＄畻骞惰缃畇tart鐨勪綅缃�
+ double x = -topNode.getVnodeCellNumX()*LAYOUT_CELL_SIZE_X/2 - LAYOUT_START_END_SIZE_X;
+ double y = -LAYOUT_START_END_SIZE_Y/2;
+ setRbdNodePosition(rbdJsonArray, "10000", x, y);
+ // 2. 璁＄畻骞惰缃妭鐐圭殑浣嶇疆
+ calcNodeLayoutPosition(rbdJsonArray, algorithmList, modelNodeAndVnodeList, topNode, topAlgo, 0, 0);
+ // 3. 璁＄畻骞惰缃甧nd鐨勪綅缃�
+ x = topNode.getVnodeCellNumX()*LAYOUT_CELL_SIZE_X/2;
+ setRbdNodePosition(rbdJsonArray, "20000", x ,y);
+ JSONObject jsonObject = new JSONObject();
+ jsonObject.put("cells", rbdJsonArray);
+ modelRbd.setContent(jsonObject.toString());
+ }
+
+ // 閫掑綊鍑芥暟
+ private void calcNodeLayoutPosition(JSONArray rbdJsonArray,
+ List<Algorithm> algorithmList,
+ List<ModelNode> modelNodeAndVnodeList,
+ ModelNode node,
+ Algorithm algo,
+ double x,
+ double y) {
+ if ("node".equals(node.getNodeType())) {
+ //璁剧疆node锛堣澶囪妭鐐癸級甯冨眬淇℃伅
+ node.setPositionX(x - node.getCellNumX()*LAYOUT_CELL_SIZE_X/2);
+ node.setPositionY(y - node.getCellNumY()*LAYOUT_CELL_SIZE_Y/2);
+ setRbdNodePosition(rbdJsonArray, node.getPicId().toString(), node.getPositionX(), node.getPositionY());
+ } else if ("vnode".equals(node.getNodeType())) {
+ String[] computerNodeListStr = algo.getComputerList().split(",");
+ switch (algo.getAlgorithmType()) {
+ case OPE_TYPE_SERIES:
+ int sumCellNumX = 0;
+ for (String nodeStr : computerNodeListStr) {
+ ModelNode childNode = modelNodeAndVnodeList.stream().filter(item ->
+ nodeStr.equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ sumCellNumX += childNode.getVnodeCellNumX();
+ }
+ for (int i=0; i<computerNodeListStr.length; i++) {
+ int idx = i;
+ ModelNode childNode = modelNodeAndVnodeList.stream().filter(item ->
+ computerNodeListStr[idx].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ if (0==i) {
+ double childNodeX = x - sumCellNumX * LAYOUT_CELL_SIZE_X / 2;
+ double childNodeY = y - childNode.getVnodeCellNumY() * LAYOUT_CELL_SIZE_Y / 2;
+ if ("node".equals(childNode.getNodeType())) {
+ childNode.setPositionX(childNodeX);
+ childNode.setPositionY(childNodeY);
+ setRbdNodePosition(rbdJsonArray, childNode.getPicId().toString(), childNode.getPositionX(), childNode.getPositionY());
+ } else {
+ Algorithm childAlgo = algorithmList.stream().filter(item ->
+ childNode.getId().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ calcNodeLayoutPosition(rbdJsonArray,
+ algorithmList,
+ modelNodeAndVnodeList,
+ childNode,
+ childAlgo,
+ childNodeX,
+ childNodeY);
+ }
+ } else {
+ int idxPre = i - 1;
+ ModelNode childNodePre = modelNodeAndVnodeList.stream().filter(item ->
+ computerNodeListStr[idxPre].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ int idxMe = i;
+ double childNodeX = childNodePre.getPositionX() + childNodePre.getVnodeCellNumX()*LAYOUT_CELL_SIZE_X;
+ double childNodeY = y - childNode.getVnodeCellNumY()*LAYOUT_CELL_SIZE_Y/2;
+ if ("node".equals(childNode.getNodeType())) {
+ childNode.setPositionX(childNodeX);
+ childNode.setPositionY(childNodeY);
+ setRbdNodePosition(rbdJsonArray, childNode.getPicId().toString(), childNode.getPositionX(), childNode.getPositionY());
+ } else {
+ ModelNode childNodeMe = modelNodeAndVnodeList.stream().filter(item ->
+ computerNodeListStr[idxMe].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ Algorithm childAlgoMe = algorithmList.stream().filter(item ->
+ childNodeMe.getId().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ calcNodeLayoutPosition(rbdJsonArray,
+ algorithmList,
+ modelNodeAndVnodeList,
+ childNode,
+ childAlgoMe,
+ childNodePre.getPositionX() + childNodePre.getVnodeCellNumX() * LAYOUT_CELL_SIZE_X,
+ y - childNodeMe.getVnodeCellNumY() * LAYOUT_CELL_SIZE_Y / 2);
+ }
+ }
+ }
+ break;
+ case OPE_TYPE_PARALLEL:
+ case OPE_TYPE_SWITCH:
+ case OPE_TYPE_VOTE:
+ int sumCellNumY = 0;
+ for (String nodeStr : computerNodeListStr) {
+ ModelNode childNode = modelNodeAndVnodeList.stream().filter(item ->
+ nodeStr.equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ sumCellNumY += childNode.getVnodeCellNumY();
+ }
+ for (int i=0; i<computerNodeListStr.length; i++) {
+ int idx = i;
+ ModelNode childNode = modelNodeAndVnodeList.stream().filter(item ->
+ computerNodeListStr[idx].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ if (0==i) {
+ double childNodeX = x - childNode.getVnodeCellNumX()*LAYOUT_CELL_SIZE_X/2;
+ double childNodeY = y - sumCellNumY*LAYOUT_CELL_SIZE_Y/2;
+ if ("node".equals(childNode.getNodeType())) {
+ childNode.setPositionX(childNodeX);
+ childNode.setPositionY(childNodeY);
+ setRbdNodePosition(rbdJsonArray, childNode.getPicId(), childNode.getPositionX(), childNode.getPositionY());
+ } else {
+ Algorithm childAlgo = algorithmList.stream().filter(item ->
+ childNode.getId().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ calcNodeLayoutPosition(rbdJsonArray,
+ algorithmList,
+ modelNodeAndVnodeList,
+ childNode,
+ childAlgo,
+ childNodeX,
+ childNodeY);
+ }
+ } else {
+ int idxPre = i - 1;
+ ModelNode childNodePre = modelNodeAndVnodeList.stream().filter(item ->
+ computerNodeListStr[idxPre].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ int idxMe = i;
+ ModelNode childNodeMe = modelNodeAndVnodeList.stream().filter(item ->
+ computerNodeListStr[idxMe].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ double childNodeX = x - childNodeMe.getVnodeCellNumY() * LAYOUT_CELL_SIZE_Y / 2;
+ double childNodeY = childNodePre.getPositionY() + childNodePre.getVnodeCellNumY() * LAYOUT_CELL_SIZE_Y;
+ if ("node".equals(childNodeMe.getNodeType())) {
+ childNodeMe.setPositionX(childNodeX);
+ childNodeMe.setPositionY(childNodeY);
+ setRbdNodePosition(rbdJsonArray, childNodeMe.getPicId(), childNodeMe.getPositionX(), childNodeMe.getPositionY());
+ } else {
+ Algorithm childAlgoMe = algorithmList.stream().filter(item ->
+ childNodeMe.getId().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ calcNodeLayoutPosition(rbdJsonArray,
+ algorithmList,
+ modelNodeAndVnodeList,
+ childNodeMe,
+ childAlgoMe,
+ childNodeX,
+ childNodeY);
+ }
+ }
+ }
+ break;
+ case OPE_TYPE_BRIDGE:
+ ModelNode node1 = modelNodeAndVnodeList.stream().filter(item ->
+ computerNodeListStr[0].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ ModelNode node2 = modelNodeAndVnodeList.stream().filter(item ->
+ computerNodeListStr[1].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ ModelNode node3 = modelNodeAndVnodeList.stream().filter(item ->
+ computerNodeListStr[2].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ ModelNode node4 = modelNodeAndVnodeList.stream().filter(item ->
+ computerNodeListStr[3].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ ModelNode node5 = modelNodeAndVnodeList.stream().filter(item ->
+ computerNodeListStr[4].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ Algorithm algo1 = algorithmList.stream().filter(item ->
+ node1.getId().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ Algorithm algo2 = algorithmList.stream().filter(item ->
+ node2.getId().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ Algorithm algo3 = algorithmList.stream().filter(item ->
+ node3.getId().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ Algorithm algo4 = algorithmList.stream().filter(item ->
+ node4.getId().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ Algorithm algo5 = algorithmList.stream().filter(item ->
+ node5.getId().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ // 1锛岃绠椾笁琛岀殑鎬婚珮搴�
+ // 1.1 璁＄畻绗竴琛屼袱涓妭鐐圭殑楂樺害
+ int firstRowCellNumY = Math.max(node1.getVnodeCellNumY(), node2.getVnodeCellNumY());
+ // 1.2 璁＄畻绗簩琛屾ˉ鑱旇妭鐐圭殑楂樺害
+ int secondRowCellNumY = node3.getVnodeCellNumY();
+ // 1.3 璁＄畻绗笁琛屼袱涓妭鐐圭殑楂樺害
+ int thirdRowCellNumY = Math.max(node4.getVnodeCellNumY(), node5.getVnodeCellNumY());
+ int totalCellNumY = firstRowCellNumY + secondRowCellNumY + thirdRowCellNumY;
+ // 2. 璁＄畻涓夎鍚勮妭鐐圭殑鍧愭爣
+ // 2.1 璁＄畻绗竴琛屼袱涓妭鐐圭殑鍧愭爣
+ calcNodeLayoutPosition(rbdJsonArray,
+ algorithmList,
+ modelNodeAndVnodeList,
+ node1,
+ algo1,
+ x - (node1.getVnodeCellNumX() + node2.getVnodeCellNumX())*LAYOUT_CELL_SIZE_X/2,
+ y - (totalCellNumY-firstRowCellNumY+node1.getVnodeCellNumY())*LAYOUT_CELL_SIZE_Y/2);
+ calcNodeLayoutPosition(rbdJsonArray,
+ algorithmList,
+ modelNodeAndVnodeList,
+ node2,
+ algo2,
+ x + (node1.getVnodeCellNumX() + node2.getVnodeCellNumX())*LAYOUT_CELL_SIZE_X/2,
+ y - (totalCellNumY-firstRowCellNumY+node2.getVnodeCellNumY())*LAYOUT_CELL_SIZE_Y/2);
+ // 2.2 璁＄畻绗簩琛屾ˉ鑱旇妭鐐圭殑鍧愭爣
+ calcNodeLayoutPosition(rbdJsonArray,
+ algorithmList,
+ modelNodeAndVnodeList,
+ node2,
+ algo2,
+ x - node3.getVnodeCellNumX()*LAYOUT_CELL_SIZE_X/2,
+ y - (totalCellNumY/2-firstRowCellNumY)*LAYOUT_CELL_SIZE_Y);
+ // 2.3 璁＄畻绗笁琛屼袱涓妭鐐圭殑鍧愭爣
+ calcNodeLayoutPosition(rbdJsonArray,
+ algorithmList,
+ modelNodeAndVnodeList,
+ node1,
+ algo1,
+ x - (node1.getVnodeCellNumX() + node2.getVnodeCellNumX())*LAYOUT_CELL_SIZE_X/2,
+ y - (totalCellNumY-firstRowCellNumY+node1.getVnodeCellNumY())*LAYOUT_CELL_SIZE_Y/2);
+ calcNodeLayoutPosition(rbdJsonArray,
+ algorithmList,
+ modelNodeAndVnodeList,
+ node2,
+ algo2,
+ x + (node1.getVnodeCellNumX() + node2.getVnodeCellNumX())*LAYOUT_CELL_SIZE_X/2,
+ y - (totalCellNumY-firstRowCellNumY+node2.getVnodeCellNumY())*LAYOUT_CELL_SIZE_Y/2);
+ // 2.4 璁＄畻妗ヨ仈杩愮畻绗︾殑鍧愭爣
+ // 2.5 璁＄畻宸︿晶閰嶅鐨刢onnect鐨勫潗鏍�
+ break;
+ default:
+ break;
+ }
+ }
+ }
+
+ private void setRbdNodePosition(JSONArray rbdJsonArray,
+ String id,
+ double x,
+ double y) {
+ for (int i = 0; i < rbdJsonArray.size(); i++) {
+ JSONObject jsonObject = rbdJsonArray.getJSONObject(i);
+ if (id.equals(jsonObject.get("id").toString())) {
+ JsonUtils2.setJsonValueByPath(jsonObject, "position/x".split("/"), x);
+ JsonUtils2.setJsonValueByPath(jsonObject, "position/y".split("/"), y);
+ }
+ }
+ }
+
+ /**
+ * 鑷簳鍚戜笂閫掑綊鍚堣鍑烘暣涓猂BD鐨勫ぇ灏忥紙妯悜鍙婄旱鍚戞墍鍗犲崟鍏冩牸鐨勬暟閲忥級
+ * @param modelRbd
+ * @param algorithmList
+ * @param modelNodeAndVnodeList
+ */
+ private void calcLayoutSize(
+ ModelRbd modelRbd,
+ List<Algorithm> algorithmList,
+ List<ModelNode> modelNodeAndVnodeList) {
+ Algorithm endAlgo = algorithmList.stream().filter(item ->
+ "end".equals(item.getAlgorithmType())).collect(Collectors.toList()).get(0);
+ ModelNode topNode = modelNodeAndVnodeList.stream().filter(item ->
+ endAlgo.getComputerList().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ Algorithm topAlgo = algorithmList.stream().filter(item ->
+ endAlgo.getComputerList().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ calcNodeLayoutSize(algorithmList, modelNodeAndVnodeList, topNode, topAlgo);
+ }
+
+ // 閫掑綊鍑芥暟
+ private void calcNodeLayoutSize(List<Algorithm> algorithmList,
+ List<ModelNode> modelNodeAndVnodeList,
+ ModelNode node,
+ Algorithm algo) {
+ if ("node".equals(node.getNodeType())) {
+ //璁剧疆node锛堣澶囪妭鐐癸級甯冨眬淇℃伅
+ node.setWidth(LAYOUT_DEVICE_NODE_SIZE_X);
+ node.setHeight(LAYOUT_DEVICE_NODE_SIZE_Y);
+ node.setCellNumX(LAYOUT_CELL_NUM_NODE_X);
+ node.setCellNumY(LAYOUT_CELL_NUM_NODE_Y);
+ node.setVnodeCellNumX(node.getCellNumX());
+ node.setVnodeCellNumY(node.getCellNumY());
+ } else if ("vnode".equals(node.getNodeType())) {
+ // 1. 璁剧疆vnode锛堣繍绠楄妭鐐癸級甯冨眬淇℃伅锛堝叾瀹炰覆鑱旀病鏈夎繍绠楃锛屼笉闇�瑕佽缃紝浣嗘槸璁剧疆浜嗕篃娌℃湁鍧忓锛屾墍鏈変笉浣滃尯鍒嗭級
+ node.setWidth(LAYOUT_OPE_NODE_SIZE_X);
+ node.setHeight(LAYOUT_OPE_NODE_SIZE_Y);
+ node.setCellNumX(LAYOUT_CELL_NUM_NODE_X);
+ node.setCellNumY(LAYOUT_CELL_NUM_NODE_Y);
+
+ // 2. 璁剧疆铏氳妭鐐瑰竷灞�淇℃伅
+ // 2.1 璁剧疆铏氳妭鐐瑰唴鍚勮繍绠楀璞＄殑甯冨眬淇℃伅
+ String[] computerNodeListStr = algo.getComputerList().split(",");
+ for (String nodeStr : computerNodeListStr) {
+ ModelNode childNode = modelNodeAndVnodeList.stream().filter(item ->
+ nodeStr.equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ if ("node".equals(childNode.getNodeType())) {
+ childNode.setWidth(LAYOUT_DEVICE_NODE_SIZE_X);
+ childNode.setHeight(LAYOUT_DEVICE_NODE_SIZE_Y);
+ childNode.setCellNumX(LAYOUT_CELL_NUM_NODE_X);
+ childNode.setCellNumY(LAYOUT_CELL_NUM_NODE_Y);
+ childNode.setVnodeCellNumX(node.getCellNumX());
+ childNode.setVnodeCellNumY(node.getCellNumY());
+ } else {
+ Algorithm childAlgo = algorithmList.stream().filter(item ->
+ childNode.getId().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ calcNodeLayoutSize(algorithmList,
+ modelNodeAndVnodeList,
+ childNode,
+ childAlgo);
+ }
+ }
+ // 2.2 璁剧疆铏氳妭鐐规�荤殑甯冨眬淇℃伅鍒拌繍绠楄妭鐐逛腑
+ setVnodeLayoutNum(computerNodeListStr, modelNodeAndVnodeList, node, algo);
+ }
+ }
+
+ private void setVnodeLayoutNum(String[] computerNodeListStr,
+ List<ModelNode> modelNodeAndVnodeList,
+ ModelNode vnode,
+ Algorithm algo) {
+ int numX = 0;
+ int numY = 0;
+ // 1. 璁＄畻涓层�佸苟銆佹梺鑱斻�佽〃鍐�
+ for (String nodeStr : computerNodeListStr) {
+ ModelNode childNode = modelNodeAndVnodeList.stream().filter(item ->
+ nodeStr.equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ switch (algo.getAlgorithmType()) {
+ case OPE_TYPE_SERIES:
+ numX += childNode.getCellNumX();
+ numY = childNode.getCellNumY() > numY ? childNode.getCellNumY() : numY;
+ break;
+ case OPE_TYPE_PARALLEL:
+ case OPE_TYPE_SWITCH:
+ case OPE_TYPE_VOTE:
+ numX = childNode.getCellNumX() > numX ? childNode.getCellNumX() : numX;
+ numY += childNode.getCellNumY();
+ break;
+ default:
+ break;
+ }
+ }
+ if (OPE_TYPE_PARALLEL.equals(algo.getAlgorithmType())
+ || OPE_TYPE_SWITCH.equals(algo.getAlgorithmType())
+ || OPE_TYPE_VOTE.equals(algo.getAlgorithmType())) {
+ // 璁剧疆connect鐨勫ぇ灏�
+ ModelNode connect = modelNodeAndVnodeList.stream().filter(item ->
+ vnode.getPairStartNodeId().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ connect.setWidth(LAYOUT_CONNECT_SIZE_X);
+ connect.setHeight(LAYOUT_CONNECT_SIZE_Y);
+ connect.setCellNumX(LAYOUT_CELL_NUM_CONNECT_X);
+ connect.setCellNumY(LAYOUT_CELL_NUM_CONNECT_Y);
+ numX += connect.getCellNumX();
+ numX += vnode.getCellNumX();
+ }
+ // 2. 璁＄畻妗ヨ仈
+ if (OPE_TYPE_BRIDGE.equals(algo.getAlgorithmType())) {
+ // 妗ヨ仈鏀矾绠椾竴琛岋紝鏁翠釜妗ヨ仈鍏�3琛�
+ // 2.1 璁＄畻绗竴琛�
+ ModelNode node1 = modelNodeAndVnodeList.stream().filter(item ->
+ computerNodeListStr[0].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ ModelNode node2 = modelNodeAndVnodeList.stream().filter(item ->
+ computerNodeListStr[1].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ ModelNode node3 = modelNodeAndVnodeList.stream().filter(item ->
+ computerNodeListStr[2].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ ModelNode node4 = modelNodeAndVnodeList.stream().filter(item ->
+ computerNodeListStr[3].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ ModelNode node5 = modelNodeAndVnodeList.stream().filter(item ->
+ computerNodeListStr[4].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ int numX1 = node1.getCellNumX() + node2.getCellNumX();
+ int numY1 = node1.getCellNumY() > node2.getCellNumY() ? node1.getCellNumY() : node2.getCellNumY();
+ // 2.2 璁＄畻绗簩琛岋紙妗ヨ仈鏀矾锛屾í鍚戠敾鍥撅級
+ int numX2 = node3.getCellNumX();
+ int numY2 = node3.getCellNumY();
+ // 2.3 璁＄畻绗笁琛�
+ int numX3 = node4.getCellNumX() + node5.getCellNumX();
+ int numY3 = node4.getCellNumY() > node5.getCellNumY() ? node4.getCellNumY() : node5.getCellNumY();
+ numX = Math.max(Math.max(numX1, numX2), numX3);
+ numY = numY1 + numY2 + numY3;
+ // 2.4 璁剧疆connect鐨勫ぇ灏�
+ ModelNode connect = modelNodeAndVnodeList.stream().filter(item ->
+ vnode.getPairStartNodeId().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
+ connect.setWidth(LAYOUT_CONNECT_SIZE_X);
+ connect.setHeight(LAYOUT_CONNECT_SIZE_Y);
+ connect.setCellNumX(LAYOUT_CELL_NUM_CONNECT_X);
+ connect.setCellNumY(LAYOUT_CELL_NUM_CONNECT_Y);
+ numX += connect.getCellNumX();
+ numX += vnode.getCellNumX();
+ }
+ vnode.setVnodeCellNumX(numX);
+ vnode.setVnodeCellNumY(numY);
+ }
+
@Transactional(rollbackFor = Exception.class)
public boolean analyze(ModelRbd modelRbd) {
boolean result = true;
@@ -138,7 +613,7 @@
// 6. 杞崲涓虹畻娉曞簱鎺ュ彛XML
if (result) {
- result = createIfXmlFromRbd(modelRbd, algorithmList, modelNodeAndVnodeList);
+// result = createIfXmlFromRbd(modelRbd, algorithmList, modelNodeAndVnodeList);
}
// 7. 淇濆瓨妯″瀷
@@ -187,134 +662,6 @@
}
modelNodeList.addAll(nodesToAdd);
modelLineList.addAll(linesToAdd);
- }
-
- private boolean createIfXmlFromRbd(ModelRbd modelRbd,
- List<Algorithm> algorithmList,
- List<ModelNode> modelNodeAndVnodeList) {
- boolean result = true;
-
- try {
- Document document = DocumentHelper.createDocument();
- // 娣诲姞root鑺傜偣
- Element root = document.addElement("DES");
- root.addAttribute("Name", "A System");
- // 娣诲姞terminal鑺傜偣鍒皉oot1
- Element terminal = root.addElement("Node");
- terminal.addAttribute("Name", "Terminal");
- terminal.addAttribute("Type", "NODE");
-
- // 灏嗘ā鍨嬭浆鎹负DOM锛屾坊鍔犲埌root
- Algorithm endAlgo = algorithmList.stream().filter(item ->
- "end".equals(item.getAlgorithmType())).collect(Collectors.toList()).get(0);
- ModelNode computerNode = modelNodeAndVnodeList.stream().filter(item ->
- endAlgo.getComputerList().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- node2DOM(algorithmList, modelNodeAndVnodeList, computerNode, root);
-
- // 娣诲姞start鑺傜偣鍒皉oot
- Element start = root.addElement("Node");
- start.addAttribute("Name", "Start");
- start.addAttribute("Type", "NODE");
- // 娣诲姞link锛堣矾寰勶級鍒皉oot
- Element link = root.addElement("Link");
- Element block = link.addElement("Block");
- block.addAttribute("Name", "Terminal");
- block = link.addElement("Block");
- block.addAttribute("Name", computerNode.getId().toString());
- block = link.addElement("Block");
- block.addAttribute("Name", "Start");
-
-// document.setXMLEncoding("UTF-8");
-// String xmlString = document.asXML();
- // 杈撳嚭鏍煎紡鍖杧ml
- XMLWriter xmlWriter = null;
- try {
- OutputFormat format = OutputFormat.createPrettyPrint();
- format.setEncoding("UTF-8");
- StringWriter writer = new StringWriter();
- xmlWriter = new XMLWriter(writer, format);
- xmlWriter.write(document);
- modelRbd.setPublishedXml(writer.toString());
- } finally {
- if (xmlWriter!=null) xmlWriter.close();
- }
- } catch (Exception e) {
- e.printStackTrace();
- result = false;
- }
-
- return result;
- }
-
- // 閫掑綊鍑芥暟
- private void node2DOM(List<Algorithm> algorithmList,
- List<ModelNode> modelNodeAndVnodeList,
- ModelNode node,
- Element parent) {
- if ("node".equals(node.getNodeType())) {
- Long dataId = node.getDataId();
- XhProductModel xhProductModel = xhProductModelDao.getById(dataId);
- if (xhProductModel == null) return;
- if ("5".equals(xhProductModel.getProductType())) {
- // 璁惧
- ParamData paramData = paramDataDao.getParamData(dataId, "expect");
- if (paramData == null) return;
- Element element = parent.addElement("Node");
- element.addAttribute("Name", dataId.toString());
- element.addAttribute("Type", "NODE");
- Element failureTag = element.addElement("Failure");
- failureTag.addAttribute("Dist", "EXP"); // TODO:闇�璁句负鍏蜂綋鐨勫垎甯�
- Element argsTag = failureTag.addElement("Args");
- Double value = new Double(paramData.getTaskMtbcfRegulate());
- value = 1.0/value;
- argsTag.addAttribute("value", value.toString());
- if (1==paramData.getRepairable()) {
- Element repairTag = element.addElement("Repair");
- repairTag.addAttribute("Dist", "EXP"); // TODO:闇�璁句负鍏蜂綋鐨勫垎甯�
- argsTag = repairTag.addElement("Args");
- value = new Double(paramData.getRepairMttcr());
- value = 1.0/value;
- argsTag.addAttribute("value", value.toString());
- Element repairTimeLimitTag = element.addElement("RepairTimeLimit");
- repairTimeLimitTag.setText(String.valueOf(paramData.getRepairMttcr()));
- }
- } else if ("10".equals(xhProductModel.getProductType())) {
- // 铏氬崟浣�
- ModelRbd rbdXDY = modelRbdDao.getDiagramOfXDY(dataId);
- if (rbdXDY == null) return;
- List<Algorithm> algorithmListXDY = algorithmDao.getListByModelId(rbdXDY.getId());
- List<ModelNode> modelNodeAndVnodeListXDY =modelNodeAlgorithmDao.getListByModelId(rbdXDY.getId());
- Algorithm endAlgo = algorithmListXDY.stream().filter(item ->
- "end".equals(item.getAlgorithmType())).collect(Collectors.toList()).get(0);
- ModelNode computerNode = modelNodeAndVnodeListXDY.stream().filter(item ->
- endAlgo.getComputerList().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- node2DOM(algorithmListXDY, modelNodeAndVnodeListXDY, computerNode, parent);
- }
- } else {
- // vnode锛堣繍绠楄妭鐐癸級
- Algorithm algo = algorithmList.stream().filter(item ->
- node.getId().equals(item.getId())).collect(Collectors.toList()).get(0);
- Element element = parent.addElement("Logic");
- element.addAttribute("Name", algo.getId().toString());
- if ("series".equals(algo.getAlgorithmType())) {
- element.addAttribute("Type", "SERIES");
- } else if ("parallel".equals(algo.getAlgorithmType())) {
- element.addAttribute("Type", "PARALLEL");
- } else if ("vote".equals(algo.getAlgorithmType())) {
- element.addAttribute("Type", "VOTE");
- element.addAttribute("VoteValue", algo.getVoteNum().toString());
- } else if ("switch".equals(algo.getAlgorithmType())) {
- element.addAttribute("Type", "STANDBY");
- } else if ("bridge".equals(algo.getAlgorithmType())) {
- element.addAttribute("Type", "BRIDGE");
- }
- String[] computerNodeListStr = algo.getComputerList().split(",");
- for (String nodeStr : computerNodeListStr) {
- ModelNode nd = modelNodeAndVnodeList.stream().filter(item ->
- nodeStr.equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- node2DOM(algorithmList, modelNodeAndVnodeList, nd, element);
- }
- }
}
private boolean getAlgorithmFromRbd(ModelRbd modelRbd,
@@ -864,8 +1211,8 @@
List<ModelLine> lines = modelLineList.stream().filter(item ->
item.getEndCell().equals(startNode.getPicId())).collect(Collectors.toList());
if (lines.size()<2) continue;
- List<ModelLinePair> linePairs = getLinePairs(lines);
- for (ModelLinePair linePair : linePairs) {
+ List<ModelLinePairDto> linePairs = getLinePairs(lines);
+ for (ModelLinePairDto linePair : linePairs) {
hasSimplifiedMe = simplifyBridgeOneLinePair(modelId, modelNodeList, modelLineList,
algorithmList, modelNodeAndVnodeList, startNode, linePair);
if (hasSimplifiedMe) {
@@ -884,7 +1231,7 @@
List<Algorithm> algorithmList,
List<ModelNode> modelNodeAndVnodeList,
ModelNode startNode,
- ModelLinePair linePair) {
+ ModelLinePairDto linePair) {
ModelNode node1 = null;
ModelNode node2 = null;
ModelNode node3 = null;
@@ -1095,11 +1442,11 @@
}
// 鎵惧嚭鎵�鏈�2鏍圭嚎鐨勭粍鍚�
- private List<ModelLinePair> getLinePairs(List<ModelLine> lines) {
- List<ModelLinePair> linePairs = new ArrayList<>();
+ private List<ModelLinePairDto> getLinePairs(List<ModelLine> lines) {
+ List<ModelLinePairDto> linePairs = new ArrayList<>();
for (int i=0; i<lines.size()-1; i++) {
for (int j=i+1; j<lines.size(); j++) {
- ModelLinePair linePair = new ModelLinePair();
+ ModelLinePairDto linePair = new ModelLinePairDto();
linePair.setLine1(lines.get(i));
linePair.setLine2(lines.get(j));
linePairs.add(linePair);
@@ -1250,6 +1597,14 @@
if (jsonValue!=null && StringUtils.isNotBlank(jsonValue.toString())) {
modelNode.setVoteNum(Integer.valueOf(jsonValue.toString()));
}
+ jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/startNodeId".split("/"));
+ if (jsonValue!=null && StringUtils.isNotBlank(jsonValue.toString())) {
+ modelNode.setPairStartNodeId(jsonValue.toString());
+ }
+ jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/endNodeId".split("/"));
+ if (jsonValue!=null && StringUtils.isNotBlank(jsonValue.toString())) {
+ modelNode.setPairEndNodeId(jsonValue.toString());
+ }
if ("node".equals(modelNode.getNodeType())) {
ProductImg productImg = new ProductImg();
String dataId = JsonUtils2.getJsonValueByPath(jsonObject, "data/dataId".split("/")).toString();
@@ -1265,22 +1620,39 @@
jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/reliabDistribType".split("/"));
if (jsonValue != null && StringUtils.isNotBlank(jsonValue.toString())) {
productImg.setReliabDistribType(Integer.valueOf(jsonValue.toString()));
+ if (3==productImg.getReliabDistribType()) {
+ // 浜岄」鍒嗗竷
+ jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/simulatTimes".split("/"));
+ if (jsonValue != null && StringUtils.isNotBlank(jsonValue.toString())) {
+ productImg.setBinomialTotalNum(Integer.valueOf(jsonValue.toString()));
+ modelNode.setBinomialTotalNum(Integer.valueOf(jsonValue.toString()));
+ }
+ jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/successTimes".split("/"));
+ if (jsonValue != null && StringUtils.isNotBlank(jsonValue.toString())) {
+ productImg.setBinomialSuccessNum(Integer.valueOf(jsonValue.toString()));
+ modelNode.setBinomialSuccessNum(Integer.valueOf(jsonValue.toString()));
+ }
+ }
}
- productImg.setTaskMtbcf(JsonUtils2.getJsonValueByPath(jsonObject, "data/taskMtbcf".split("/")).toString());
+ jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/taskMtbcf".split("/"));
+ if (null != jsonValue) productImg.setTaskMtbcf(jsonValue.toString());
jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/taskMtbcfOtherParams2".split("/"));
if (null != jsonValue) productImg.setTaskMtbcfOtherParams2(jsonValue.toString());
jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/taskMtbcfOtherParams3".split("/"));
if (null != jsonValue) productImg.setTaskMtbcfOtherParams3(jsonValue.toString());
jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/isRepair".split("/"));
- if (jsonValue != null && StringUtils.isNotBlank(jsonValue.toString())) {
+ if (jsonValue != null && StringUtils.isNotBlank(jsonValue.toString()) && !"null".equals(jsonValue.toString())) {
productImg.setIsRepair(Integer.valueOf(jsonValue.toString()));
+ } else {
+ productImg.setIsRepair(0);
}
if (1 == productImg.getIsRepair()) {
jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/repairDistribType".split("/"));
if (jsonValue != null && StringUtils.isNotBlank(jsonValue.toString())) {
productImg.setRepairDistribType(Integer.valueOf(jsonValue.toString()));
}
- productImg.setRepairMttcr(JsonUtils2.getJsonValueByPath(jsonObject, "data/repairMttcr".split("/")).toString());
+ jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/repairMttcr".split("/"));
+ if (null != jsonValue) productImg.setRepairMttcr(jsonValue.toString());
jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/repairMttcrOtherParams2".split("/"));
if (null != jsonValue) productImg.setRepairMttcrOtherParams2(jsonValue.toString());
jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/repairMttcrOtherParams3".split("/"));
--
Gitblit v1.9.1