Merge remote-tracking branch 'origin/master'

xyc

2024-10-14 3d72db70fcb406e02b283c4b624e8282ed301422

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

@@ -16,8 +16,9 @@
            </el-form-item>
            <el-form-item>
              <el-button type="primary" @click="saveDiagram()">暂存</el-button>
              <el-button type="primary" @click="analyzeDiagram()">保存</el-button>
              <el-button type="primary" @click="analyzeDiagram()">提交</el-button>
              <el-button type="primary" @click="clearDiagram()">清空图形</el-button>
              <el-button type="primary" @click="layoutDiagram()">一键排版</el-button>
              <el-button @click="leftAlign()">
                <i style="font-size: 1rem;" class="wt-iconfont icon-zuoduiqi"></i>
              </el-button>
@@ -42,7 +43,7 @@
              <el-button @click="redo()">重做</el-button>
            </el-form-item>
            <el-form-item>
              <zt-button type="delete" @click="deleteCompment()" />
              <zt-button type="delete" @click="deleteCompment()"/>
            </el-form-item>
          </el-form>
          <div id="containerImg" style="border: 1px solid #EAEBEE;border-radius: 6px;
@@ -63,6 +64,8 @@
  import {setHartBeat} from '@/commonJS/common';
  import Cookies from 'js-cookie'
  import {getUUID} from '../../../../packages/utils'
  // import Mousetrap from 'mousetrap'
  // var Mousetrap = require('mousetrap');
  // import RBDDefault from './RBD-default.json'

  export default {
@@ -106,7 +109,7 @@
                "text": {
                  "refY": "100%",
                  "textVerticalAnchor": "top",
                  "text": "start",
                  "text": "",
                  "refY2": 4
                },
                "image": {
@@ -229,7 +232,7 @@
                "text": {
                  "refY": "100%",
                  "textVerticalAnchor": "top",
                  "text": "dashedBox",
                  "text": "",
                  "refY2": 4
                },
                "image": {
@@ -257,7 +260,7 @@
                        "r": 4,
                        "magnet": true,
                        "stroke": "#5F95FF",
                        "strokeWidth": 1,

                        "fill": "#fff",
                        "style": {
                          "visibility": "hidden"
@@ -351,7 +354,7 @@
                "text": {
                  "refY": "100%",
                  "textVerticalAnchor": "top",
                  "text": "end",
                  "text": "",
                  "refY2": 4
                },
                "image": {
@@ -465,39 +468,43 @@
              "shape": "edge",
              "id": "66c81c68-0827-4a3c-8343-e2c453d3e9e7",
              "router": {
                "name": "manhattan"
                "name": "manhattan",
                "args": {
                        "startDirections": ["right"],
                        "endDirections": ["left"]
                       }
              },
              "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"
                "name": "manhattan",
                "args": {
                        "startDirections": ["right"],
                        "endDirections": ["left"]
                       }
              },
              "connector": {
                "name": "rounded"
              },
              "source": {
                "cell": 15000,
                "port": "right1"
                "cell": 15000
              },
              "target": {
                "cell": "20000",
                "port": "left1"
                "cell": "20000"
              },
              "zIndex": 5
              "zIndex": -1
            }
          ]
        }
@@ -507,6 +514,8 @@
    },
    data() {
      return {
        nodeX: '',
        nodeY: '',
        isFirstLoad: true,
        hasMoveNode: false,
        hasMoveSingleNode: null,
@@ -518,19 +527,19 @@
        timer: null,
        imagesList: [
          {
            imgPath: 'parallel',
            imgName: 'parallel',
            nodeType: 'parallel',
            imgPath: 'switch',
            imgName: '',
            nodeType: 'switch',
            imgWidth: 50,
            imgHeight: 50,
            imgId: '9',
            data: {}
          },
          {imgPath: 'vote', imgName: 'vote', nodeType: 'vote', imgWidth: 50, imgHeight: 50, imgId: '6', data: {}},
          {imgPath: 'vote', imgName: '', nodeType: 'vote', imgWidth: 50, imgHeight: 50, imgId: '6', data: {}},
          {
            imgPath: 'switch',
            imgName: 'switch',
            nodeType: 'switch',
            imgPath: 'parallel',
            imgName: '',
            nodeType: 'parallel',
            imgWidth: 50,
            imgHeight: 50,
            imgId: '5',
@@ -538,22 +547,13 @@
          },
          {
            imgPath: 'bridgeConnection',
            imgName: 'bridgeConnection',
            imgName: '',
            nodeType: 'bridgeConnection',
            imgWidth: 50,
            imgHeight: 50,
            imgId: '10',
            data: {}
          },
          // {
          //   imgPath: 'dashedBox',
          //   imgName: 'dashedBox',
          //   nodeType: 'dashedBox',
          //   imgWidth: 60,
          //   imgHeight: 60,
          //   imgId: '10000',
          //   data: {}
          // },
        ],
        imagesList2: [],
        nodeType: '',
@@ -584,10 +584,12 @@
          productType: '',
          voteNum: '',
          repairMttcr: '',
          repairMttcrOther: '',
          repairMttcrOtherParams2: '',
          repairMttcrOtherParams3: '',
          repairDistribType: '',
          reliabDistribType: '',
          taskMtbcfOther: '',
          taskMtbcfOtherParams2: '',
          taskMtbcfOtherParams3: '',
          isRepair: 0,
          taskMtbcf: '',
          numberInputValue: '',
@@ -610,7 +612,13 @@
          stroke: '#5F95FF',
          strokeWidth: 1,
          connector: 'rounded',
          router: 'manhattan',
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['top', 'bottom'], // 从下方开始
              endDirections: ['left'],      // 向左方结束
            },
          },
          label: '',
          nodeStroke: '#5F95FF',
          nodeStrokeWidth: 1,
