修改

jinlin

2024-09-19 79da50ff6a8cabc082472c27ac85724ef664db67

修改

 modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/model/RbdTreeNode.java

@@ -18,6 +18,10 @@
    private String pairEndNodeId;
    private String nodeType;
    private String algorithmType;

    private double x;
    private double y;

    private double blockX;
    private double blockY;
    private double descentWidth;

 modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/service/ModelLineService.java

@@ -8,14 +8,11 @@
import com.zt.common.utils.UUIDUtil;
import com.zt.life.modules.mainPart.basicInfo.dao.ParamDataDao;
import com.zt.life.modules.mainPart.basicInfo.dao.XhProductModelDao;
import com.zt.life.modules.mainPart.basicInfo.model.ParamData;
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.ModelLinePairDto;
import com.zt.life.modules.mainPart.taskReliability.model.*;
import org.apache.commons.lang3.StringUtils;
import org.dom4j.Element;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
@@ -193,7 +190,11 @@
        // 7. 递归计算RBD的布局空间参数（x、y坐标）
        root.setBlockX(0);
        root.setBlockY(0);
        calcPosition(rbdJsonArray, root);

        Map<String, RbdTreeNode> nodeMap = new HashMap<>();
        calcPosition(rbdJsonArray, root, nodeMap);
        setEdgeRouter(rbdJsonArray, nodeMap);

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("cells", rbdJsonArray);
        modelRbd.setContent(jsonObject.toString());
