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

package/dist/src/components/authorization/EntityConstraintFormItem.js

@@ -0,0 +1,284 @@
+import '../../../style.css';
+import component from "@epxing/core/src/mixins/component";
+import { evalWith } from "@epxing/utils/src/eval-with";
+import { resolveComponent, openBlock, createElementBlock, normalizeStyle, createBlock, createCommentVNode, createElementVNode, createVNode, withCtx, createTextVNode } from "vue";
+/* empty css                             */
+import _export_sfc from "../../../_virtual/_plugin-vue_export-helper.js";
+const _sfc_main = {
+  name: "epx-entity-constraint-form-item",
+  mixins: [component],
+  componentName: "addFormItem",
+  fieldConfigs: {},
+  inheritAttrs: false,
+  props: {
+    formData: {
+      type: Object,
+      default() {
+        return {};
+      }
+    },
+    formConfigs: {
+      type: Object,
+      default() {
+        return {};
+      }
+    },
+    fieldRelations: {
+      type: Array,
+      default() {
+        return [];
+      }
+    },
+    pageType: String,
+    form: Object
+  },
+  data() {
+    return {
+      fieldsConfigs: [],
+      scopeParamsObj: {
+        scopeParams: {},
+        scopeText: ""
+      },
+      scopeValue: "",
+      scopeParams: [],
+      entityMetaId: "",
+      filterDrawer: false,
+      isScope: false
+    };
+  },
+  computed: {
+    getPageType() {
+      const { pageType: defaultFormPageType } = this.formConfigs;
+      const { pageType: defaultPageType = defaultFormPageType } = this.$configs;
+      const { pageType = defaultPageType } = this.upPage ? this.upPage.$query : {};
+      return this.pageType || pageType;
+    },
+    column() {
+      const { column = this.formConfigs.column } = this.$configs;
+      return column;
+    },
+    getChineseValue() {
+      return () => {
+        let scopeText = "";
+        if (this.scopeValue) {
+          const scope = JSON.parse(this.scopeValue);
+          if (scope.scopeText) {
+            scopeText = scope.scopeText;
+          }
+          return scopeText;
+        }
+      };
+    }
+  },
+  watch: {
+    pageType: {
+      handler(v) {
+        this.getFieldsConfigs();
+      }
+    },
+    scopeParams: {
+      deep: true,
+      handler(v) {
+        this.setValue();
+      }
+    }
+  },
+  methods: {
+    setValue() {
+      this.scopeParamsObj = {
+        scopeParams: {},
+        scopeText: ""
+      };
+      this.scopeParamsObj.scopeParams = this.scopeParams;
+      this.scopeParams.forEach((item) => {
+        this.scopeParamsObj.scopeText += item.text;
+      });
+      this.scopeValue = JSON.stringify(this.scopeParamsObj);
+    },
+    changeHandler(v) {
+      if (v.ENTITY) {
+        this.isScope = true;
+        this.entityMetaId = v.ENTITY;
+        this.scopeValue = "";
+        this.scopeParams = [];
+      } else {
+        this.entityMetaId = "";
+        this.isScope = false;
+      }
+    },
+    init() {
+      this.getFieldsConfigs();
+    },
+    getFieldsConfigs() {
+      const { fields, fieldConfigs = {} } = this.$configs;
+      const { fieldConfigs: routeFieldConfigs = {} } = this.$query;
+      this.$FieldFactory.createFields({
+        defaultFieldConfigs: { ...routeFieldConfigs, ...fieldConfigs },
+        meta: this.$meta,
+        metaId: this.$metaId,
+        pageType: this.pageType || this.getPageType,
+        fields
+      }).then((data) => {
+        this.fieldsConfigs = [...data];
+        data && data.forEach((item) => {
+          if ((!this.formData[item.attriName] || item.state === "HIDDEN") && 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;
+          }
+        });
+      });
+    },
+    cancel(finish) {
+      if (this.form) {
+        this.form.cancelEdit(finish);
+      }
+    },
+    save() {
+      const params = {};
+      let submitFlag = true;
+      const { submitParams: querySumitParams = {} } = this.$query;
+      const form = this.$refs.form;
+      if (this.formData[this.$metaKey]) {
+        params[`bean.${this.$metaKey}`] = this.formData[this.$metaKey];
+      }
+      if (component && form) {
+        const { hiddenFields = [] } = component.configs || {};
+        hiddenFields.forEach((field) => {
+          if (field.attriName && field.value) {
+            params[`bean.${field.attriName}`] = field.value;
+          }
+        });
+        form.validate((valid, err) => {
+          if (!valid) {
+            for (const key in err) {
+              const errMessgae = err[key][0];
+              this.$message.error(errMessgae.message);
+              submitFlag = false;
+              return;
+            }
+          }
+        });
+        for (const field in form.model.data) {
+          const formValue = form.model.data[field];
+          const fieldsConfigs = component.fieldsConfigs || [];
+          if (!field.includes("#")) {
+            let submitValue = formValue;
+            const fieldConfigs = fieldsConfigs.find((item) => item.attriName === field) || {};
+            if (Array.isArray(formValue)) {
+              submitValue = formValue[formValue.length - 1];
+            }
+            params[fieldConfigs.name || `bean.${field}`] = submitValue || "";
+          }
+        }
+      }
+      params["bean.RESTRICTIONS"] = this.scopeValue;
+      if (this.pageType === "EDIT") params.action = "update";
+      if (!submitFlag) return;
+      this.$http.save({
+        entityId: this.$metaId,
+        ...querySumitParams,
+        ...params
+      }).then(() => {
+        this.$message.success("保存成功");
+        this.cancel(true);
+        this.backPage();
+      }).catch((err) => {
+        this.$message.error(err.message || "保存失败");
+      });
+    }
+  },
+  created() {
+    if (this.formData.ENTITY) {
+      this.entityMetaId = this.formData.ENTITY;
+      this.isScope = true;
+      this.scopeValue = this.formData.RESTRICTIONS;
+      const value = JSON.parse(this.scopeValue);
+      if (value.scopeParams) {
+        this.scopeParams = value.scopeParams;
+      }
+    }
+    this.init();
+  }
+};
+const _hoisted_1 = {
+  key: 1,
+  class: "scope-container"
+};
+const _hoisted_2 = { class: "button-group" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_epx_table_form = resolveComponent("epx-table-form");
+  const _component_el_input = resolveComponent("el-input");
+  const _component_epx_scope_drawer = resolveComponent("epx-scope-drawer");
+  const _component_el_button = resolveComponent("el-button");
+  return openBlock(), createElementBlock("div", {
+    style: normalizeStyle(_ctx.$component.style)
+  }, [
+    $data.fieldsConfigs.length > 0 ? (openBlock(), createBlock(_component_epx_table_form, {
+      key: 0,
+      class: "form-content",
+      ref: "form",
+      metaId: _ctx.$metaId,
+      fieldsConfigs: $data.fieldsConfigs,
+      "field-relations": $props.fieldRelations,
+      value: $props.formData,
+      onInput: _cache[0] || (_cache[0] = (v) => {
+        if (v && v !== $props.formData) Object.assign($props.formData, v);
+      }),
+      column: $options.column,
+      onChange: $options.changeHandler
+    }, null, 8, ["metaId", "fieldsConfigs", "field-relations", "value", "column", "onChange"])) : createCommentVNode("", true),
+    $data.isScope ? (openBlock(), createElementBlock("div", _hoisted_1, [
+      _cache[4] || (_cache[4] = createElementVNode("div", { class: "scope-lable" }, "限制条件：", -1)),
+      createElementVNode("div", {
+        class: "scope-input",
+        onClick: _cache[1] || (_cache[1] = ($event) => $data.filterDrawer = true)
+      }, [
+        createVNode(_component_el_input, {
+          "model-value": $options.getChineseValue(),
+          type: "textarea",
+          readonly: "",
+          rows: 5,
+          placeholder: "请输入限制条件"
+        }, null, 8, ["model-value"])
+      ])
+    ])) : createCommentVNode("", true),
+    createVNode(_component_epx_scope_drawer, {
+      visible: $data.filterDrawer,
+      "onUpdate:visible": _cache[2] || (_cache[2] = ($event) => $data.filterDrawer = $event),
+      ref: "filterDrawer",
+      modeType: true,
+      metaId: $data.entityMetaId,
+      modelValue: $data.scopeParams,
+      "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => $data.scopeParams = $event),
+      params: $data.scopeParams
+    }, null, 8, ["visible", "metaId", "modelValue", "params"]),
+    createElementVNode("div", _hoisted_2, [
+      createVNode(_component_el_button, {
+        type: "primary",
+        onClick: $options.save
+      }, {
+        default: withCtx(() => [..._cache[5] || (_cache[5] = [
+          createTextVNode("保存", -1)
+        ])]),
+        _: 1
+      }, 8, ["onClick"]),
+      createVNode(_component_el_button, { onClick: _ctx.backPage }, {
+        default: withCtx(() => [..._cache[6] || (_cache[6] = [
+          createTextVNode("返回", -1)
+        ])]),
+        _: 1
+      }, 8, ["onClick"])
+    ])
+  ], 4);
+}
+const EntityConstraintFormItem = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__scopeId", "data-v-f05d7fb8"]]);
+export {
+  EntityConstraintFormItem as default
+};