@@ -813,6 +821,10 @@
          connecting: {
            router: {
              name: 'manhattan',
              args: {
                startDirections: ['top', 'bottom'], // 从下方开始
                endDirections: ['left'],      // 向左方结束
              },
            },
            connector: {
              name: 'rounded',
@@ -823,6 +835,7 @@
            anchor: 'center',
            connectionPoint: 'anchor',
            allowBlank: false,
            allowLoop: false, // 是否允许创建循环连线，即边的起始节点和终止节点为同一节点，默认为 true
            snap: {
              radius: 20,
            },
@@ -1001,12 +1014,15 @@

              reliabDistribType: item.reliabDistribType ? item.reliabDistribType : 1,
              taskMtbcf: item.taskMtbcf,
              taskMtbcfOther: item.taskMtbcfOther,
              taskMtbcfOther2: item.taskMtbcfOtherParams2,
              taskMtbcfOther3: item.taskMtbcfOtherParams3,

              isRepair: item.isRepair,
              repairDistribType: item.repairDistribType ? item.repairDistribType : 1,
              repairMttcr: item.repairMttcr,
              repairMttcrOther: item.repairMttcrOther,
              repairMttcrOther2: item.repairMttcrOtherParams2,
              repairMttcrOther3: item.repairMttcrOtherParams3,
              successRate: item.successRate,

              imgHeight: item.imgHeight,
              imgWidth: item.imgWidth,
@@ -1057,10 +1073,42 @@
        stencil.load(imageNodes, 'group1')
        stencil.load(imageNodes2, 'group2')

        this.graph.bindKey(['meta+c', 'ctrl+up'], () => {
          console.log('按了小键盘的UP键')
        })

// konami code!
        // 单击node节点
        // this.graph.on('node:click', ({ e, x, y, node, view}) => {
        //   Mousetrap.bind('up', function(e) {
        //     e.preventDefault();
        //     node.getBBox().x
        //     node.getBBox().y
        //     setTimeout(()=>{
        //       node.position(node.getBBox().x,node.getBBox().y -0.5)
        //       console.log(x,y,'按下了↑键 up');
        //     },100)
        //   })
        //   Mousetrap.bind('down', function(e) {
        //     e.preventDefault();
        //     setTimeout(()=>{
        //       node.position(node.getBBox().x,node.getBBox().y+0.5)
        //       console.log(x,y,'按下了↓键 down');
        //     },100)
        //
        //   })
        //   Mousetrap.bind('left', function(e) {
        //     e.preventDefault();
        //     setTimeout(()=>{
        //       node.position(node.getBBox().x-0.5,node.getBBox().y)
        //       console.log(x,y,'按下了←键 left');
        //     },100)
        //
        //   })
        //   Mousetrap.bind('right', function(e) {
        //     e.preventDefault();
        //     setTimeout(()=>{
        //       node.position(node.getBBox().x+0.5,node.getBBox().y)
        //       console.log(x,y,'按下了→键 right');
        //     },100)
        //   })
        // })
        this.graph.bindKey(['meta+c', 'ctrl+c'], () => {
          const cells = this.graph.getSelectedCells()
          if (cells.length) {
@@ -1174,9 +1222,7 @@
          //
          // })
        })
        // 单击node节点
        this.graph.on('node:click', ({node}) => {
        })

        // 控制连接桩显示/隐藏
        this.graph.on('node:delete', ({view, e}) => {
          e.stopPropagation()
@@ -1209,57 +1255,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()
@@ -1362,7 +1408,7 @@
                })
                return false
              })
            }else if (this.isMultipleBrach(node)) {
            } else if (this.isMultipleBrach(node)) {
              //提示是否要删除
              this.$confirm('是否删除该节点?', '提示', {
                confirmButtonText: '确定',
@@ -1390,7 +1436,7 @@
                })
                return false
              })
            }else {
            } else {
              //提示不能删除
              this.$message({message: '该条线路上只有该节点，无法删除', type: 'warning'})
              return false; // 取消操作
@@ -1407,45 +1453,96 @@
      },
      async saveDiagram() {
        console.log(JSON.stringify(this.graph.toJSON()), 'graph.toJSON()')
        const nodes = this.graph.getNodes()
        let nodeArr2 = []
        // 检查除当前节点之外的所有节点的包围框是否相交
        for (const node of nodes) {
          console.log(node, 'saveDiagram node')
          if (node.getData().nodeType == 'node' && node.getData().productType != 'product_xdy' && node.getData().dataId) {
            nodeArr2.push(node.getData().dataId)
          }
        }
        this.dataForm.nodeArr = nodeArr2
        //   获取所有子节点
        this.getNodeArr()
        this.dataForm.content = JSON.stringify(this.graph.toJSON())
        this.dataForm.urlPref = window.SITE_CONFIG['apiURL']
        console.log(this.dataForm, 'dataFrom')
        await this.$http[this.dataForm.id === null ? 'post' : 'put'](`/taskReliability/ModelLine/`, this.dataForm).then(async res => {
          if (res.msg === 'success') {
            this.$emit('refreshDataList')
            this.$alert('保存成功', '提示', {
              confirmButtonText: '确定'
            })
          }
        })
      },
      async analyzeDiagram() {
        console.log(JSON.stringify(this.graph.toJSON()), 'graph.toJSON()')
      getNodeArr() {
        const nodes = this.graph.getNodes()
        let nodeArr2 = []
        // 检查除当前节点之外的所有节点的包围框是否相交
        for (const node of nodes) {
          if (node.getData().nodeType === 'node' && node.getData().productType !== 'product_xdy' && node.getData().dataId) {
          console.log(node, 'saveDiagram node')
          if (node.getData().nodeType == 'node' && node.getData().dataId) {
            nodeArr2.push(node.getData().dataId)
          }
        }
        this.dataForm.nodeArr = nodeArr2
      },
      async analyzeDiagram() {
        console.log(JSON.stringify(this.graph.toJSON()), 'graph.toJSON()')
        // 检查除当前节点之外的所有节点的包围框是否相交
        //   获取所有子节点
        this.getNodeArr()
        const nodes = this.graph.getNodes()
        for (const node of nodes) {
          if (node.getData().nodeType === 'dashedBox') {
            this.$message({message: '该模型中存在虚框，无法提交', type: 'warning'})
            return false;
          }
          if (node.getData().nodeType === 'vote') {
            if (node.getData().voteNum === null || node.getData().voteNum === '') {
              this.$message({message: '表决节点的表决数量未设置', type: 'warning'})
              return false;
            }
            const edges = this.graph.getIncomingEdges(node);
            if (node.getData().voteNum >= edges.length) {
              this.$message({message: '表决节点的表决数量必须小于该节点的进线数量', type: 'warning'})
              return false;
            }
          }
          if (node.getData().nodeType === 'switch') {
            if (node.getData().voteNum === null || node.getData().voteNum === '') {
              this.$message({message: '旁联节点的备份数量未设置', type: 'warning'})
              return false;
            }
            const edges = this.graph.getIncomingEdges(node);
            if (node.getData().voteNum >= edges.length) {
              this.$message({message: '旁联节点的备份数量必须小于该节点的进线数量', type: 'warning'})
              return false;
            }
          }
        }
        this.dataForm.content = JSON.stringify(this.graph.toJSON())
        this.dataForm.urlPref = window.SITE_CONFIG['apiURL']
        await this.$http['post'](`/taskReliability/ModelLine/analyze`, this.dataForm).then(async res => {
          if (res.msg === 'success') {
            this.$alert('解析成功', '提示', {
            this.$emit('refreshDataList')
            this.$alert('提交成功', '提示', {
              confirmButtonText: '确定'
            })
          }
        })
      },
      async layoutDiagram() {
        console.log(JSON.stringify(this.graph.toJSON()), 'graph.toJSON()')
        this.dataForm.content = JSON.stringify(this.graph.toJSON())
        this.dataForm.urlPref = window.SITE_CONFIG['apiURL']
        await this.$http['post'](`/taskReliability/ModelLine/layout`, this.dataForm).then(async res => {
          if (res.msg === 'success') {
            // this.$emit('refreshDataList')
            // this.$alert('解析成功', '提示', {
            //   confirmButtonText: '确定'
            // })
            console.log(res.data, 'layoutDiagram res.data')
            this.dataForm.content = res.data.content
            console.log(this.dataForm.content, 'layoutDiagram dataForm.content')
            this.diagramJson = JSON.parse(this.dataForm.content)
            this.graph.fromJSON(this.diagramJson)
            this.isFirstLoad = false;
            // console.log(this.diagramJson.cells.length, 'this.diagramJson.cells.length')

            this.graph.positionContent('left')
          }
        })
      },
@@ -1613,11 +1710,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'
@@ -1626,9 +1718,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
@@ -1653,23 +1749,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'},
            connector: {name: 'rounded'}
          })
          this.graph.addEdge({
            source: {cell: result.newEndNode, port: 'right1'},
            target: {cell: graphNode, port: 'left1'},
            router: {name: 'manhattan'},
            connector: {name: 'rounded'}
          })
        }
      },
      addNodeAndConnect(targetNode, dragNode, centerX, centerY) { // graphCell是画布上原有的节点。dragNode是当前拖拽的节点
@@ -1693,17 +1803,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}
          }
        }
      },
      // 相交的边
