ze-react-component-library/es/ZESchemaEditor/ER/schemasToGraphData.js

ZeroETP React Component Library

var __assign = this && this.__assign || function () {
  __assign = Object.assign || function (t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
      s = arguments[i];

      for (var p in s) {
        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
      }
    }

    return t;
  };

  return __assign.apply(this, arguments);
};

var __spreadArray = this && this.__spreadArray || function (to, from) {
  for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) {
    to[j] = from[i];
  }

  return to;
};

import { EntityType } from './const';
var NODE_WIDTH = 214;
var NODE_HEIGHT = 252;
var GAP = 120;
export default (function (schemas, position) {
  /** 链接桩样式配置, 将具有相同行为和外观的链接桩归为同一组 */
  var portAttrs = {
    circle: {
      r: 7,
      stroke: '#31d0c6',
      strokeWidth: 2,
      fill: '#fff',

      /** 链接桩在连线交互时可以被连接上 */
      magnet: true
    }
  };
  var edges = [];
  var refs = [];
  var entityNodes = [];
  var eventNodes = [];
  schemas.forEach(function (d) {
    var nodeConfig = {
      id: d._id,
      width: NODE_WIDTH,
      height: NODE_HEIGHT,
      entityId: d._id,
      entityName: d.name + " (" + d._id + ")",
      entityType: d.type === "entity" ? EntityType.FACT : EntityType.DIM,
      properties: d.properties.map(function (p) {
        if (p.ref) {
          refs.push(p.ref);
          edges.push({
            id: d._id + "_" + p._id,
            source: d._id,
            target: p.ref,
            renderKey: 'EDGE1',
            edgeContentWidth: 20,
            edgeContentHeight: 20,

            /** 设置连线样式 */
            attrs: {
              line: {
                stroke: '#d8d8d8',
                strokeWidth: 1,
                targetMarker: {
                  name: 'classic'
                }
              }
            }
          });
        }

        return {
          propertyId: p._id,
          propertyName: p.name,
          propertyType: p.type
        };
      }),
      renderKey: 'NODE1',
      ports: {
        groups: {
          top: {
            position: 'top',
            attrs: portAttrs
          },
          right: {
            position: 'right',
            attrs: portAttrs
          },
          bottom: {
            position: 'bottom',
            attrs: portAttrs
          },
          left: {
            position: 'left',
            attrs: portAttrs
          }
        },
        items: [{
          id: 'top_port',
          group: 'top'
        }, {
          id: 'right_port',
          group: 'right'
        }, {
          id: 'bottom_port',
          group: 'bottom'
        }, {
          id: 'left_port',
          group: 'left'
        }]
      }
    };

    if (d.type === "entity") {
      entityNodes.push(nodeConfig);
    } else {
      nodeConfig.x = 0;
      nodeConfig.y = (NODE_HEIGHT + GAP) * eventNodes.length;
      eventNodes.push(nodeConfig);
    }
  });
  var refEntityNodes = entityNodes.filter(function (f) {
    return refs.includes(f.id);
  }).map(function (e, i) {
    return __assign(__assign({}, e), {
      x: NODE_WIDTH + GAP,
      y: (NODE_HEIGHT + GAP) * i
    });
  });
  var restEntityNodes = entityNodes.filter(function (f) {
    return !refs.includes(f.id);
  }).map(function (e, i) {
    return __assign(__assign({}, e), {
      x: (NODE_WIDTH + GAP) * 2,
      y: (NODE_HEIGHT + GAP) * i
    });
  });

  var nodes = __spreadArray(__spreadArray(__spreadArray([], eventNodes), refEntityNodes), restEntityNodes); // 有已保存的画布布局时


  if (position) {
    var maxX_1 = 0;
    var originNodes = nodes.filter(function (n) {
      return n.id in position;
    }).map(function (m) {
      var _a = position[m.id],
          x = _a.x,
          y = _a.y;

      if (x > maxX_1) {
        maxX_1 = x;
      }

      return __assign(__assign({}, m), {
        x: x,
        y: y
      });
    }); // 如果是新增的schema，统一最右边单独放一列

    var newNodes = nodes.filter(function (n) {
      return !(n.id in position);
    }).map(function (m, i) {
      var x = maxX_1 + NODE_WIDTH + GAP;
      var y = (NODE_HEIGHT + GAP) * i;
      return __assign(__assign({}, m), {
        x: x,
        y: y
      });
    });
    return {
      nodes: __spreadArray(__spreadArray([], originNodes), newNodes),
      edges: edges
    };
  }

  return {
    nodes: nodes,
    edges: edges
  };
});