package/dist/src/components/authorization/OtherShareApiList.js

@@ -0,0 +1,247 @@
+import '../../../style.css';
+import EntityList from "@epxing/components/src/entity-list";
+import { resolveComponent, resolveDirective, openBlock, createElementBlock, createElementVNode, createTextVNode, createVNode, toDisplayString, withCtx, withDirectives } from "vue";
+import _export_sfc from "../../../_virtual/_plugin-vue_export-helper.js";
+const _sfc_main = {
+  name: "epx-other-share-api-list",
+  extends: EntityList,
+  data() {
+    return {
+      tableData: [],
+      searchText: ""
+    };
+  },
+  methods: {
+    addAuthorization(row) {
+      if (row.apiId) {
+        this.$createPage({
+          flag: "v_entity_api_authorization_nosystem",
+          metaId: "FM_ENTITY_RIGHT",
+          id: row.apiId,
+          apiSystemId: row.apiSystemId,
+          pageType: "DETAIL",
+          entityId: row.entityId,
+          otherSystem: true
+        });
+      } else {
+        this.$message.error("该对象下没有接口");
+      }
+    },
+    // 合并行
+    objectSpanMethod({ row, column, rowIndex, columnIndex }) {
+      if (columnIndex === 2 || columnIndex === 3) {
+        if (row.merge && row.apis.length > 0) {
+          return {
+            rowspan: row.apis.length,
+            colspan: 1
+          };
+        } else if (row.merge && row.apis.length === 0) {
+          return {
+            rowspan: 1,
+            colspan: 1
+          };
+        } else {
+          return {
+            rowspan: 0,
+            colspan: 0
+          };
+        }
+      }
+    },
+    // tableRowClassName ({ row, rowIndex }) {
+    //   if (rowIndex % 2 === 0) {
+    //     return 'even-row'
+    //   } else {
+    //     return ''
+    //   }
+    // },
+    getData(current, cb) {
+      let { queryParams = {}, pageFlag, orderFields, order_field: orderField = [], order_mode: orderMode = [], limit } = this.$configs;
+      const params = {
+        action: "getExternalApiShares",
+        entityId: this.$metaId,
+        systemId: this.SYSTEM,
+        searchText: this.searchText
+      };
+      const functionField = this.listFields.filter((item) => {
+        return item.function;
+      });
+      let functionList = [];
+      if (functionField.length > 0) {
+        functionList = functionField.map((item) => ({ dataIndex: item.attriName, function: item.function }));
+        params.fieldFunctions = JSON.stringify(functionList);
+      }
+      if (pageFlag) {
+        params.page = current || this.currentPage;
+        params.limit = this.pageSize;
+      }
+      if (limit) {
+        params.limit = limit;
+      }
+      if (this.scopeParams) {
+        params.scopeParams = JSON.stringify(this.scopeParams);
+      }
+      if (orderFields && orderFields.length > 0) {
+        orderField = orderFields.map((item) => item.attriName || item);
+        orderMode = orderFields.map((item) => item.sort || "asc");
+      }
+      if (this.loading) return;
+      this.loading = true;
+      this.$http.list({
+        ...params,
+        ...this.$formatParams(queryParams),
+        ...this.queryParams,
+        ...this.sortParams,
+        order_field: orderField.join(","),
+        order_mode: orderMode.join(",")
+      }).then((data) => {
+        this.initData = true;
+        this.loading = false;
+        if (current) this.currentPage = current;
+        if (data.entitys) {
+          this.data = [...data.entitys];
+        } else {
+          this.data = [];
+        }
+        this.tableData = [];
+        this.data.forEach((element) => {
+          if (element.apis.length > 0) {
+            element.apis.forEach((item, index) => {
+              this.tableData.push({ ...item, ...element, merge: index === 0 });
+            });
+          } else {
+            this.tableData.push({ ...element, merge: true });
+          }
+        });
+        this.total = data.total || data.entitys.length || 0;
+        if (cb) cb(this.data);
+        this.$dispatchPage("listData", [{ total: this.total, entitys: this.data }]);
+        this.$emit("listData", { total: this.total, entitys: this.data });
+        if (this.afterData) this.afterData(this.data);
+      }).catch(() => {
+        this.loading = false;
+      });
+    }
+  }
+};
+const _hoisted_1 = { class: "list-operates" };
+const _hoisted_2 = { style: { "padding": "6px 20px 16px" } };
+const _hoisted_3 = { class: "pagination" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_el_input = resolveComponent("el-input");
+  const _component_el_table_column = resolveComponent("el-table-column");
+  const _component_el_button = resolveComponent("el-button");
+  const _component_el_table = resolveComponent("el-table");
+  const _component_el_pagination = resolveComponent("el-pagination");
+  const _directive_loading = resolveDirective("loading");
+  return openBlock(), createElementBlock("div", null, [
+    createElementVNode("div", _hoisted_1, [
+      createElementVNode("div", _hoisted_2, [
+        _cache[2] || (_cache[2] = createTextVNode(" 关键词：", -1)),
+        createVNode(_component_el_input, {
+          onChange: _cache[0] || (_cache[0] = ($event) => $options.getData(null)),
+          style: { "width": "200px" },
+          clearable: "",
+          modelValue: $data.searchText,
+          "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => $data.searchText = $event),
+          placeholder: "请输入对象编号、对象名称"
+        }, null, 8, ["modelValue"])
+      ]),
+      createElementVNode("span", null, "共" + toDisplayString(_ctx.total) + "条数据", 1)
+    ]),
+    createVNode(_component_el_table, {
+      class: "list-table no-border",
+      data: $data.tableData,
+      rowKey: _ctx.$metaKey,
+      "span-method": $options.objectSpanMethod,
+      border: ""
+    }, {
+      default: withCtx(() => [
+        createVNode(_component_el_table_column, {
+          type: "selection",
+          width: "55",
+          "reserve-selection": true,
+          fixed: true
+        }),
+        createVNode(_component_el_table_column, {
+          label: "序号",
+          width: "60"
+        }, {
+          default: withCtx((scope) => [
+            createTextVNode(toDisplayString(scope.$index + 1), 1)
+          ]),
+          _: 1
+        }),
+        createVNode(_component_el_table_column, { label: "对象名称" }, {
+          default: withCtx((scope) => [
+            createTextVNode(toDisplayString(scope.row.entityName), 1)
+          ]),
+          _: 1
+        }),
+        createVNode(_component_el_table_column, { label: "对象编号" }, {
+          default: withCtx((scope) => [
+            createTextVNode(toDisplayString(scope.row.entityCode), 1)
+          ]),
+          _: 1
+        }),
+        createVNode(_component_el_table_column, { label: "接口名称" }, {
+          default: withCtx((scope) => [
+            createTextVNode(toDisplayString(scope.row.apiLabel), 1)
+          ]),
+          _: 1
+        }),
+        createVNode(_component_el_table_column, { label: "接口命令" }, {
+          default: withCtx((scope) => [
+            createTextVNode(toDisplayString(scope.row.apiName), 1)
+          ]),
+          _: 1
+        }),
+        createVNode(_component_el_table_column, { label: "开放范围" }, {
+          default: withCtx((scope) => [
+            createTextVNode(toDisplayString(scope.row["apiOpenScope#"]), 1)
+          ]),
+          _: 1
+        }),
+        createVNode(_component_el_table_column, { label: "授予角色" }, {
+          default: withCtx((scope) => [
+            createTextVNode(toDisplayString(scope.row.roles), 1)
+          ]),
+          _: 1
+        }),
+        createVNode(_component_el_table_column, { label: "操作" }, {
+          default: withCtx((scope) => [
+            createVNode(_component_el_button, {
+              type: "primary",
+              link: "",
+              onClick: ($event) => $options.addAuthorization(scope.row)
+            }, {
+              default: withCtx(() => [..._cache[3] || (_cache[3] = [
+                createTextVNode("授权", -1)
+              ])]),
+              _: 1
+            }, 8, ["onClick"])
+          ]),
+          _: 1
+        })
+      ]),
+      _: 1
+    }, 8, ["data", "rowKey", "span-method"]),
+    createElementVNode("div", _hoisted_3, [
+      withDirectives(createVNode(_component_el_pagination, {
+        currentPage: _ctx.currentPage,
+        pageSizes: [5, 10, 15, 20, 30, 50, 100, 200],
+        pageSize: _ctx.pageSize,
+        layout: "prev, pager, next, jumper, sizes,total",
+        total: _ctx.total,
+        onSizeChange: _ctx.sizeChange,
+        onCurrentChange: _ctx.currentChange
+      }, null, 8, ["currentPage", "pageSize", "total", "onSizeChange", "onCurrentChange"]), [
+        [_directive_loading, _ctx.loading]
+      ])
+    ])
+  ]);
+}
+const OtherShareApiList = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  OtherShareApiList as default
+};