@@ -1724,7 +1841,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
          }
        }
@@ -1735,14 +1852,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
@@ -1751,29 +1868,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},
              router: {name: 'manhattan'},
              connector: {name: 'rounded'}
              source: {cell: result.newEndNode},
              target: {cell: endNode},
              router: {
                name: 'manhattan',
                args: {
                  startDirections: routerStart, // 从下方开始
                  endDirections: routerEnd,      // 向左方结束
                },
              },
              connector: {name: 'rounded'},
              zIndex: -1
            })
          } else {
            this.graph.addEdge({
              source: {cell: startNode, port: startPort},
              target: {cell: result.newStartNode, port: endPort},
              router: {name: 'manhattan'},
              connector: {name: 'rounded'}
              source: {cell: startNode},
              target: {cell: result.newStartNode},
              router: {
                name: 'manhattan',
                args: {
                  startDirections: routerStart, // 从下方开始
                  endDirections: routerEnd,      // 向左方结束
                },
              },
              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()
        }
@@ -1805,34 +1941,41 @@
      createParallelBrach(x, y, dragNode) {
        dragNode.position(x + 320, y - dragNode.size().height / 2)
        const connectNode = this.createConnectNode(x + 50, y)
        this.createBrach(dragNode,connectNode,x,y-50)
        this.createBrach(dragNode,connectNode,x,y+50)

        return {newStartNode: connectNode, newEndNode: dragNode}
      },
      createBrach(dragNode,connectNode,x,y){
        const dashedBox = this.createDashedBox(x + 150, y)
        dragNode.setData({startNodeId: connectNode.id})

        this.graph.addEdge({
          source: {cell: connectNode, port: 'right1'},
          target: {cell: dashedBox, port: 'left1'},
          router: {name: 'manhattan'},
          connector: {name: 'rounded'}
          source: {cell: connectNode},
          target: {cell: dashedBox},
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['top','bottom'], // 从下方开始
              endDirections: ['left'],      // 向左方结束
            },
          },
          connector: {name: 'rounded'},
          zIndex: -1
        })
        this.graph.addEdge({
          source: {cell: dashedBox, port: 'right1'},
          target: {cell: dragNode, port: 'left1'},
          router: {name: 'manhattan'},
          connector: {name: 'rounded'}
          source: {cell: dashedBox},
          target: {cell: dragNode},
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['right'], // 从下方开始
              endDirections: ['top','bottom'],      // 向左方结束
            },
          },
          connector: {name: 'rounded'},
          zIndex: -1
        })
        return {newStartNode: connectNode, newEndNode: dragNode}
        /*        this.graph.addEdge({
                  source: {cell: startNode, port: 'right1'},
                  target: {cell: connectNode, port: 'left1'},
                  router: {name: 'manhattan'},
                  connector: {name: 'rounded'}
                })
                this.graph.addEdge({
                  source: {cell: dragNode, port: 'right1'},
                  target: {cell: endNode, port: 'left1'},
                  router: {name: 'manhattan'},
                  connector: {name: 'rounded'}
                })*/
      },
      createBridgeConnection(x, y, dragNode) {
        console.log(x, y, 'leftX centerY')
@@ -1841,10 +1984,36 @@

        const leftConnectNode = this.createConnectNode(x, y + 87)
        const alignCenterDashedBox = this.createDashedBox(x + 209, y + 87)
        const rightConnectNode = this.createBridgeNode(x + 530, y + 87)

        const leftBottomDashedBox = this.createDashedBox(x + 40, y + 160)
        const rightBottomDashedBox = this.createDashedBox(x + 380, y + 160)
        let edgeTop = this.graph.addEdge({
          source: {cell: leftTopDashedBox},
          target: {cell: rightTopDashedBox},
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['right'], // 从下方开始
              endDirections: ['left'],      // 向左方结束
            },
          },
          connector: {name: 'rounded'},
          zIndex: -1
        })
        let edgeBottom = this.graph.addEdge({
          source: {cell: leftBottomDashedBox},
          target: {cell: rightBottomDashedBox},
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['right'], // 从下方开始
              endDirections: ['left'],      // 向左方结束
            },
          },
          connector: {name: 'rounded'},
          zIndex: -1
        })

        const rightConnectNode = this.createBridgeNode(x + 530, y + 87, leftConnectNode.id, edgeTop.id, edgeBottom.id)

        rightConnectNode.setData({startNodeId: leftConnectNode.id})
        leftConnectNode.setData({endNodeId: rightConnectNode.id})