@@ -207,15 +208,53 @@
        return result;
    }

    private void setNodePositionXY(JSONArray rbdJsonArray, RbdTreeNode block) {
    private void setEdgeRouter(JSONArray rbdJsonArray, Map<String, RbdTreeNode> nodeMap) {
        for (int i = 0; i < rbdJsonArray.size(); i++
        ) {
            JSONObject jsonObject = rbdJsonArray.getJSONObject(i);
            if (jsonObject.get("shape").equals("edge")) {
                String sourceId = JsonUtils2.getJsonValueByPath(jsonObject, "source/cell".split("/")).toString();
                String targetId = JsonUtils2.getJsonValueByPath(jsonObject, "target/cell".split("/")).toString();
                RbdTreeNode sourceNode = nodeMap.get(sourceId);
                RbdTreeNode targetNode = nodeMap.get(targetId);
                if (sourceNode != null) {
                    if ("connect".equals(sourceNode.getNodeType()) && !"10000".equals(sourceId)){
                        if (sourceNode.getY()+sourceNode.getMyHeight()/2 == targetNode.getY()+targetNode.getMyHeight()/2){
                            JsonUtils2.setJsonValueByPath(jsonObject, "router/args/startDirections".split("/"),"right".split(","));
                            JsonUtils2.setJsonValueByPath(jsonObject, "router/args/endDirections".split("/"),"left".split(","));
                        }else{
                            JsonUtils2.setJsonValueByPath(jsonObject, "router/args/startDirections".split("/"),"top,bottom".split(","));
                            JsonUtils2.setJsonValueByPath(jsonObject, "router/args/endDirections".split("/"),"left".split(","));
                        }
                    }
                }
                if (targetNode != null) {
                    if ("parallel,vote".contains(targetNode.getNodeType())){
                        if (sourceNode.getY()+sourceNode.getMyHeight()/2 == targetNode.getY()+targetNode.getMyHeight()/2){
                            JsonUtils2.setJsonValueByPath(jsonObject, "router/args/startDirections".split("/"),"right".split(""));
                            JsonUtils2.setJsonValueByPath(jsonObject, "router/args/endDirections".split("/"),"left".split(""));
                        }else{
                            JsonUtils2.setJsonValueByPath(jsonObject, "router/args/startDirections".split("/"),"right".split(""));
                            JsonUtils2.setJsonValueByPath(jsonObject, "router/args/endDirections".split("/"),"top,bottom".split(""));
                        }
                    }
                }
            }
        }
    }

    private void setNodePositionXY(JSONArray rbdJsonArray, RbdTreeNode block, Map<String, RbdTreeNode> nodeMap) {
        Double x = block.getBlockX() + (block.getBlockWidth() - block.getMyWidth()) / 2;
        Double y = block.getBlockY() + (block.getBlockHeight() - block.getMyHeight()) / 2;
        block.setX(x);
        block.setY(y);
        nodeMap.put(block.getPicId(),block);
        setRbdNodePosition(rbdJsonArray, block.getPicId(), x, y);
    }

    private void calcPosition(JSONArray rbdJsonArray, RbdTreeNode block) {
    private void calcPosition(JSONArray rbdJsonArray, RbdTreeNode block, Map<String, RbdTreeNode> nodeMap) {
        if (block.getNodeType().equals("node")) {
            setNodePositionXY(rbdJsonArray, block);
            setNodePositionXY(rbdJsonArray, block,nodeMap);
        } else {
            double blockWidth = block.getBlockWidthNum() * LAYOUT_CELL_SIZE_X;
            double blockHeight = block.getBlockHeightNum() * LAYOUT_CELL_SIZE_Y;
@@ -246,7 +285,7 @@

                    child.setBlockY(block.getBlockY());
                    child.setBlockX(subBlockX);
                    calcPosition(rbdJsonArray, child);
                    calcPosition(rbdJsonArray, child, nodeMap);
                    subBlockX = subBlockX + selfWidth;

                }
@@ -259,12 +298,13 @@
                RbdTreeNode connectBlock = new RbdTreeNode();
                connectBlock.setMyWidth(getRbdNodeInfo(rbdJsonArray, block.getPairStartNodeId(), "size/width"));
                connectBlock.setMyHeight(getRbdNodeInfo(rbdJsonArray, block.getPairStartNodeId(), "size/height"));
                connectBlock.setNodeType("connect");
                connectBlock.setPicId(block.getPairStartNodeId());
                connectBlock.setBlockX(block.getBlockX());
                connectBlock.setBlockY(firstSubBlockY);
                connectBlock.setBlockWidth(LAYOUT_CELL_SIZE_X);
                connectBlock.setBlockHeight(blockHeight);
                setNodePositionXY(rbdJsonArray, connectBlock);
                setNodePositionXY(rbdJsonArray, connectBlock, nodeMap);

                for (RbdTreeNode child : children) {
                    child.setDescentWidth(block.getBlockWidth() - 2 * LAYOUT_CELL_SIZE_X);
@@ -276,20 +316,21 @@
                    child.setBlockX(block.getBlockX() + LAYOUT_CELL_SIZE_X);
                    child.setBlockY(subBlockY);
                    subBlockY = subBlockY + child.getBlockHeightNum() * LAYOUT_CELL_SIZE_Y;
                    calcPosition(rbdJsonArray, child);
                    calcPosition(rbdJsonArray, child, nodeMap);
                }

                // 设置运算符的位置
                RbdTreeNode opeBlock = new RbdTreeNode();

                opeBlock.setPicId(block.getPicId());
                opeBlock.setNodeType("parallel");
                opeBlock.setMyWidth(getRbdNodeInfo(rbdJsonArray, block.getPicId(), "size/width"));
                opeBlock.setMyHeight(getRbdNodeInfo(rbdJsonArray, block.getPicId(), "size/height"));
                opeBlock.setBlockX(block.getBlockX() + blockWidth - LAYOUT_CELL_SIZE_X);
                opeBlock.setBlockY(firstSubBlockY);
                opeBlock.setBlockWidth(LAYOUT_CELL_SIZE_X);
                opeBlock.setBlockHeight(blockHeight);
                setNodePositionXY(rbdJsonArray, opeBlock);
                setNodePositionXY(rbdJsonArray, opeBlock, nodeMap);
            }
        }


 web/src/views/modules/taskReliability/RBD-edit-img.vue

@@ -468,47 +468,35 @@
              "shape": "edge",
              "id": "66c81c68-0827-4a3c-8343-e2c453d3e9e7",
              "router": {
                "name": "manhattan",
                args: {
                        startDirections: ['top','bottom'], // 从下方开始
                        endDirections: ['left'],      // 向左方结束
                       },
                "name": "manhattan"
              },
              "connector": {
                "name": "rounded"
              },
              "source": {
                "cell": "10000",
                "port": "right1"
                "cell": "10000"
              },
              "target": {
                "cell": 15000,
                "port": "left1"
                "cell": 15000
              },
              "zIndex": 4
              "zIndex": -1
            },
            {
              "shape": "edge",
              "id": "a0f3cf90-6d37-4ee0-a254-90b4ec2b6a7f",
              "router": {
                "name": "manhattan",
                args: {
                        startDirections: ['top','bottom'], // 从下方开始
                        endDirections: ['left'],      // 向左方结束
                       },
                "name": "manhattan"
              },
              "connector": {
                "name": "rounded"
              },
              "source": {
                "cell": 15000,
                "port": "right1"
                "cell": 15000
              },
              "target": {
                "cell": "20000",
                "port": "left1"
                "cell": "20000"
              },
              "zIndex": 5
              "zIndex": -1
            }
          ]
        }
