@jeecg/online 1.0.1

package/AuthButtonConfig.js

@@ -0,0 +1,140 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { defineComponent, ref, watch, resolveComponent, openBlock, createElementBlock, createVNode, withCtx, createTextVNode } from "vue";
+import { BasicTable, useTable } from "/@/components/Table";
+import { d as authButtonLoadData, e as authButtonEnable, f as authButtonDisable } from "./auth.api.js";
+import { b as authButtonColumns, c as authButtonFixedList } from "./auth.data.js";
+import { _ as _export_sfc } from "./index.js";
+import { c as cloneDeep } from "./cloneDeep.js";
+import "/@/utils/http/axios";
+import "/@/components/jeecg/OnLine/JPopupOnlReport.vue";
+import "/@/hooks/web/useMessage";
+import "vue-router";
+import "./_arrayPush.js";
+import "./isArray.js";
+const _sfc_main = defineComponent({
+  name: "AuthButtonConfig",
+  components: { BasicTable },
+  props: {
+    headId: {
+      type: String,
+      default: "",
+      required: true
+    }
+  },
+  setup(props) {
+    const cgformId = ref("");
+    const pageType = ref(2);
+    const pageControlList = ref(3);
+    const pageControlForm = ref(5);
+    const [registerTable, { reload }] = useTable({
+      api: loadData,
+      rowKey: "code",
+      bordered: true,
+      columns: authButtonColumns,
+      showIndexColumn: false
+    });
+    watch(() => props.headId, (headId) => {
+      cgformId.value = headId.split("?")[0];
+      reload().catch(() => null);
+    }, { immediate: true });
+    function loadData(params) {
+      return __async(this, null, function* () {
+        let result = yield authButtonLoadData(cgformId.value, params);
+        let { authList, buttonList } = result;
+        let dataSource = [];
+        for (let btn of cloneDeep(authButtonFixedList)) {
+          let item = {
+            status: 0,
+            page: pageControlList.value
+          };
+          let auth = authList.find((auth2) => auth2.code == btn.code);
+          Object.assign(btn, item, auth);
+          dataSource.push(btn);
+        }
+        return concatCustomButton(authList, buttonList, dataSource);
+      });
+    }
+    function concatCustomButton(authList, buttonList, dataSource) {
+      for (let btn of buttonList) {
+        let auth = authList.find((auth2) => auth2.code == btn.buttonCode);
+        let item = {
+          code: btn.buttonCode,
+          title: btn.buttonName,
+          status: 0,
+          page: btn.buttonStyle == "form" ? pageControlForm.value : pageControlList.value
+        };
+        dataSource.push(Object.assign(item, auth));
+      }
+      return dataSource;
+    }
+    function onUpdateStatus(flag, record) {
+      return __async(this, null, function* () {
+        flag ? doEnableAuthButton(record) : doDisableAuthButton(record);
+      });
+    }
+    function doEnableAuthButton(record) {
+      return __async(this, null, function* () {
+        let result = yield authButtonEnable({
+          id: record.id,
+          code: record.code,
+          page: record.page,
+          cgformId: cgformId.value,
+          type: pageType.value,
+          control: 5,
+          status: 1
+        });
+        record.id = result.id;
+        record.status = 1;
+      });
+    }
+    function doDisableAuthButton(record) {
+      return __async(this, null, function* () {
+        yield authButtonDisable(record.id);
+        record.status = 0;
+      });
+    }
+    return { registerTable, onUpdateStatus };
+  }
+});
+const _hoisted_1 = { class: "auth-field-config" };
+const _hoisted_2 = /* @__PURE__ */ createTextVNode(" \u53EF\u89C1 ");
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_a_switch = resolveComponent("a-switch");
+  const _component_BasicTable = resolveComponent("BasicTable");
+  return openBlock(), createElementBlock("div", _hoisted_1, [
+    createVNode(_component_BasicTable, { onRegister: _ctx.registerTable }, {
+      switch: withCtx(({ text, record }) => [
+        createVNode(_component_a_switch, {
+          size: "small",
+          checked: record.status === 1,
+          onChange: (flag) => _ctx.onUpdateStatus(flag, record)
+        }, null, 8, ["checked", "onChange"])
+      ]),
+      control: withCtx(() => [
+        _hoisted_2
+      ]),
+      _: 1
+    }, 8, ["onRegister"])
+  ]);
+}
+var AuthButtonConfig = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export { AuthButtonConfig as default };

package/AuthButtonTree.js

