service-flow-designer 0.0.2-tmp3 → 1.0.1

package/dist/lib/designer/common/components/value-set-input/value-set-input.vue2.js

@@ -0,0 +1,431 @@
+"use strict";
+const es = require("element-plus/es");
+require("element-plus/es/components/base/style/css");
+require("element-plus/es/components/popover/style/css");
+require("element-plus/es/components/row/style/css");
+require("element-plus/es/components/table/style/css");
+require("element-plus/es/components/table-column/style/css");
+require("element-plus/es/components/icon/style/css");
+require("element-plus/es/components/empty/style/css");
+require("element-plus/es/components/col/style/css");
+require("element-plus/es/components/cascader-panel/style/css");
+require("element-plus/es/components/input/style/css");
+require("element-plus/es/components/button/style/css");
+const vue = require("vue");
+const iconsVue = require("@element-plus/icons-vue");
+const option = require("./option.js");
+const pageStore = require("../../../../stores/page-store.js");
+const fileUpload = require("../file-upload.vue.js");
+const http = require("agilebuilder-ui/src/utils/request");
+const elementPlus = require("element-plus");
+const _withScopeId = (n) => (vue.pushScopeId("data-v-53118ceb"), n = n(), vue.popScopeId(), n);
+const _hoisted_1 = { key: 0 };
+const _hoisted_2 = { style: { "margin-top": "10px", "font-size": "10px", "display": "flex", "align-items": "center", "justify-self": "center" } };
+const _hoisted_3 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ vue.createElementVNode("span", { style: { "margin-left": "5px" } }, "输入变量名后点击加号按钮添加", -1));
+const _hoisted_4 = { class: "totalStyle" };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "ValueSetInput",
+    inheritAttrs: false
+  },
+  __name: "value-set-input",
+  props: {
+    modelValue: {
+      type: [String],
+      default: null
+    },
+    paramTypes: {
+      type: Array,
+      default: () => []
+    },
+    size: {
+      type: String,
+      default: "default"
+    },
+    inputSize: {
+      type: String,
+      default: "small"
+    },
+    showLabel: {
+      type: Boolean,
+      default: false
+    },
+    width: {
+      type: String,
+      default: ""
+    },
+    customInputTypes: {
+      type: Array,
+      default: []
+    },
+    customOptions: {
+      type: Object,
+      default: () => ({})
+    },
+    showFileUpload: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const serviceFlowStoreUtil = pageStore.useServiceFlowStore();
+    const emits = __emit;
+    const props = __props;
+    const defalutValue = vue.ref(null);
+    defalutValue.value = props.modelValue;
+    const typeOptions = vue.ref([]);
+    const showInputType = vue.ref("");
+    const fileObject = vue.ref({});
+    const labelValue = vue.ref(null);
+    const paramType = vue.ref(null);
+    const paramValue = vue.ref(null);
+    const valueOptions = vue.ref([]);
+    const selectOptions = vue.ref({});
+    const searchValue = vue.ref(null);
+    const popoverRef = vue.ref();
+    const selectInputType = ["context", "system", "task", "data", "service"];
+    props.customInputTypes.forEach((item) => {
+      const index = selectInputType.findIndex((type) => item === type);
+      if (index >= 0) {
+        selectInputType.splice(index, 1);
+      }
+    });
+    typeOptions.value = option.getTypeOptions(props.paramTypes);
+    setSelectOptions();
+    const showFileUploadOption = () => {
+      if (props.showFileUpload) {
+        if (typeOptions.value.findIndex((item) => item.value === "file") === -1) {
+          typeOptions.value.push({ label: "文件", value: "file" });
+        }
+      } else {
+        const index = typeOptions.value.findIndex((item) => item.value === "file");
+        if (index >= 0) {
+          typeOptions.value.splice(index, 1);
+        }
+      }
+    };
+    if (props.modelValue) {
+      const match = props.modelValue.match(/\${(.*?)\.(.*?)}/);
+      if (match) {
+        const type = match[1];
+        const val = match[2];
+        paramType.value = type;
+        paramValue.value = val;
+        showFileUploadOption();
+        if (paramType.value === "file") {
+          showInputType.value = "file";
+        } else if (selectInputType.includes(type)) {
+          if (paramType.value === "system") {
+            querySystemParams();
+          }
+          showInputType.value = "select";
+        } else {
+          showInputType.value = "input";
+        }
+        setValueOptions(paramType.value);
+        labelValue.value = formatter();
+      }
+    }
+    const filterTableData = vue.computed(
+      () => valueOptions.value.filter(
+        (data) => !searchValue.value || data.label.toLowerCase().includes(searchValue.value.toLowerCase() || data.value.toLowerCase().includes(searchValue.value.toLowerCase()))
+      )
+    );
+    function setSelectOptions() {
+      selectOptions.value.dataModelOptions = serviceFlowStoreUtil.pageContextVarOptions.dataOptions;
+      if (props.customOptions.data) {
+        selectOptions.value.dataModelOptions = props.customOptions.data;
+      }
+      selectOptions.value.serviceVarOptions = serviceFlowStoreUtil.getServiceVarOptions();
+    }
+    function formatter() {
+      if (props.modelValue) {
+        return getTypeLabel(paramType.value) + " : " + getValueLabel(paramType.value, paramValue.value);
+      }
+      return props.modelValue;
+    }
+    function paramTypeChange(paramType2) {
+      paramValue.value = "";
+      if (paramType2 === "file") {
+        showInputType.value = "file";
+      } else if (selectInputType.includes(paramType2)) {
+        showInputType.value = "select";
+        if (paramType2 === "system") {
+          querySystemParams();
+        } else {
+          setValueOptions(paramType2);
+        }
+      } else {
+        showInputType.value = "input";
+      }
+    }
+    function setValueOptions(value) {
+      if (value === "context") {
+        valueOptions.value = option.contextVarOptions;
+      } else if (value === "system") {
+        valueOptions.value = selectOptions.value.systemVarOptions || [];
+      } else if (value === "task") {
+        valueOptions.value = option.taskVarOptions;
+      } else if (value === "data") {
+        valueOptions.value = selectOptions.value.dataModelOptions || [];
+      } else if (value === "service") {
+        valueOptions.value = selectOptions.value.serviceVarOptions || [];
+      }
+    }
+    function selectRow(row) {
+      console.log(row, "选择数据");
+      paramValue.value = row.value;
+      defalutValue.value = "${" + paramType.value + "." + row.value + "}";
+      emits("update:modelValue", defalutValue.value);
+      popoverRef.value.hide();
+    }
+    function addInputParams() {
+      if (!paramValue.value) {
+        elementPlus.ElMessage.warning("请输入参数名");
+        return;
+      }
+      defalutValue.value = "${" + paramType.value + "." + paramValue.value + "}";
+      emits("update:modelValue", defalutValue.value);
+      popoverRef.value.hide();
+    }
+    function getTypeLabel(valueType) {
+      var _a;
+      return (_a = typeOptions.value.find((item) => item.value === valueType)) == null ? void 0 : _a.label;
+    }
+    function getValueLabel(valueType, value) {
+      if (selectInputType.includes(valueType)) {
+        const option2 = valueOptions.value.find((item) => item.value === value);
+        if (option2) {
+          return option2.label;
+        }
+      } else if (valueType === "file") {
+        return value.split("|")[0];
+      }
+      return value;
+    }
+    const tableRef = vue.ref();
+    function handSelectRow() {
+      if (!props.showLabel && showInputType.value === "select") {
+        const index = filterTableData.value.findIndex((item) => item.value === paramValue.value);
+        tableRef.value.setCurrentRow(filterTableData.value[index]);
+      }
+    }
+    const showPopover = () => {
+      showFileUploadOption();
+      setSelectOptions();
+      if (paramType.value) {
+        setValueOptions(paramType.value);
+      }
+      vue.nextTick(() => {
+        handSelectRow();
+      });
+    };
+    function clearData() {
+      defalutValue.value = null;
+      paramType.value = null;
+      paramValue.value = null;
+      emits("update:modelValue", defalutValue.value);
+    }
+    function successUpload() {
+      defalutValue.value = "${file." + fileObject.value.name + "|" + fileObject.value.fileUuid + "}";
+      paramValue.value = fileObject.value.name + "|" + fileObject.value.fileUuid;
+      emits("update:modelValue", defalutValue.value);
+      popoverRef.value.hide();
+    }
+    let lastSystemQuery = null;
+    function querySystemParams() {
+      if (lastSystemQuery && lastSystemQuery == searchValue.value) {
+        return;
+      }
+      const param = {
+        query: searchValue.value
+      };
+      lastSystemQuery = searchValue.value;
+      http.post("/component/system-params/query", param).then((results) => {
+        const tempOptions = [];
+        for (let result of results) {
+          tempOptions.push({
+            value: result.key,
+            label: result.key + "  (" + result.value + ")"
+          });
+        }
+        selectOptions.value.systemVarOptions = tempOptions;
+        if (paramType.value == "system") {
+          setValueOptions(paramType.value);
+        }
+      });
+    }
+    __expose({
+      setSelectOptions
+    });
+    return (_ctx, _cache) => {
+      const _component_el_button = es.ElButton;
+      const _component_el_input = es.ElInput;
+      const _component_el_cascader_panel = es.ElCascaderPanel;
+      const _component_el_col = es.ElCol;
+      const _component_el_empty = es.ElEmpty;
+      const _component_el_icon = es.ElIcon;
+      const _component_el_table_column = es.ElTableColumn;
+      const _component_el_table = es.ElTable;
+      const _component_el_row = es.ElRow;
+      const _component_el_popover = es.ElPopover;
+      return __props.showLabel ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_1, vue.toDisplayString(labelValue.value), 1)) : (vue.openBlock(), vue.createBlock(_component_el_popover, {
+        key: 1,
+        ref_key: "popoverRef",
+        ref: popoverRef,
+        trigger: "click",
+        width: 450
+      }, {
+        reference: vue.withCtx(() => [
+          vue.createVNode(_component_el_input, {
+            style: vue.normalizeStyle({ width: __props.width ? __props.width : "" }),
+            readonly: "",
+            size: __props.inputSize,
+            onClick: showPopover,
+            formatter,
+            class: "input-with-select",
+            "prefix-icon": vue.unref(iconsVue.Search),
+            modelValue: defalutValue.value,
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => defalutValue.value = $event),
+            placeholder: "请选择"
+          }, {
+            append: vue.withCtx(() => [
+              vue.createVNode(_component_el_button, {
+                size: __props.inputSize,
+                icon: vue.unref(iconsVue.Delete),
+                onClick: vue.withModifiers(clearData, ["stop"])
+              }, null, 8, ["size", "icon"])
+            ]),
+            _: 1
+          }, 8, ["style", "size", "prefix-icon", "modelValue"])
+        ]),
+        default: vue.withCtx(() => [
+          vue.createVNode(_component_el_row, null, {
+            default: vue.withCtx(() => [
+              vue.createVNode(_component_el_col, { span: 8 }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_el_cascader_panel, {
+                    modelValue: paramType.value,
+                    "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => paramType.value = $event),
+                    onChange: paramTypeChange,
+                    props: { emitPath: false },
+                    size: "small",
+                    style: { "width": "fit-content", "height": "200px" },
+                    options: typeOptions.value
+                  }, null, 8, ["modelValue", "options"])
+                ]),
+                _: 1
+              }),
+              !paramType.value ? (vue.openBlock(), vue.createBlock(_component_el_col, {
+                key: 0,
+                span: 16
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_el_empty, {
+                    description: "请选择类型",
+                    "image-size": 40
+                  })
+                ]),
+                _: 1
+              })) : showInputType.value === "input" ? (vue.openBlock(), vue.createBlock(_component_el_col, {
+                key: 1,
+                span: 16
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_el_input, {
+                    style: { "width": "75%" },
+                    size: "small",
+                    modelValue: paramValue.value,
+                    "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => paramValue.value = $event),
+                    placeholder: "请手动输入"
+                  }, null, 8, ["modelValue"]),
+                  vue.createVNode(_component_el_button, {
+                    style: { "float": "right" },
+                    onClick: addInputParams,
+                    size: "small",
+                    type: "primary",
+                    icon: vue.unref(iconsVue.Plus),
+                    circle: ""
+                  }, null, 8, ["icon"]),
+                  vue.createElementVNode("div", _hoisted_2, [
+                    vue.createVNode(_component_el_icon, null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.InfoFilled))
+                      ]),
+                      _: 1
+                    }),
+                    _hoisted_3
+                  ])
+                ]),
+                _: 1
+              })) : showInputType.value === "file" ? (vue.openBlock(), vue.createBlock(_component_el_col, {
+                key: 2,
+                span: 16
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(fileUpload, {
+                    modelValue: fileObject.value,
+                    "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => fileObject.value = $event),
+                    onOnSuccess: successUpload
+                  }, null, 8, ["modelValue"])
+                ]),
+                _: 1
+              })) : (vue.openBlock(), vue.createBlock(_component_el_col, {
+                key: 3,
+                span: 16
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_el_input, {
+                    size: "small",
+                    modelValue: searchValue.value,
+                    "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => searchValue.value = $event),
+                    placeholder: "搜索",
+                    "suffix-icon": vue.unref(iconsVue.Search),
+                    style: { "margin-bottom": "5px", "height": "25px" }
+                  }, null, 8, ["modelValue", "suffix-icon"]),
+                  vue.createVNode(_component_el_table, {
+                    ref_key: "tableRef",
+                    ref: tableRef,
+                    height: "155",
+                    "show-header": false,
+                    size: "small",
+                    "current-row-key": "code",
+                    "row-key": "code",
+                    "tree-props": { children: "items" },
+                    "highlight-current-row": true,
+                    data: filterTableData.value
+                  }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(_component_el_table_column, null, {
+                        default: vue.withCtx((scope) => [
+                          vue.createVNode(_component_el_button, {
+                            size: "small",
+                            onClick: ($event) => selectRow(scope.row)
+                          }, {
+                            default: vue.withCtx(() => [
+                              vue.createTextVNode(" 选择 ")
+                            ]),
+                            _: 2
+                          }, 1032, ["onClick"])
+                        ]),
+                        _: 1
+                      }),
+                      vue.createVNode(_component_el_table_column, { prop: "label" })
+                    ]),
+                    _: 1
+                  }, 8, ["data"]),
+                  vue.createElementVNode("div", _hoisted_4, "总计：" + vue.toDisplayString(filterTableData.value.length), 1)
+                ]),
+                _: 1
+              }))
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 512));
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/designer/common/util/node-util.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function getNextNodeById(node, flowData) {
+  const edges = flowData.edges.filter((item) => item.sourceNodeId === node.id);
+  const result = [];
+  if (edges) {
+    for (let i = 0; i < edges.length; i++) {
+      result.push(flowData.nodes.find((item) => item.id === edges[i].targetNodeId));
+    }
+  }
+  return result;
+}
+function isDeepEqual(tempData, flowData) {
+  if (typeof tempData !== "object" || typeof flowData !== "object") {
+    return tempData === flowData;
+  }
+  if (tempData === void 0 || tempData === null || flowData === void 0 || flowData === null) {
+    return tempData === flowData;
+  }
+  if (Array.isArray(tempData) && Array.isArray(flowData)) {
+    if (tempData.length !== flowData.length)
+      return false;
+    for (let i = 0; i < tempData.length; i++) {
+      if (!isDeepEqual(tempData[i], flowData[i]))
+        return false;
+    }
+    return true;
+  } else {
+    const keys1 = Object.keys(tempData);
+    const keys2 = Object.keys(flowData);
+    if (keys1.length !== keys2.length) {
+      return false;
+    }
+    for (let key of keys1) {
+      if (!keys2.includes(key) || !isDeepEqual(tempData[key], flowData[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+function findServcieByCode(code, datas) {
+  for (let i = 0; i < datas.length; i++) {
+    if (datas[i].code === code) {
+      return datas[i];
+    } else if (datas[i].children && datas[i].children.length > 0) {
+      const result = findServcieByCode(code, datas[i].children);
+      if (result) {
+        return result;
+      }
+    }
+  }
+}
+exports.findServcieByCode = findServcieByCode;
+exports.getNextNodeById = getNextNodeById;
+exports.isDeepEqual = isDeepEqual;

package/dist/lib/designer/desginer-index.css

@@ -0,0 +1,24 @@
+.amb-container-left[data-v-9cfa34b7] {
+  width: 260px;
+  padding-right: 20px;
+  overflow-y: auto;
+}
+.amb-container-main[data-v-9cfa34b7] {
+  padding: 0 10px 0 0;
+}
+.amb-container-main[data-v-9cfa34b7]::-webkit-scrollbar {
+  width: 1px;
+}
+.amb-container-attr[data-v-9cfa34b7] {
+  width: 300px;
+  padding-left: 20px;
+}
+/**
+解决右侧弹出属性配置遮罩层打开后页面其他地方无法点击问题
+ */
+[data-v-9cfa34b7]:v-deep(.el-drawer__header) {
+  margin-bottom: 0 !important;
+}
+[data-v-9cfa34b7] .el-overlay {
+  position: static;
+}

package/dist/lib/designer/desginer-index.vue.js

@@ -0,0 +1,6 @@
+"use strict";
+const desginerIndex_vue_vue_type_script_setup_true_lang = require("./desginer-index.vue2.js");
+;/* empty css                     */
+const _pluginVue_exportHelper = require("../_virtual/_plugin-vue_export-helper.js");
+const ServiceFlowDesginer = /* @__PURE__ */ _pluginVue_exportHelper(desginerIndex_vue_vue_type_script_setup_true_lang, [["__scopeId", "data-v-9cfa34b7"]]);
+module.exports = ServiceFlowDesginer;

package/dist/lib/designer/desginer-index.vue2.js

@@ -0,0 +1,113 @@
+"use strict";
+const es = require("element-plus/es");
+require("element-plus/es/components/base/style/css");
+require("element-plus/es/components/container/style/css");
+require("element-plus/es/components/main/style/css");
+require("element-plus/es/components/aside/style/css");
+const vue = require("vue");
+const servicePanel = require("./service-panel/service-panel.vue.js");
+const viewIndex = ;/* empty css                                  */
+require("./service-components/index.js");
+const pageStore = require("../stores/page-store.js");
+const http = require("agilebuilder-ui/src/utils/request");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "desginer-index",
+  props: {
+    pageContext: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const serviceTreeData = vue.ref([]);
+    const serviceFlowStoreUtil = pageStore.useServiceFlowStore();
+    serviceFlowStoreUtil.setPageContext(props.pageContext);
+    const logicFlowInstance = vue.ref(null);
+    const serviceFlowViewRef = vue.ref();
+    const winHeight = vue.ref();
+    const containerHeightStyle = vue.computed(() => {
+      return {
+        height: winHeight.value - 60 + "px"
+      };
+    });
+    const serviceFlowContainerRef = vue.ref();
+    vue.onMounted(() => {
+      loadTreeData();
+      if (serviceFlowContainerRef.value) {
+        const rect = serviceFlowContainerRef.value.getBoundingClientRect();
+        if (rect.y || rect.y === 0) {
+          winHeight.value = window.innerHeight - rect.y;
+        }
+      }
+    });
+    const loadTreeData = () => {
+      http.get(
+        "/component/super-page-design/service-flow/tree/" + props.pageContext.systemCode + "/" + props.pageContext.systemVersion
+      ).then((res) => {
+        if (res) {
+          serviceTreeData.value = res.children;
+        }
+      });
+    };
+    const dragNode = (serviceComponent) => {
+      console.log("dragNode");
+      serviceFlowViewRef.value.onDragNode(serviceComponent);
+    };
+    const onServiceClick = (service) => {
+      console.log("service-click", service);
+      serviceFlowViewRef.value.onServiceClick(service);
+    };
+    const clearFlowCanvas = () => {
+      serviceFlowViewRef.value.clearFlowCanvas();
+      logicFlowInstance.value = null;
+    };
+    return (_ctx, _cache) => {
+      const _component_el_aside = es.ElAside;
+      const _component_el_main = es.ElMain;
+      const _component_el_container = es.ElContainer;
+      return vue.openBlock(), vue.createElementBlock("div", {
+        ref_key: "serviceFlowContainerRef",
+        ref: serviceFlowContainerRef
+      }, [
+        vue.createVNode(_component_el_container, { class: "amb-container" }, {
+          default: vue.withCtx(() => [
+            vue.createVNode(_component_el_aside, { class: "amb-container-left" }, {
+              default: vue.withCtx(() => [
+                vue.createVNode(servicePanel, {
+                  logicFlowInstance: logicFlowInstance.value,
+                  "onUpdate:logicFlowInstance": _cache[0] || (_cache[0] = ($event) => logicFlowInstance.value = $event),
+                  serviceTreeData: serviceTreeData.value,
+                  onServiceClick,
+                  onClearFlowCanvas: clearFlowCanvas,
+                  onLoadTreeData: loadTreeData,
+                  onDragNode: dragNode,
+                  style: vue.normalizeStyle(containerHeightStyle.value)
+                }, null, 8, ["logicFlowInstance", "serviceTreeData", "style"])
+              ]),
+              _: 1
+            }),
+            vue.createVNode(_component_el_main, {
+              class: "amb-container-main",
+              style: vue.normalizeStyle(containerHeightStyle.value)
+            }, {
+              default: vue.withCtx(() => [
+                vue.createVNode(viewIndex, {
+                  logicFlowInstance: logicFlowInstance.value,
+                  "onUpdate:logicFlowInstance": _cache[1] || (_cache[1] = ($event) => logicFlowInstance.value = $event),
+                  serviceTreeData: serviceTreeData.value,
+                  onLoadTreeData: loadTreeData,
+                  ref_key: "serviceFlowViewRef",
+                  ref: serviceFlowViewRef
+                }, null, 8, ["logicFlowInstance", "serviceTreeData"])
+              ]),
+              _: 1
+            }, 8, ["style"])
+          ]),
+          _: 1
+        })
+      ], 512);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/designer/flow/base/AbLogicNode.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const LogicFlow = require("@logicflow/core");
+require("@logicflow/extension");
+class AbLogicNode extends LogicFlow.HtmlNode {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "isMounted", false);
+    __publicField(this, "r");
+    __publicField(this, "app");
+  }
+  setHtml(rootEl) {
+    if (!this.isMounted) {
+      this.isMounted = true;
+      const node = document.createElement("div");
+      rootEl.appendChild(node);
+      this.app.mount(node);
+    } else {
+      this.r.component.props.properties = this.props.model.getProperties();
+    }
+  }
+}
+module.exports = AbLogicNode;