@@ -1268,57 +1256,57 @@
          })
        })

        this.graph.on('node:mouseenter', ({node}) => {
          const container = document.getElementById('containerImg')
          const ports = container.querySelectorAll(
            '.x6-port-body',
          )
          this.showPorts(ports, true)
        })
        // this.graph.on('node:mouseenter', ({node}) => {
        //   const container = document.getElementById('containerImg')
        //   const ports = container.querySelectorAll(
        //     '.x6-port-body',
        //   )
        //   this.showPorts(ports, true)
        // })

        this.graph.on('node:mouseleave', ({node}) => {
          // if (node.hasTool('button-remove')) {
          //   node.removeTool('button-remove')
          // }
          const container = document.getElementById('containerImg')
          const ports = container.querySelectorAll(
            '.x6-port-body',
          )
          this.showPorts(ports, false)
        })
        // this.graph.on('node:mouseleave', ({node}) => {
        //   // if (node.hasTool('button-remove')) {
        //   //   node.removeTool('button-remove')
        //   // }
        //   const container = document.getElementById('containerImg')
        //   const ports = container.querySelectorAll(
        //     '.x6-port-body',
        //   )
        //   this.showPorts(ports, false)
        // })

        this.graph.on('edge:mouseenter', ({cell}) => {
          // alert(123)
          cell.addTools([
            {
              name: 'source-arrowhead',
            },
            {
              name: 'target-arrowhead',
              args: {
                attrs: {
                  fill: 'red',
                },
              },
            },
            {
              name: 'segments',
              args: {snapRadius: 20, attrs: {fill: '#444'}}
            },
          ])
        })

        this.graph.on('edge:mouseleave', ({cell}) => {
          cell.removeTools()
        })
        // this.graph.on('edge:mouseenter', ({cell}) => {
        //   // alert(123)
        //   cell.addTools([
        //     {
        //       name: 'source-arrowhead',
        //     },
        //     {
        //       name: 'target-arrowhead',
        //       args: {
        //         attrs: {
        //           fill: 'red',
        //         },
        //       },
        //     },
        //     {
        //       name: 'segments',
        //       args: {snapRadius: 20, attrs: {fill: '#444'}}
        //     },
        //   ])
        // })
        //
        // this.graph.on('edge:mouseleave', ({cell}) => {
        //   cell.removeTools()
        // })

        await this.getDiagram(this.dataForm.id)
      },
      showPorts(ports, show) {
        for (let i = 0, len = ports.length; i < len; i = i + 1) {
          ports[i].style.visibility = show ? 'visible' : 'hidden'
        }
      },
      // showPorts(ports, show) {
      //   for (let i = 0, len = ports.length; i < len; i = i + 1) {
      //     ports[i].style.visibility = show ? 'visible' : 'hidden'
      //   }
      // },
      reset() {
        this.graph.drawBackground({color: '#fff'})
        const nodes = this.graph.getNodes()
@@ -1708,11 +1696,6 @@
            centerX = graphNode.position().x + graphNode.getBBox().width / 2
            centerY = graphNode.position().y + graphNode.getBBox().height / 2
            let result = this.addNodeAndConnect(graphNode, dragNode, centerX, centerY)
            if (!result) {
              dragNode.remove()
              this.$message({message: '没有足够的空间放置该节点，请扩大剩余空间', type: 'warning'})
              return
            }

            let startPort = 'right1'
            let endPort = 'left1'
@@ -1721,9 +1704,13 @@
              endPort = 'top1'
            }

            inEdges[0].target = {cell: result.newStartNode.id, port: endPort}
            outEdges[0].source = {cell: result.newEndNode.id, port: startPort}
            inEdges[0].target = {cell: result.newStartNode.id}
            outEdges[0].source = {cell: result.newEndNode.id}
            graphNode.remove()
            if (!result.canPlace) {
//调用自动排版
              this.layoutDiagram()
            }
          }
        } else { //并行结构
          const graphNodeStartNodeId = graphNode.getData().startNodeId  // 获取画布上原有节点的开始ID
@@ -1748,35 +1735,37 @@
            pointXY.maxY + offHeight / 2 + 30 : pointXY.minY - offHeight / 2 - 30

          let result = this.addNodeAndConnect(null, dragNode, minX, centerY)
          if (!result) {
            dragNode.remove()
            this.$message({message: '没有足够的空间放置该节点，请扩大剩余空间', type: 'warning'})
            return
          console.log(result, 'result111')
          this.graph.addEdge({
            source: {cell: graphNodeStartNode},
            target: {cell: result.newStartNode},
            router: {
              name: 'manhattan',
              args: {
                startDirections: ['top', 'bottom'], // 从下方开始
                endDirections: ['left'],      // 向左方结束
              },
            },
            connector: {name: 'rounded'},
            zIndex: -1
          })
          this.graph.addEdge({
            source: {cell: result.newEndNode},
            target: {cell: graphNode},
            router: {
              name: 'manhattan',
              args: {
                startDirections: ['right'], // 从下方开始
                endDirections: ['top', 'bottom'],      // 向左方结束
              },
            },
            connector: {name: 'rounded'},
            zIndex: -1
          })
          if (!result.canPlace) {
//调用自动排版
            this.layoutDiagram()
          }
          this.graph.addEdge({
            source: {cell: graphNodeStartNode, port: 'right1'},
            target: {cell: result.newStartNode, port: 'left1'},
            router: {
              name: 'manhattan',
              args: {
                startDirections: ['top','bottom'], // 从下方开始
                endDirections: ['left'],      // 向左方结束
              },
            },
            connector: {name: 'rounded'}
          })
          this.graph.addEdge({
            source: {cell: result.newEndNode, port: 'right1'},
            target: {cell: graphNode, port: 'left1'},
            router: {
              name: 'manhattan',
              args: {
                startDirections: ['top','bottom'], // 从下方开始
                endDirections: ['left'],      // 向左方结束
              },
            },
            connector: {name: 'rounded'}
          })
        }
      },
      addNodeAndConnect(targetNode, dragNode, centerX, centerY) { // graphCell是画布上原有的节点。dragNode是当前拖拽的节点
@@ -1800,17 +1789,24 @@
        }
        leftTopX = centerX - width / 2
        leftTopY = centerY - height / 2
        let canPlace = true;
        if (!this.canPlace(targetNode, dragNode, {leftTopX, leftTopY, width, height})) {
          return false
          canPlace = false
        }

        if (dragNodeType === 'node' || dragNodeType === 'dashedBox') {
          dragNode.position(leftTopX, leftTopY)
          return {newStartNode: dragNode, newEndNode: dragNode}
          return {newStartNode: dragNode, newEndNode: dragNode, canPlace: canPlace}
        } else if (dragNodeType === 'bridgeConnection') {
          return this.createBridgeConnection(leftTopX, leftTopY, dragNode)
          return {
            ...this.createBridgeConnection(leftTopX, leftTopY, dragNode),
            ...{canPlace: canPlace}
          }
        } else {
          return this.createParallelBrach(leftTopX, centerY, dragNode)
          return {
            ...this.createParallelBrach(leftTopX, centerY, dragNode),
            ...{canPlace: canPlace}
          }
        }
      },
      // 相交的边
