@epxing/business 0.0.0-stage → 5.3.0-beta.2

package/dist/src/views/match/fieldMatch.vue.js

@@ -0,0 +1,610 @@
+import { createVNode, resolveComponent, mergeProps, withDirectives, resolveDirective, isVNode } from "vue";
+import { mapGetters } from "vuex";
+import EntitySubList from "@epxing/components/src/entity-sub-list";
+import { captureRef } from "@epxing/core/src/capture-ref";
+function _isSlot(s) {
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+const _sfc_main = {
+  name: "epx-field-match",
+  setField: false,
+  extends: EntitySubList,
+  data() {
+    return {
+      matchMode: [],
+      sourceField: [],
+      sourceEntity: "",
+      targetEntity: "",
+      entityMatchIds: "",
+      showSourceFieldPopover: false,
+      filterText: ""
+    };
+  },
+  computed: {
+    ...mapGetters(["getCodeById"])
+  },
+  watch: {
+    filterText: {
+      handler(v) {
+        this.$refs.sourceFieldTree.filter(v);
+      },
+      deep: true
+    }
+  },
+  methods: {
+    getField(fieldId, arr = this.sourceField) {
+      for (const item of arr) {
+        if (item.id === fieldId) {
+          return item;
+        } else if (item.children && item.children.length > 0) {
+          const field = this.getField(fieldId, item.children);
+          if (field) return field;
+        }
+      }
+    },
+    addTargetField() {
+      this.$createPage({
+        component: "match-add-target-field",
+        metaId: "FM_ATTRIBUTE",
+        entityMeta: this.$metaId,
+        // metaId: this.targetEntity,
+        openType: "2",
+        parentId: this.parentId,
+        targetEntity: this.targetEntity,
+        selectedField: this.data.map((item) => item.TARGET_FIELD),
+        title: "添加目标字段"
+      });
+    },
+    async setMarchRule(config, row) {
+      const mode = row.MODE;
+      const targetFieldId = row.TARGET_FIELD;
+      const sourceFieldId = row.SOURCE_FIELD;
+      if (mode !== "customize" && !sourceFieldId) {
+        this.$message.error("未选择源对象字段");
+        return;
+      }
+      if (mode === "conversion") {
+        const field = this.getField(sourceFieldId);
+        const targetField = this.getField(targetFieldId, this.targetField);
+        if (!["list", "radio", "multibox", "treeList", "text", "textarea", "bigtext"].includes(field.dataType) || !["list", "radio", "multibox", "treeList", "text", "textarea", "bigtext"].includes(targetField.dataType)) {
+          this.$message.error("映射转换只支持文本或选项类型");
+          return;
+        }
+        let conversionWay = row.CONVERSION_WAY;
+        if (!conversionWay) {
+          conversionWay = "manual";
+          if (field.dataType === "list" || field.dataType === "radio" || field.dataType === "multibox" || field.dataType === "treeList") {
+            conversionWay = "auto";
+            let options = this.getCodeById(field.codeKey);
+            if (!options) {
+              options = await this.$store.dispatch({
+                type: "ADD_LIST",
+                key: field.codeKey
+              });
+            }
+            if (options.length >= 50) {
+              await this.$confirm("检测到当前字段值较多，可能会存在卡顿的情况，建议您采用手动匹配，手动匹配下可以通过输入或选择的方式追加源对象字段值", "温馨提示", {
+                confirmButtonText: "手动匹配",
+                cancelButtonText: "继续自动匹配",
+                cancelButtonClass: "el-button--danger"
+              }).then(() => {
+                conversionWay = "manual";
+              }).catch(() => {
+                conversionWay = "auto";
+              });
+            }
+          }
+          this.$http.update({
+            entityId: this.$metaId,
+            "bean.ID": row.ID,
+            "bean.CONVERSION_WAY": conversionWay
+          });
+        }
+        setTimeout(() => {
+          this.$createPage({
+            component: "match-conversion",
+            metaId: this.$metaId,
+            openType: "2",
+            title: "映射转换",
+            sourceEntity: this.sourceEntity,
+            targetEntity: this.targetEntity,
+            targetFieldId,
+            entityFieldMatchId: row.ID,
+            sourceFieldId,
+            conversionWay
+          });
+        }, 200);
+      } else if (mode === "customize") {
+        this.$createPage({
+          component: "match-customize",
+          metaId: this.$metaId,
+          openType: "2",
+          title: "自定义规则",
+          sourceEntity: this.sourceEntity,
+          entityFieldMatchId: row.ID,
+          targetFieldId,
+          // targetC,
+          sourceFieldId,
+          paramList: this.$pageParams.paramList
+          // sourceC
+        });
+      } else if (mode === "direct") {
+        this.$message.info("直接匹配不需要操作");
+      } else {
+        this.$message.info("暂未设置匹配规则");
+      }
+    },
+    // getSourceName (sourceFieldId) {
+    //   const item = this.sourceField.find(item => {
+    //     return item.attribute.id === sourceFieldId
+    //   })
+    //   return item.attriLabel || item.attriName
+    // },
+    // 获取关联关系
+    async getLinkAttr() {
+      const defaultMetaId = this.upPage.$metaId;
+      const {
+        metaId: parentMetaId = defaultMetaId,
+        relationId = ""
+      } = this.$configs;
+      let relation = null;
+      let linkAttr = "";
+      let relationFlag = relationId;
+      let parentMeta = this.metas[parentMetaId];
+      if (!parentMeta) {
+        parentMeta = await this.$store.dispatch({
+          type: "ADD_META",
+          metaId: parentMetaId
+        });
+      }
+      this.parentMeta = parentMeta;
+      if (relationId.includes("#")) {
+        relationFlag = relationId.split("#")[0];
+        relation = parentMeta.getRelationByFlag(relationFlag);
+        const metaId2 = relation.entityA;
+        linkAttr = parentMeta.getLinkAttr(relationFlag);
+        const field = Object.values(parentMeta.attributes).find((item) => item.id === linkAttr);
+        if (field) this.parentField = field.name;
+        const attribute2 = Object.values(parentMeta.attributes).find((item) => item.id === linkAttr);
+        if (attribute2) this.linkAttrDataB = relationFlag.toUpperCase() + "|" + attribute2.name;
+        relationFlag = relationId.split("#")[1];
+        parentMeta = this.metas[metaId2];
+        if (!parentMeta) {
+          parentMeta = await this.$store.dispatch({
+            type: "ADD_META",
+            metaId: metaId2
+          });
+        }
+      } else {
+        const relation2 = parentMeta.getRelationByFlag(relationFlag);
+        const field = Object.values(parentMeta.attributes).find((item) => item.id === relation2.linkAttrB);
+        this.parentField = field.name;
+      }
+      relation = parentMeta.getRelationByFlag(relationFlag);
+      const metaId = relation.entityA;
+      linkAttr = parentMeta.getLinkAttr(relationFlag);
+      const parentAttr = parentMeta.relatedEntitys.find((item) => item.entityA === metaId);
+      const keyAttribute = parentMeta.getKeyAttribute();
+      if (parentAttr.linkAttrB && parentAttr.linkAttrB !== keyAttribute.id && relationId.includes("#")) {
+        const flag = relationId.split("#")[0];
+        const field = Object.values(parentMeta.attributes).find((item) => item.id === parentAttr.linkAttrB);
+        this.parentField = flag.toUpperCase() + "|" + field.name;
+      }
+      let meta = this.metas[metaId];
+      if (!meta) {
+        meta = await this.$store.dispatch({
+          type: "ADD_META",
+          metaId
+        });
+      }
+      this.configs.metaId = metaId;
+      const attribute = Object.values(meta.attributes).find((item) => item.id === linkAttr) || {};
+      this.linkAttrData = attribute.name;
+      if (!this.formData[this.parentField] && this.linkAttrDataB) {
+        this.linkAttrData = this.linkAttrDataB;
+        this.parentField = null;
+      }
+      this.getMatchMode();
+      this.loadFinish = true;
+    },
+    getMatchMode() {
+      this.$http.getCodes({
+        key: this.$meta.getAttribute("MODE").codeKey || "FM_FIELD_TRANSFER_MODE",
+        status: "on"
+      }).then((data) => {
+        this.matchMode = data;
+      });
+    },
+    getSourceField() {
+      this.$http.get({
+        action: "getEntityMetaView",
+        entityId: "FM_ENTITY_VIEW",
+        metaId: this.sourceEntity,
+        relationSort: "2,3"
+      }).then((data) => {
+        if (data) {
+          this.defaultExpandKeys = [data[0].code];
+          data[0].isMain = true;
+          const formatData = (arr, parentText, parent) => {
+            arr.forEach((item, index) => {
+              item.disabled = item.type === "meta";
+              if (parentText) item.linkText = parentText + "/" + item.text;
+              if (parent) item.parentField = parent;
+              if (item.children) formatData(item.children, !item.isMain ? item.linkText || item.text : "", !item.isMain ? item.id : "");
+            });
+          };
+          formatData(data);
+          this.sourceField = data;
+        }
+      });
+    },
+    getTargetField() {
+      this.$http.get({
+        action: "getEntityMetaView",
+        entityId: "FM_ENTITY_VIEW",
+        metaId: this.targetEntity,
+        relationSort: "2,3"
+      }).then((data) => {
+        if (data) {
+          const formatData = (arr, parentText, parent) => {
+            arr.forEach((item, index) => {
+              item.disabled = item.type === "meta";
+              if (parentText) item.linkText = parentText + "/" + item.text;
+              if (parent) item.parentField = parent;
+              if (item.children) formatData(item.children, !item.isMain ? item.linkText || item.text : "", !item.isMain ? item.id : "");
+            });
+          };
+          formatData(data);
+          this.targetField = data;
+        }
+      });
+    },
+    selectionChange(selection, row) {
+      this.selectionIds = [...selection.map((item) => item.ID)];
+    },
+    updateFieldRow(field, id, value) {
+      const params = {
+        entityId: this.$metaId,
+        "bean.ID": id
+      };
+      params[`bean.${field}`] = value;
+      this.$http.update(params);
+    },
+    updateField(id, props) {
+      if (!props) return;
+      const params = {
+        entityId: this.$metaId,
+        "bean.ID": id
+      };
+      for (const key in props) {
+        params[`bean.${key}`] = props[key];
+      }
+      this.$http.update(params);
+    },
+    selectSourceField(row, e) {
+      this.showSourceFieldPopover = true;
+      this.activeRow = row;
+      e.stopPropagation();
+      if (this.showSourceFieldPopover !== false) {
+        let elem = e.target;
+        while (!(elem.className && elem.className.split(" ").includes("el-table__cell"))) {
+          elem = elem.offsetParent;
+        }
+        this.$nextTick(() => {
+          let top = elem.offsetTop + this.$refs.table.$el.offsetTop + 100;
+          if (this.$refs.table.$el.offsetTop + this.$refs.table.$el.offsetHeight < top + this.$refs.popover.popperElm.offsetHeight) {
+            top = elem.offsetTop + this.$refs.table.$el.offsetTop - this.$refs.popover.popperElm.offsetHeight + 50;
+          }
+          this.$refs.popover.popperElm.style.top = top + "px";
+          this.$refs.popover.popperElm.style.left = elem.offsetLeft + "px";
+        });
+      }
+    },
+    setSourceField(node) {
+      if (node.type !== "meta") {
+        this.activeRow.SOURCE_FIELD = node.id;
+        this.activeRow.SOURCE_FIELD_CODE = node.linkCode || node.code;
+        this.activeRow.SOURCE_FIELD_NAME = node.linkText || node.text;
+        this.activeRow["SOURCE_FIELD#"] = node.linkText || node.text;
+        this.updateField(this.activeRow.ID, {
+          SOURCE_FIELD: this.activeRow.SOURCE_FIELD,
+          SOURCE_FIELD_CODE: this.activeRow.SOURCE_FIELD_CODE,
+          SOURCE_FIELD_NAME: this.activeRow.SOURCE_FIELD_NAME
+        });
+        this.showSourceFieldPopover = false;
+      }
+    },
+    deleteSourceField(row) {
+      row.SOURCE_FIELD = "";
+      row.SOURCE_FIELD_CODE = "";
+      row.SOURCE_FIELD_NAME = "";
+      row["SOURCE_FIELD#"] = "";
+      this.updateField(row.ID, {
+        SOURCE_FIELD: row.SOURCE_FIELD,
+        SOURCE_FIELD_CODE: row.SOURCE_FIELD_CODE,
+        SOURCE_FIELD_NAME: row.SOURCE_FIELD_NAME
+      });
+    },
+    closePopup() {
+      this.showSourceFieldPopover = false;
+    },
+    filterNode(value, data) {
+      console.log(value);
+      if (!value) return true;
+      return data.text && data.text.indexOf(value) !== -1;
+    },
+    renderTargetField(field) {
+      return {
+        default: ({
+          row
+        }) => {
+          return createVNode("span", null, [row.TARGET_FIELD_NAME || row["TARGET_FIELD#"]]);
+        }
+      };
+    },
+    renderSourceField(field) {
+      return {
+        default: ({
+          row
+        }) => {
+          return createVNode(resolveComponent("el-input"), {
+            "class": "select__input",
+            "modelValue": row.SOURCE_FIELD_NAME || row["SOURCE_FIELD#"],
+            "clearable": true,
+            "suffix-icon": "el-icon-search",
+            "size": "default",
+            "placeholder": "请选择",
+            "onClick": this.selectSourceField.bind(this, row),
+            "onClear": this.deleteSourceField.bind(this, row)
+          }, null);
+        }
+      };
+    },
+    renderSourceFieldPopover() {
+      return createVNode(resolveComponent("el-popover"), {
+        "ref": "popover",
+        "trigger": "manual",
+        "visible": this.showSourceFieldPopover,
+        "onUpdate:visible": ($event) => this.showSourceFieldPopover = $event,
+        "tabindex": 1
+      }, {
+        default: () => [createVNode("div", {
+          "class": "scope-opera__popper",
+          "onClick": (e) => e.stopPropagation()
+        }, [createVNode(resolveComponent("el-input"), {
+          "suffix-icon": "el-icon-search",
+          "size": "small",
+          "placeholder": "请输入字段名称筛选",
+          "modelValue": this.filterText,
+          "onUpdate:modelValue": ($event) => this.filterText = $event
+        }, null), createVNode(resolveComponent("el-tree"), {
+          "ref": captureRef(this, "sourceFieldTree"),
+          "data": this.sourceField,
+          "node-key": "id",
+          "filter-node-method": this.filterNode,
+          "onNodeClick": (node) => this.setSourceField(node)
+        }, {
+          default: ({
+            node,
+            data
+          }) => createVNode("span", {
+            "xxxx": true
+          }, [data.text])
+        })])]
+      });
+    },
+    renderMode(field) {
+      return {
+        default: ({
+          row
+        }) => {
+          let _slot;
+          return createVNode(resolveComponent("el-select"), {
+            "modelValue": row.MODE,
+            "onUpdate:modelValue": ($event) => row.MODE = $event,
+            "placeholder": "请选择",
+            "onChange": this.updateFieldRow.bind(this, "MODE", row.ID)
+          }, _isSlot(_slot = this.matchMode.map((mode) => {
+            return createVNode(resolveComponent("el-option"), {
+              "label": mode.name,
+              "key": mode.id,
+              "value": mode.code
+            }, null);
+          })) ? _slot : {
+            default: () => [_slot]
+          });
+        }
+      };
+    },
+    renderSyncKey(field) {
+      return {
+        default: ({
+          row
+        }) => {
+          return createVNode(resolveComponent("el-switch"), {
+            "modelValue": row.SYNC_KEY,
+            "onUpdate:modelValue": ($event) => row.SYNC_KEY = $event,
+            "onChange": this.updateFieldRow.bind(this, "SYNC_KEY", row.ID),
+            "active-value": "1",
+            "inactive-value": "0"
+          }, null);
+        }
+      };
+    },
+    renderField(field) {
+      return {
+        default: ({
+          row
+        }) => {
+          return createVNode("font", {
+            "color": field.color
+          }, [row[field.attriName + "#"] || row[field.attriName]]);
+        }
+      };
+    },
+    /**
+     * 重新加载数据
+     */
+    reloadData() {
+      this.getData(null, (data) => {
+        const existSelection = [];
+        const dataMap = {};
+        data.forEach((dataItem) => {
+          dataMap[dataItem[this.$metaKey]] = dataItem;
+        });
+        this.selection.forEach((item) => {
+          if (dataMap[item[this.$metaKey]]) existSelection.push(dataMap[item[this.$metaKey]]);
+        });
+        if (!this.$_.isEqual(this.selection, existSelection)) {
+          this.$refs.table.clearSelection();
+          existSelection.forEach((item) => {
+            this.$refs.table.toggleRowSelection(item, true);
+          });
+          this.selection = existSelection;
+        }
+      });
+    },
+    renderTable() {
+      const {
+        pageFlag,
+        operateColumnFlag,
+        operateColumnWidth,
+        operateColumnPosition,
+        operateColumnLocked,
+        multiSelectColumnFlag,
+        serialColumnFlag,
+        columnOperates = [],
+        sortable
+      } = this.$configs;
+      return createVNode("div", null, [createVNode(resolveComponent("el-table"), {
+        "class": "list-table",
+        "ref": "table",
+        "rowKey": this.$metaKey,
+        "border": true,
+        "data": this.data,
+        "onSelectionChange": this.selectionChange,
+        "onRowDblclick": (v) => this.viewEntity({}, v),
+        "onSortChange": this.sortChange
+      }, {
+        default: () => [createVNode(resolveComponent("el-table-column"), {
+          "width": "40"
+        }, {
+          default: () => createVNode("i", {
+            "class": "epx-entity-list__drag-icon epx-icon-tuozhuai",
+            "onMouseover": () => {
+              this.dragStart = true;
+            },
+            "onMouseout": () => {
+              this.dragStart = false;
+            }
+          }, null),
+          header: () => createVNode("span", null, null)
+        }), multiSelectColumnFlag && createVNode(resolveComponent("el-table-column"), {
+          "type": "selection",
+          "width": "55",
+          "reserve-selection": true
+        }, null), serialColumnFlag && createVNode(resolveComponent("el-table-column"), {
+          "width": "55",
+          "label": "序号",
+          "type": "index",
+          "index": (index) => (this.currentPage - 1) * this.pageSize + index + 1,
+          "fixed": this.lockedIndex !== -1
+        }, null), operateColumnFlag !== false && columnOperates.length > 0 && operateColumnPosition !== "end" && createVNode(resolveComponent("el-table-column"), {
+          "width": operateColumnWidth,
+          "fixed": operateColumnLocked || this.lockedIndex !== -1 ? "left" : false,
+          "label": "操作"
+        }, this.renderColumnOperates()), this.listFields.map((field, index) => {
+          if (field.attriName === "TARGET_FIELD") {
+            return createVNode(resolveComponent("el-table-column"), mergeProps({
+              "prop": field.attriName
+            }, field, {
+              "min-width": field.width || 120,
+              "sortable": sortable,
+              "resizable": true,
+              "show-overflow-tooltip": true,
+              "label": field.attriLabel,
+              "fixed": index <= this.lockedIndex
+            }), this.renderTargetField(field));
+          } else if (field.attriName === "SOURCE_FIELD") {
+            return createVNode(resolveComponent("el-table-column"), mergeProps({
+              "prop": field.attriName
+            }, field, {
+              "min-width": field.width || 120,
+              "sortable": sortable,
+              "resizable": true,
+              "label": field.attriLabel,
+              "fixed": index <= this.lockedIndex
+            }), this.renderSourceField(field));
+          } else if (field.attriName === "MODE") {
+            return createVNode(resolveComponent("el-table-column"), mergeProps({
+              "prop": field.attriName
+            }, field, {
+              "min-width": field.width || 120,
+              "sortable": sortable,
+              "resizable": true,
+              "label": field.attriLabel,
+              "fixed": index <= this.lockedIndex
+            }), this.renderMode(field));
+          } else if (field.attriName === "SYNC_KEY") {
+            return createVNode(resolveComponent("el-table-column"), mergeProps({
+              "prop": field.attriName
+            }, field, {
+              "min-width": field.width || 120,
+              "sortable": sortable,
+              "resizable": true,
+              "show-overflow-tooltip": true,
+              "label": field.attriLabel,
+              "fixed": index <= this.lockedIndex
+            }), this.renderSyncKey(field));
+          } else if (field.state !== "HIDDEN") {
+            return createVNode(resolveComponent("el-table-column"), mergeProps({
+              "prop": field.attriName
+            }, field, {
+              "min-width": field.width || 120,
+              "sortable": sortable,
+              "resizable": true,
+              "show-overflow-tooltip": true,
+              "label": field.attriLabel,
+              "fixed": index <= this.lockedIndex
+            }), this.renderField(field));
+          }
+        }), operateColumnFlag !== false && columnOperates.length > 0 && operateColumnPosition === "end" && createVNode(resolveComponent("el-table-column"), {
+          "width": operateColumnWidth,
+          "fixed": operateColumnLocked ? "right" : false,
+          "label": "操作"
+        }, this.renderColumnOperates())]
+      }), pageFlag && createVNode("div", {
+        "class": "pagination"
+      }, [withDirectives(createVNode(resolveComponent("el-pagination"), {
+        "currentPage": this.currentPage,
+        "pageSizes": [10, 15, 20, 30, 50, 100, 200],
+        "pageSize": this.pageSize,
+        "layout": "prev, pager, next, jumper, sizes,total",
+        "total": this.total,
+        "onSizeChange": this.sizeChange,
+        "onCurrentChange": this.currentChange
+      }, null), [[resolveDirective("loading"), this.loading]])])]);
+    }
+  },
+  created() {
+    this.entityMatchIds = this.$query.id;
+    const {
+      SOURCE_ENTITY,
+      TARGET_ENTITY
+    } = this.formData;
+    this.sourceEntity = SOURCE_ENTITY || this.$query.SOURCE_ENTITY;
+    this.targetEntity = TARGET_ENTITY || this.$query.TARGET_ENTITY;
+    this.renderComponents.unshift(this.renderSubAdd, this.renderSourceFieldPopover);
+    this.getSourceField();
+    this.getTargetField();
+  },
+  mounted() {
+    window.addEventListener("click", this.closePopup);
+  },
+  beforeUnmount() {
+    window.removeEventListener("click", this.closePopup);
+  }
+};
+export {
+  _sfc_main as default
+};

package/dist/src/views/report/AddFormItem.js

@@ -0,0 +1,60 @@
+import '../../../style.css';
+import AddFormItem from "@epxing/components/src/add-form-item/AddFormItem";
+import { evalWith } from "@epxing/utils/src/eval-with";
+const _sfc_main = {
+  name: "epx-report-add-form-item",
+  extends: AddFormItem,
+  watch: {
+    "data.OBJECT"(v) {
+      if (v) {
+        this.changeObject(v);
+      }
+    }
+  },
+  methods: {
+    changeObject(v) {
+      const index = this.fieldsConfigs.findIndex((item) => {
+        return item.attriName === "SCOPE";
+      });
+      if (index > 0) {
+        const obj = this.fieldsConfigs[index];
+        obj.scopeEntity = v;
+        this.fieldsConfigs.splice(index, 1, obj);
+      }
+    },
+    getFieldsConfigs(pageType = this.componentType) {
+      const { fieldConfigs: formFieldConfigs = {} } = this.formConfigs;
+      const { fields, fieldConfigs = {} } = this.$configs;
+      const { fieldConfigs: routeFieldConfigs = {} } = this.$query;
+      this.$FieldFactory.createFields({
+        defaultFieldConfigs: { ...formFieldConfigs, ...routeFieldConfigs, ...fieldConfigs },
+        meta: this.$meta,
+        metaId: this.$metaId,
+        pageType,
+        fields
+      }).then((data) => {
+        if (this.onAfterFieldsConfigs) this.onAfterFieldsConfigs();
+        data && data.forEach((item) => {
+          if ((!this.formData[item.attriName] || this.componentType === "ADD") && item.value) {
+            const _this = this;
+            const value = item.value.replace(/\$\[(.+)\]/, (match, key) => {
+              try {
+                return evalWith(`_this.${key}`, { _this }) || evalWith(`_this.$query.${key}`, { _this }) || evalWith(`_this.$tab.${key}`, { _this }) || evalWith(`_this.$route.query.${key}`, { _this }) || "";
+              } catch (error) {
+                return item.value;
+              }
+            });
+            this.formData[item.attriName] = value;
+          }
+          if (item.attriName === "SCOPE" && this.formData.OBJECT) {
+            item.scopeEntity = this.formData.OBJECT;
+          }
+        });
+        this.fieldsConfigs = [...data];
+      });
+    }
+  }
+};
+export {
+  _sfc_main as default
+};