@@ -0,0 +1,183 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { defineComponent, ref, computed, watch, resolveComponent, openBlock, createElementBlock, createBlock, Fragment, createElementVNode, createVNode, withCtx, createTextVNode } from "vue";
+import { useMessage } from "/@/hooks/web/useMessage";
+import { c as authButtonFixedList } from "./auth.data.js";
+import { m as authButtonLoadTree, l as loadRoleAuthChecked, n as saveAuthButton } from "./auth.api.js";
+import { _ as _export_sfc } from "./index.js";
+import "/@/utils/http/axios";
+import "/@/components/jeecg/OnLine/JPopupOnlReport.vue";
+import "vue-router";
+var AuthButtonTree_vue_vue_type_style_index_0_scoped_true_lang = "";
+const _sfc_main = defineComponent({
+  name: "AuthButtonTree",
+  props: {
+    cgformId: { type: String, required: true }
+  },
+  setup(props) {
+    const { createMessage: $message } = useMessage();
+    const roleId = ref("");
+    const authType = ref(2);
+    const autoExpandParent = ref(true);
+    const expandedKeys = ref([]);
+    const checkedKeys = ref([]);
+    const treeData = ref([]);
+    const authMode = ref("");
+    const disabled = computed(() => !roleId.value);
+    watch(() => props.cgformId, loadTree, { immediate: true });
+    function loadTree() {
+      return __async(this, null, function* () {
+        if (!props.cgformId)
+          return;
+        let result = yield authButtonLoadTree(props.cgformId, authType.value);
+        result.forEach((item) => {
+          for (const btn of authButtonFixedList) {
+            if (item.code == btn.code) {
+              item["title"] = btn.title;
+              break;
+            }
+          }
+        });
+        let trees = [];
+        for (let item of result) {
+          let title = getTreeNodeTitle(item);
+          trees.push({ key: item.id, title });
+        }
+        treeData.value = trees;
+      });
+    }
+    function onRefresh() {
+      loadTree();
+      loadChecked(roleId.value, authMode.value);
+    }
+    function loadChecked($roleId, $authMode) {
+      return __async(this, null, function* () {
+        roleId.value = $roleId;
+        authMode.value = $authMode;
+        checkedKeys.value = [];
+        let result = yield loadRoleAuthChecked({
+          roleId: $roleId,
+          cgformId: props.cgformId,
+          type: authType.value,
+          authMode: $authMode
+        });
+        checkedKeys.value = result.map((item) => item.authId);
+      });
+    }
+    function clearChecked() {
+      roleId.value = "";
+    }
+    function onSave() {
+      return __async(this, null, function* () {
+        yield saveAuthButton(roleId.value, props.cgformId, {
+          authId: JSON.stringify(checkedKeys.value),
+          authMode: authMode.value
+        });
+        $message.success("\u4FDD\u5B58\u6210\u529F");
+      });
+    }
+    function getTreeNodeTitle(item) {
+      let str = item.title + "-";
+      if (item.page == 3) {
+        str += "\u5217\u8868\u53EF\u89C1";
+      } else if (item.page == 5) {
+        str += "\u8868\u5355\u53EF\u89C1";
+      }
+      return str;
+    }
+    function onExpand($expandedKeys) {
+      expandedKeys.value = $expandedKeys;
+      autoExpandParent.value = false;
+    }
+    function clear() {
+      roleId.value = "";
+      checkedKeys.value = [];
+    }
+    return {
+      loadChecked,
+      clear,
+      expandedKeys,
+      autoExpandParent,
+      checkedKeys,
+      treeData,
+      disabled,
+      onSave,
+      onExpand,
+      onRefresh,
+      clearChecked
+    };
+  }
+});
+const _hoisted_1 = { class: "onl-auth-tree-btns" };
+const _hoisted_2 = /* @__PURE__ */ createTextVNode("\u5237\u65B0");
+const _hoisted_3 = /* @__PURE__ */ createTextVNode("\u4FDD\u5B58");
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_a_empty = resolveComponent("a-empty");
+  const _component_a_button = resolveComponent("a-button");
+  const _component_a_tree = resolveComponent("a-tree");
+  return openBlock(), createElementBlock("div", null, [
+    _ctx.disabled ? (openBlock(), createBlock(_component_a_empty, {
+      key: 0,
+      description: "\u8BF7\u5148\u9009\u4E2D\u5DE6\u4FA7\u89D2\u8272/\u90E8\u95E8/\u7528\u6237"
+    })) : _ctx.treeData.length === 0 ? (openBlock(), createBlock(_component_a_empty, {
+      key: 1,
+      description: "\u65E0\u6743\u9650\u4FE1\u606F"
+    })) : (openBlock(), createElementBlock(Fragment, { key: 2 }, [
+      createElementVNode("div", _hoisted_1, [
+        createVNode(_component_a_button, {
+          onClick: _ctx.onRefresh,
+          size: "small",
+          type: "primary",
+          preIcon: "ant-design:redo",
+          ghost: ""
+        }, {
+          default: withCtx(() => [
+            _hoisted_2
+          ]),
+          _: 1
+        }, 8, ["onClick"]),
+        createVNode(_component_a_button, {
+          onClick: _ctx.onSave,
+          size: "small",
+          type: "primary",
+          preIcon: "ant-design:save",
+          ghost: ""
+        }, {
+          default: withCtx(() => [
+            _hoisted_3
+          ]),
+          _: 1
+        }, 8, ["onClick"])
+      ]),
+      createVNode(_component_a_tree, {
+        checkable: "",
+        checkedKeys: _ctx.checkedKeys,
+        "onUpdate:checkedKeys": _cache[0] || (_cache[0] = ($event) => _ctx.checkedKeys = $event),
+        expandedKeys: _ctx.expandedKeys,
+        autoExpandParent: _ctx.autoExpandParent,
+        treeData: _ctx.treeData,
+        onExpand: _ctx.onExpand
+      }, null, 8, ["checkedKeys", "expandedKeys", "autoExpandParent", "treeData", "onExpand"])
+    ], 64))
+  ]);
+}
+var AuthButtonTree = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__scopeId", "data-v-3285957e"]]);
+export { AuthButtonTree as default };