@@ -1831,7 +1827,7 @@
        } else {
          centerX = dragNode.position().x + dragNode.getBBox().width / 2
          centerY = source.position().y + source.getBBox().height / 2
          if (target.getData().nodeType === 'node') {
          if (target.getData().nodeType === 'node' || target.getData().nodeType === 'dashedBox') {
            centerY = target.position().y + target.getBBox().height / 2
          }
        }
@@ -1842,14 +1838,14 @@
        let endNode = this.graph.getCellById(endNodeId)

        if (startNode && endNode) {
          let isRight = true;
          let startPort = 'right1'
          let endPort = 'left1'
          let routerStart = ['right'];
          let routerEnd = ['left'];
          if (this.isTopBottom(graphEdge)) {
            startPort = 'bottom1'
            endPort = 'top1'
            routerStart = ['top', 'bottom'];
            routerEnd = ['top', 'bottom'];
          }

          let isRight = true;
          if (this.hasOtherLineToMyLine(graphEdge.id)) {
            let leftX = startNode.position().x + startNode.getBBox().width
            let rightX = endNode.position().x
@@ -1858,41 +1854,48 @@
              isRight = false
            }
          }

          let result = this.addNodeAndConnect(null, dragNode, centerX, centerY)
          if (!result) {
            dragNode.remove()
            this.$message({message: '没有足够的空间放置该节点，请扩大剩余空间', type: 'warning'})
            return
          }
          if (isRight) {
            graphEdge.target = {cell: result.newStartNode.id, port: endPort}
            if (endNode.getData()) {
              if ("parallel,vote,bridge".indexOf(endNode.getData().nodeType) > -1) {
                isRight = false
              }
            }
          }
          let result = this.addNodeAndConnect(null, dragNode, centerX, centerY)

          if (isRight) {
            graphEdge.target = {cell: result.newStartNode.id}
            this.graph.addEdge({
              source: {cell: result.newEndNode, port: startPort},
              target: {cell: endNode, port: endPort},
              source: {cell: result.newEndNode},
              target: {cell: endNode},
              router: {
                name: 'manhattan',
                args: {
                  startDirections: ['top','bottom'], // 从下方开始
                  endDirections: ['left'],      // 向左方结束
                  startDirections: routerStart, // 从下方开始
                  endDirections: routerEnd,      // 向左方结束
                },
              },
              connector: {name: 'rounded'}
              connector: {name: 'rounded'},
              zIndex: -1
            })
          } else {
            this.graph.addEdge({
              source: {cell: startNode, port: startPort},
              target: {cell: result.newStartNode, port: endPort},
              source: {cell: startNode},
              target: {cell: result.newStartNode},
              router: {
                name: 'manhattan',
                args: {
                  startDirections: ['top','bottom'], // 从下方开始
                  endDirections: ['left'],      // 向左方结束
                  startDirections: routerStart, // 从下方开始
                  endDirections: routerEnd,      // 向左方结束
                },
              },
              connector: {name: 'rounded'}
              connector: {name: 'rounded'},
              zIndex: -1
            })
            graphEdge.source = {cell: result.newEndNode.id, port: startPort}
            graphEdge.source = {cell: result.newEndNode.id}
          }
          if (!result.canPlace) {
            this.layoutDiagram()
          }
          // graphEdge.remove()
        }