@@ -1861,55 +2030,84 @@
                  connector: {name: 'rounded'}
                })*/
        this.graph.addEdge({
          source: {cell: leftConnectNode, port: 'right1'},
          target: {cell: leftTopDashedBox, port: 'left1'},
          router: {name: 'manhattan'},
          source: {cell: leftConnectNode},
          target: {cell: leftTopDashedBox},
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['top', 'bottom'],
              endDirections: ['left'],
            },
          },
          connector: {name: 'rounded'},
          zIndex: -1
        })
        this.graph.addEdge({
          source: {cell: leftConnectNode, port: 'right1'},
          target: {cell: leftBottomDashedBox, port: 'left1'},
          router: {name: 'manhattan'},
          source: {cell: leftConnectNode},
          target: {cell: leftBottomDashedBox},
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['top', 'bottom'], // 从下方开始
              endDirections: ['left'],      // 向左方结束
            },
          },
          connector: {name: 'rounded'},
        })

        let edgeTop = this.graph.addEdge({
          source: {cell: leftTopDashedBox, port: 'right1'},
          target: {cell: rightTopDashedBox, port: 'left1'},
          router: {name: 'manhattan'},
          connector: {name: 'rounded'},
        })
        let edgeBottom = this.graph.addEdge({
          source: {cell: leftBottomDashedBox, port: 'right1'},
          target: {cell: rightBottomDashedBox, port: 'left1'},
          router: {name: 'manhattan'},
          connector: {name: 'rounded'},
          zIndex: -1
        })

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

        this.graph.addEdge({
          source: {cell: edgeTop},
          target: {cell: alignCenterDashedBox, port: 'top1'},
          router: {name: 'manhattan'},
          target: {cell: alignCenterDashedBox},
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['top', 'bottom'], // 从下方开始
              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'},
          router: {
            name: 'manhattan',
            args: {
              startDirections: ['top', 'bottom'], // 从下方开始
              endDirections: ['top', 'bottom'],      // 向左方结束
            },
          },
          connector: {name: 'rounded'},
          zIndex: -1
        })
        dragNode.remove()
        return {newStartNode: leftConnectNode, newEndNode: rightConnectNode}