package/dist/src/components/authorization/PermissCommonRoleTabs.js

@@ -0,0 +1,114 @@
+import '../../../style.css';
+import component from "@epxing/core/src/mixins/component";
+import { resolveComponent, openBlock, createBlock, normalizeStyle, withCtx, createElementBlock, Fragment, renderList, createVNode } from "vue";
+/* empty css                          */
+import _export_sfc from "../../../_virtual/_plugin-vue_export-helper.js";
+const _sfc_main = {
+  name: "epx-permiss-common-role-tabs",
+  mixins: [component],
+  items: [],
+  style: {
+    "margin-bottom": "0"
+  },
+  data() {
+    return {
+      activeName: "",
+      counts: {},
+      components: [],
+      roleId: ""
+    };
+  },
+  methods: {
+    getRoleSystem() {
+      this.$http.list({
+        entityId: "FM_SYSTEM"
+      }).then((data) => {
+        const components = data.entitys.map((item) => {
+          return {
+            systemId: item.ID,
+            systemName: item.NAME
+          };
+        });
+        components.forEach((tab, index) => {
+          this.getCount(tab, index);
+        });
+        this.activeName = components[0].systemId;
+      });
+    },
+    getCount(tab, index) {
+      const params = {
+        entityId: "FM_ENTITY_RIGHT_ROLE"
+      };
+      if (tab.systemId === this.SYSTEM) {
+        params.action = "getCount";
+        params["scope.ROLE"] = this.roleId;
+        params["scope.IS_LOCAL"] = "1";
+      } else {
+        params.action = "getDesignatedSystemCount";
+        params.systemId = tab.systemId;
+        params["scope.ROLE"] = this.roleId;
+      }
+      this.$http.getCount(params).then((data) => {
+        this.components.splice(index, 1, { ...tab, count: data.total || 0 });
+      });
+    }
+  },
+  created() {
+    this.roleId = this.$query.id;
+    this.getRoleSystem();
+  },
+  mounted() {
+    this.$bus.on("refreshCount", (data) => {
+      const index = data.index;
+      const total = data.total;
+      const tab = this.components[index];
+      this.components.splice(index, 1, { ...tab, count: total || 0 });
+    });
+  }
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_epx_page = resolveComponent("epx-page");
+  const _component_el_tab_pane = resolveComponent("el-tab-pane");
+  const _component_el_tabs = resolveComponent("el-tabs");
+  return openBlock(), createBlock(_component_el_tabs, {
+    style: normalizeStyle(_ctx.$component.style),
+    class: "tabs",
+    modelValue: $data.activeName,
+    "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => $data.activeName = $event)
+  }, {
+    default: withCtx(() => [
+      (openBlock(true), createElementBlock(Fragment, null, renderList($data.components, (component2, index) => {
+        return openBlock(), createBlock(_component_el_tab_pane, {
+          key: component2.systemId,
+          label: component2.systemName + "(" + component2.count + ")",
+          name: component2.systemId,
+          lazy: ""
+        }, {
+          default: withCtx(() => [
+            createVNode(_component_epx_page, {
+              ref_for: true,
+              ref: "page",
+              inline: true,
+              component: "permiss-role-authorization",
+              metaId: "FM_ENTITY_RIGHT_ROLE",
+              "current-query": {
+                systemId: component2.systemId,
+                systemName: component2.systemName,
+                systemType: "others",
+                roleId: $data.roleId,
+                componentIndex: index,
+                pageType: _ctx.$query.pageType
+              }
+            }, null, 8, ["current-query"])
+          ]),
+          _: 2
+        }, 1032, ["label", "name"]);
+      }), 128))
+    ]),
+    _: 1
+  }, 8, ["style", "modelValue"]);
+}
+const PermissCommonRoleTabs = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__scopeId", "data-v-66f4fb2e"]]);
+export {
+  PermissCommonRoleTabs as default
+};