@@ -1928,28 +1931,30 @@
        dragNode.setData({startNodeId: connectNode.id})

        this.graph.addEdge({
          source: {cell: connectNode, port: 'right1'},
          target: {cell: dashedBox, port: 'left1'},
          source: {cell: connectNode},
          target: {cell: dashedBox},
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['top','bottom'], // 从下方开始
              startDirections: ['right'], // 从下方开始
              endDirections: ['left'],      // 向左方结束
            },
          },
          connector: {name: 'rounded'}
          connector: {name: 'rounded'},
          zIndex: -1
        })
        this.graph.addEdge({
          source: {cell: dashedBox, port: 'right1'},
          target: {cell: dragNode, port: 'left1'},
          source: {cell: dashedBox},
          target: {cell: dragNode},
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['top','bottom'], // 从下方开始
              startDirections: ['right'], // 从下方开始
              endDirections: ['left'],      // 向左方结束
            },
          },
          connector: {name: 'rounded'}
          connector: {name: 'rounded'},
          zIndex: -1
        })
        return {newStartNode: connectNode, newEndNode: dragNode}
        /*        this.graph.addEdge({
@@ -1992,20 +1997,21 @@
                  connector: {name: 'rounded'}
                })*/
        this.graph.addEdge({
          source: {cell: leftConnectNode, port: 'right1'},
          target: {cell: leftTopDashedBox, port: 'left1'},
          source: {cell: leftConnectNode},
          target: {cell: leftTopDashedBox},
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['top','bottom'], // 从下方开始
              endDirections: ['left'],      // 向左方结束
              startDirections: ['top', 'bottom'],
              endDirections: ['left'],
            },
          },
          connector: {name: 'rounded'},
          zIndex: -1
        })
        this.graph.addEdge({
          source: {cell: leftConnectNode, port: 'right1'},
          target: {cell: leftBottomDashedBox, port: 'left1'},
          source: {cell: leftConnectNode},
          target: {cell: leftBottomDashedBox},
          router: {
            name: 'manhattan',
            args: {
@@ -2014,81 +2020,88 @@
            },
          },
          connector: {name: 'rounded'},
          zIndex: -1
        })

        let edgeTop = this.graph.addEdge({
          source: {cell: leftTopDashedBox, port: 'right1'},
          target: {cell: rightTopDashedBox, port: 'left1'},
          source: {cell: leftTopDashedBox},
          target: {cell: rightTopDashedBox},
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['top','bottom'], // 从下方开始
              startDirections: ['right'], // 从下方开始
              endDirections: ['left'],      // 向左方结束
            },
          },
          connector: {name: 'rounded'},
          zIndex: -1
        })
        let edgeBottom = this.graph.addEdge({
          source: {cell: leftBottomDashedBox, port: 'right1'},
          target: {cell: rightBottomDashedBox, port: 'left1'},
          source: {cell: leftBottomDashedBox},
          target: {cell: rightBottomDashedBox},
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['top','bottom'], // 从下方开始
              startDirections: ['right'], // 从下方开始
              endDirections: ['left'],      // 向左方结束
            },
          },
          connector: {name: 'rounded'},
          zIndex: -1
        })

        this.graph.addEdge({
          source: {cell: rightTopDashedBox, port: 'right1'},
          target: {cell: rightConnectNode, port: 'left1'},
          source: {cell: rightTopDashedBox},
          target: {cell: rightConnectNode},
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['top','bottom'], // 从下方开始
              endDirections: ['left'],      // 向左方结束
              startDirections: ['right'], // 从下方开始
              endDirections: ['top', 'bottom'],      // 向左方结束
            },
          },
          connector: {name: 'rounded'},
          zIndex: -1
        })
        this.graph.addEdge({
          source: {cell: rightBottomDashedBox, port: 'right1'},
          target: {cell: rightConnectNode, port: 'left1'},
          source: {cell: rightBottomDashedBox},
          target: {cell: rightConnectNode},
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['top','bottom'], // 从下方开始
              endDirections: ['left'],      // 向左方结束
              startDirections: ['right'],
              endDirections: ['top', 'bottom'],
            },
          },
          connector: {name: 'rounded'},
          zIndex: -1
        })

        this.graph.addEdge({
          source: {cell: edgeTop},
          target: {cell: alignCenterDashedBox, port: 'top1'},
          target: {cell: alignCenterDashedBox},
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['top','bottom'], // 从下方开始
              endDirections: ['left'],      // 向左方结束
              endDirections: ['top', 'bottom'],      // 向左方结束
            },
          },
          connector: {name: 'rounded'},
          zIndex: -1
        })
        this.graph.addEdge({
          source: {cell: alignCenterDashedBox, port: 'bottom1'},
          source: {cell: alignCenterDashedBox},
          target: {cell: edgeBottom},
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['top','bottom'], // 从下方开始
              endDirections: ['left'],      // 向左方结束
              endDirections: ['top', 'bottom'],      // 向左方结束
            },
          },
          connector: {name: 'rounded'},
          zIndex: -1
        })
        dragNode.remove()
        return {newStartNode: leftConnectNode, newEndNode: rightConnectNode}