@@ -1935,7 +2133,7 @@
              'xlink:href': '/modelImg/dashedBox.svg',
            },
            text: {
              text: 'dashedBox',
              text: '',
              fontSize: 14,
              refX: 0.5,
              refY: '100%',
@@ -1971,7 +2169,7 @@
              'xlink:href': '/modelImg/connect.svg',
            },
            text: {
              text: 'connect',
              text: '',
              fontSize: 14,
              refX: 0.5,
              refY: '100%',
@@ -1985,18 +2183,19 @@
        connectNode.position(x, y - connectNode.size().height / 2)
        return connectNode
      },
      createBridgeNode(x, y) {
        const connectId = getUUID().toString()
      createBridgeNode(x, y, connectId, edgeTopId, edgeBottomId) {
        const dragNodeId = getUUID().toString()
        let bridgeNode = this.graph.addNode({
          shape: 'image',
          width: 30,
          height: 30,
          id: connectId,
          id: dragNodeId,
          data: {
            isSelfCreated: true,
            type: 'imageNodes',
            endNodeId: dragNodeId,
            startNodeId: connectId,
            edgeTopId: edgeTopId,
            edgeBottomId: edgeBottomId,
            dataId: '',
            nodeType: 'bridge',
            nodeTypeExt: '',
@@ -2095,9 +2294,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)