package/AuthDataConfig.js

@@ -0,0 +1,243 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { defineComponent, ref, watch, reactive, resolveComponent, openBlock, createElementBlock, createVNode, withCtx, normalizeProps, guardReactiveProps, createTextVNode, nextTick } from "vue";
+import { BasicTable, TableAction, useTable } from "/@/components/Table";
+import { BasicModal, useModal } from "/@/components/Modal";
+import { BasicForm, useForm } from "/@/components/Form";
+import { g as authDataLoadData, h as authDataSaveOrUpdate, i as authDataUpdateStatus, j as authDataDelete } from "./auth.api.js";
+import { d as authDataColumns, u as useAuthDataFormSchemas, U as USE_SQL_RULES } from "./auth.data.js";
+import { _ as _export_sfc } from "./index.js";
+import "/@/utils/http/axios";
+import "/@/components/jeecg/OnLine/JPopupOnlReport.vue";
+import "/@/hooks/web/useMessage";
+import "vue-router";
+const _sfc_main = defineComponent({
+  name: "AuthDataConfig",
+  components: { BasicTable, TableAction, BasicModal, BasicForm },
+  props: {
+    cgformId: { type: String, required: true },
+    authFields: { type: Array, required: true }
+  },
+  setup(props) {
+    const loading = ref(false);
+    const [registerTable, { reload, setLoading }] = useTable({
+      api: (params) => authDataLoadData(props.cgformId, params),
+      rowKey: "id",
+      bordered: true,
+      columns: authDataColumns,
+      showIndexColumn: false,
+      actionColumn: {
+        width: 120,
+        title: "\u64CD\u4F5C",
+        fixed: false,
+        dataIndex: "action",
+        slots: { customRender: "action" }
+      }
+    });
+    watch(loading, (l) => setLoading(l));
+    const [registerModal, { openModal, closeModal }] = useModal();
+    const formModalProps = reactive({
+      title: "",
+      width: 800,
+      confirmLoading: false,
+      onOk: onSubmit,
+      onCancel: closeModal,
+      onRegister: registerModal
+    });
+    let isUpdate = false;
+    let formRecord = {};
+    const { formSchemas } = useAuthDataFormSchemas(props, {
+      onRuleOperatorChange
+    });
+    const [registerForm, { validate, resetFields, setFieldsValue }] = useForm({
+      schemas: formSchemas,
+      showActionButtonGroup: false,
+      labelAlign: "right"
+    });
+    watch(() => props.cgformId, () => {
+      reload().catch(() => null);
+    }, { immediate: true });
+    function openFormModal(data) {
+      return __async(this, null, function* () {
+        var _a;
+        isUpdate = (_a = data.isUpdate) != null ? _a : false;
+        formModalProps.title = data.title;
+        openModal();
+        yield nextTick();
+        yield resetFields();
+        formRecord = Object.assign({}, data.record);
+        yield setFieldsValue(formRecord);
+      });
+    }
+    function onAdd() {
+      openFormModal({ title: "\u65B0\u589E" });
+    }
+    function onEdit(record) {
+      openFormModal({ title: "\u7F16\u8F91", record, isUpdate: true });
+    }
+    function onDelete(id) {
+      loading.value = true;
+      authDataDelete(id).then(reload).finally(() => loading.value = false);
+    }
+    function onSubmit() {
+      return __async(this, null, function* () {
+        try {
+          formModalProps.confirmLoading = true;
+          let formData = yield validate();
+          formData = Object.assign({}, formRecord, formData);
+          if (formData.ruleOperator == USE_SQL_RULES) {
+            formData.ruleColumn = "";
+          }
+          formData.cgformId = props.cgformId;
+          yield authDataSaveOrUpdate(formData, isUpdate);
+          reload();
+          closeModal();
+        } finally {
+          formModalProps.confirmLoading = false;
+        }
+      });
+    }
+    function onUpdateStatus(record) {
+      loading.value = true;
+      let status = Math.abs(record.status - 1);
+      authDataUpdateStatus(__spreadProps(__spreadValues({}, record), { status })).then(() => {
+        record.status = status;
+      }).finally(() => {
+        loading.value = false;
+      });
+    }
+    function onRuleOperatorChange(val) {
+      if (val == USE_SQL_RULES) {
+        setFieldsValue({
+          ruleColumn: ""
+        });
+      }
+    }
+    function getTableAction(record) {
+      return [
+        {
+          label: "\u7F16\u8F91",
+          onClick: () => onEdit(record)
+        }
+      ];
+    }
+    function getDropDownAction(record) {
+      return [
+        {
+          label: "\u5220\u9664",
+          popConfirm: {
+            title: "\u786E\u5B9A\u5220\u9664\u5417\uFF1F",
+            placement: "left",
+            confirm: () => onDelete(record.id)
+          }
+        }
+      ];
+    }
+    return {
+      loading,
+      formModalProps,
+      onAdd,
+      onUpdateStatus,
+      getTableAction,
+      getDropDownAction,
+      registerTable,
+      registerModal,
+      registerForm
+    };
+  }
+});
+const _hoisted_1 = /* @__PURE__ */ createTextVNode("\u65B0\u589E");
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_a_button = resolveComponent("a-button");
+  const _component_a_switch = resolveComponent("a-switch");
+  const _component_TableAction = resolveComponent("TableAction");
+  const _component_BasicTable = resolveComponent("BasicTable");
+  const _component_BasicForm = resolveComponent("BasicForm");
+  const _component_a_spin = resolveComponent("a-spin");
+  const _component_BasicModal = resolveComponent("BasicModal");
+  return openBlock(), createElementBlock("div", null, [
+    createVNode(_component_BasicTable, {
+      onRegister: _ctx.registerTable,
+      loading: _ctx.loading
+    }, {
+      tableTitle: withCtx(() => [
+        createVNode(_component_a_button, {
+          onClick: _ctx.onAdd,
+          type: "primary",
+          preIcon: "ant-design:plus"
+        }, {
+          default: withCtx(() => [
+            _hoisted_1
+          ]),
+          _: 1
+        }, 8, ["onClick"])
+      ]),
+      switch: withCtx(({ text, record }) => [
+        createVNode(_component_a_switch, {
+          size: "small",
+          checked: record.status === 1,
+          onClick: () => _ctx.onUpdateStatus(record)
+        }, null, 8, ["checked", "onClick"])
+      ]),
+      action: withCtx(({ record }) => [
+        createVNode(_component_TableAction, {
+          actions: _ctx.getTableAction(record),
+          dropDownActions: _ctx.getDropDownAction(record)
+        }, null, 8, ["actions", "dropDownActions"])
+      ]),
+      _: 1
+    }, 8, ["onRegister", "loading"]),
+    createVNode(_component_BasicModal, normalizeProps(guardReactiveProps(_ctx.formModalProps)), {
+      default: withCtx(() => [
+        createVNode(_component_a_spin, {
+          spinning: _ctx.formModalProps.confirmLoading
+        }, {
+          default: withCtx(() => [
+            createVNode(_component_BasicForm, { onRegister: _ctx.registerForm }, null, 8, ["onRegister"])
+          ]),
+          _: 1
+        }, 8, ["spinning"])
+      ]),
+      _: 1
+    }, 16)
+  ]);
+}
+var AuthDataConfig = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export { AuthDataConfig as default };