@@ -2274,9 +2287,20 @@
        return false
      },
      isTopBottom(edge) {
        if (edge.source.port === 'top1' || edge.source.port === 'bottom1' || edge.target.port === 'top1' || edge.target.port === 'bottom1') {
        if (this.hasTopBottom(edge.getRouter().args.startDirections) && this.hasTopBottom(edge.getRouter().args.endDirections)) {
          return true
        }
        return false
      },
      hasTopBottom(object) {
        let result = false
        for (let a of object) {
          if (a == "top" || a == "bottom") {
            result = true
            break
          }
        }
        return result
      },
      isMultipleBrach(node) {
        let outEdges = this.getOutLinesOfNode(node)

 web/src/views/modules/taskReliability/ReliabilityWeakness.vue

@@ -21,12 +21,12 @@
                  :row-style="rowStyle"
                  border @selection-change="table.selectionChangeHandle">
          <el-table-column prop="name" label="名称"/>
          <el-table-column prop="mtbf" label="MTBF" align="right">
          <el-table-column prop="mtbf" label="MTTF(任务可靠性)" align="right">
            <template slot-scope="scope">
              <span>{{  keepNumber(scope.row.mtbf) }}</span>
            </template>
          </el-table-column>
          <el-table-column prop="mttr" label="MTTR" align="right">
          <el-table-column prop="mttr" label="MTTR(任务可靠性)" align="right">
            <template slot-scope="scope">
              <span>{{  keepNumber(scope.row.mttr) }}</span>
            </template>