super-page-runtime 2.0.40 → 2.0.43

package/dist/lib/components/runtime/views/assemblys/data/table/sub-table-runtime.vue.js

@@ -0,0 +1,455 @@
+"use strict";
+const Vue = require("vue");
+const eventUtil = require("../../../../utils/events/event-util.js");
+const pageHelperUtil = require("../../../../utils/page-helper-util.js");
+const pageInitUtil = require("../../../../utils/page-init-util.js");
+const eventBus = require("../../../../utils/eventBus.js");
+const tableUtils = require("../../../../utils/table-utils.js");
+const commonUtil = require("../../../../utils/common-util.js");
+const standardEvent = require("../../../../utils/events/standard-event.js");
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "sub-table-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const pageContext = props.pageContext;
+    const configure = props.configure;
+    const listCode = commonUtil.getListCode(pageContext.code, pageContext.version, configure.uuid);
+    const dataModel = pageContext.entity.data;
+    const prop = listCode;
+    const additionalParamMap = standardEvent.getAdditionalParamMap(pageContext);
+    const tableEvents = configure.runtime && configure.runtime.events ? configure.runtime.events : [];
+    const selections = Vue.ref([]);
+    const superGridItems = pageContext.superGridItems;
+    const superGridSetting = superGridItems ? superGridItems[configure.uuid] : null;
+    console.log("superGridSetting===", superGridItems, superGridSetting);
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    const runtimeStyle = runtimeInfo.style;
+    const runtimeClass = runtimeInfo.class;
+    const entity = props.pageContext.entity ? props.pageContext.entity : {};
+    let dynamicFields = pageInitUtil.getModelFields(props.pageContext, props.configure, prop);
+    const listViewShowFlag = Vue.ref(false);
+    const baseURL = window["$vueApp"].config.globalProperties.baseURL;
+    const listViewOptions = Vue.ref({
+      subTableData: null,
+      extraParam: {},
+      operations: {},
+      hiddenColumns: [],
+      pageCode: pageContext.code,
+      pageVersion: pageContext.version,
+      pageContext,
+      configureObj: configure,
+      showPageArea: false,
+      showOverflowTooltip: !!(configure.props && configure.props.otherSettings && (configure.props.otherSettings.isBreakLine === void 0 || configure.props.otherSettings.isBreakLine === false))
+      // 单元格内容是否换行显示
+    });
+    if (runtimeStyle) {
+      listViewOptions.value["tableStyle"] = runtimeStyle;
+    }
+    if (runtimeClass) {
+      listViewOptions.value["tableClass"] = runtimeClass;
+    }
+    if (configure.props && configure.props.base && configure.props.base.subPaging === true) {
+      listViewOptions.value.showPageArea = true;
+    } else {
+      listViewOptions.value.showPageArea = false;
+    }
+    const gridRef = Vue.ref(null);
+    function currencyListViewSetting(canRrefreshSubtableData) {
+      if (canRrefreshSubtableData === void 0) {
+        canRrefreshSubtableData = judgeInitializationSubTable();
+      }
+      listViewOptions.value["isFormSubTable"] = true;
+      listViewOptions.value["canRrefreshSubtableData"] = canRrefreshSubtableData;
+      listViewOptions.value["getFormData"] = getParentFormData;
+      listViewOptions.value["getGridData"] = getGridData;
+      if (!(configure.props && configure.props.base && configure.props.base.showOperation)) {
+        let hiddenColumns = listViewOptions.value.hiddenColumns;
+        if (!hiddenColumns) {
+          hiddenColumns = ["operation"];
+        } else {
+          hiddenColumns.push("operation");
+        }
+        listViewOptions.value["hiddenColumns"] = hiddenColumns;
+      }
+      listViewOptions.value["showOperationButton"] = configure.props && configure.props.base ? configure.props.base.showOperation : false;
+      listViewOptions.value["isPdfEditor"] = false;
+      listViewOptions.value["tableRecordMaxNum"] = configure.props && configure.props.otherSettings ? configure.props.otherSettings.tableRecordMaxNum : null;
+      if (configure.props && configure.props.size && configure.props.size.fixHeight) {
+        listViewOptions.value["formSetHeight"] = configure.props.size.fixHeight;
+      }
+      if (configure.props && configure.props.size && configure.props.size.maxHeight) {
+        listViewOptions.value["formSetMaxHeight"] = configure.props.size.maxHeight;
+      }
+    }
+    function judgeInitializationSubTable() {
+      if (!configure.props || !configure.props.otherSettings) {
+        return;
+      }
+      if (configure.props.otherSettings.subtableSetting && configure.props.otherSettings.timeToInitializeSubTable && configure.props.otherSettings.subtableSetting.timeToInitializeSubTable.length > 0) {
+        let flag = false;
+        if (configure.props.otherSettings.subtableSetting.timeToInitializeSubTable.indexOf("create") !== -1) {
+          if (dataModel.id || dataModel.ID) {
+            flag = false;
+          } else {
+            flag = true;
+          }
+        }
+        if (configure.props.otherSettings.subtableSetting.timeToInitializeSubTable.indexOf("noData") !== -1) {
+          const tableData = dataModel[prop];
+          if (!tableData || tableData.length <= 0) {
+            flag = true;
+          }
+        }
+        return flag;
+      } else {
+        return false;
+      }
+    }
+    function getParentFormData() {
+      return pageContext.entity.data;
+    }
+    function getGridData() {
+      return pageHelperUtil.getVariableValue(entity, dynamicFields);
+    }
+    function changeInitializationSubTable(canRrefreshSubtableData) {
+      currencyListViewSetting(canRrefreshSubtableData);
+      listViewOptions.value["isPageInfo"] = false;
+      listViewOptions.value["subTableData"] = getValue();
+      listViewOptions.value.extraParam["subTableListViewCode"] = listCode;
+      listViewOptions.value.extraParam["subtableSetting"] = configure.props && configure.props.otherSettings ? JSON.stringify(configure.props.otherSettings.subtableSetting) : null;
+      listViewOptions.value.extraParam["additionalParamMap"] = additionalParamMap;
+      listViewOptions.value.extraParam["entityMap"] = pageContext.entity.data;
+      setGridDataEventOptions();
+      listViewShowFlag.value = false;
+      setTimeout(() => {
+        listViewShowFlag.value = true;
+        setGridToStore();
+      }, 10);
+    }
+    function setGridDataEventOptions() {
+      setSubTableValidateInfo();
+      eventUtil.setTableEvents(listViewOptions.value, tableEvents, pageContext, configure);
+      const customEvents = pageContext.customEvents;
+      if (customEvents) {
+        listViewOptions.value["eventCallBack"] = customEvents;
+      }
+      listViewShowFlag.value = true;
+      setGridToStore();
+    }
+    function setSubTableValidateInfo() {
+      const fieldPermissionMap = pageContext.fieldPermissionMap;
+      const actionPermissionMap = pageContext.actionPermissionMap;
+      if (fieldPermissionMap && fieldPermissionMap != null) {
+        let validateRules = fieldPermissionMap.get(prop);
+        if (!validateRules) {
+          const allValidateRules = fieldPermissionMap.get("all_fields");
+          if (allValidateRules) {
+            validateRules = [allValidateRules];
+          }
+        }
+        if (validateRules) {
+          listViewOptions.value["validateRules"] = validateRules;
+        } else {
+          listViewOptions.value["validateRules"] = null;
+        }
+      }
+      if (actionPermissionMap && actionPermissionMap != null) {
+        let actionPermission = actionPermissionMap.get(prop);
+        if (!actionPermission) {
+          actionPermission = actionPermissionMap.get("all_sub_tables");
+        }
+        listViewOptions.value["actionPermission"] = actionPermission;
+      }
+      if (!listViewOptions.value["operations"]) {
+        listViewOptions.value["operations"] = {};
+      }
+      const subTableOperations = getOperations();
+      listViewOptions.value["operations"]["operation"] = subTableOperations;
+      listViewOptions.value["subTableCanAdd"] = isShowAdd();
+    }
+    function setGridToStore() {
+      if (!pageContext.tableUuids) {
+        pageContext.tableUuids = [];
+      }
+      pageContext.tableUuids.push(configure.uuid);
+    }
+    function getOperations() {
+      let operations = [];
+      if (isShowAdd()) {
+        const addButton = {
+          props: {
+            elementType: "el-button",
+            icon: "Plus",
+            type: "primary",
+            circle: true,
+            size: "mini",
+            permission: "true"
+          },
+          onClick: addSubTableData
+        };
+        operations.push(addButton);
+      }
+      if (isShowDelete(null, null, null, null, null, true)) {
+        const removeButton = {
+          props: {
+            elementType: "el-button",
+            icon: "Minus",
+            type: "danger",
+            circle: true,
+            size: "mini",
+            permission: "true"
+          },
+          onClick: removeSubTableData,
+          isShow: isShowDelete
+        };
+        operations.push(removeButton);
+      }
+      return operations;
+    }
+    changeInitializationSubTable();
+    function getEntityId(row) {
+      if (row && row.id) {
+        return row.id;
+      } else if (row && row.ID) {
+        return row.ID;
+      }
+    }
+    function isShowAdd() {
+      const fieldPermissionMap = pageContext.fieldPermissionMap;
+      const actionPermissionMap = pageContext.actionPermissionMap;
+      let canAdd = true;
+      if (fieldPermissionMap && fieldPermissionMap !== null) {
+        const allFieldPermission = fieldPermissionMap.get("all_fields");
+        if (typeof allFieldPermission !== "undefined" && allFieldPermission.canEdit === false && (allFieldPermission.rowIndexes === void 0 || allFieldPermission.rowIndexes === null || allFieldPermission.rowIndexes.length === 0)) {
+          canAdd = false;
+        }
+      }
+      if (canAdd === true && prop && actionPermissionMap && actionPermissionMap !== null) {
+        let oneTableActionPermission = actionPermissionMap.get(prop);
+        if (!oneTableActionPermission) {
+          oneTableActionPermission = actionPermissionMap.get("all_sub_tables");
+        }
+        if (oneTableActionPermission && oneTableActionPermission.canAdd !== void 0 && oneTableActionPermission.canAdd === false) {
+          canAdd = false;
+        }
+      }
+      return canAdd;
+    }
+    function isShowDelete(originalValue, formatValue, row, column, rowIndex, isFormJudge) {
+      const fieldPermissionMap = pageContext.fieldPermissionMap;
+      const actionPermissionMap = pageContext.actionPermissionMap;
+      let canDelete = true;
+      if (fieldPermissionMap && fieldPermissionMap !== null) {
+        const allFieldPermission = fieldPermissionMap.get("all_fields");
+        if (typeof allFieldPermission !== "undefined" && allFieldPermission.canEdit === false && (allFieldPermission.rowIndexes === void 0 || allFieldPermission.rowIndexes === null || allFieldPermission.rowIndexes.length === 0)) {
+          canDelete = false;
+        }
+      }
+      if (canDelete === true && prop && actionPermissionMap && actionPermissionMap !== null) {
+        let oneTableActionPermission = actionPermissionMap.get(prop);
+        if (!oneTableActionPermission) {
+          oneTableActionPermission = actionPermissionMap.get("all_sub_tables");
+        }
+        if (oneTableActionPermission && oneTableActionPermission.canDelete !== void 0 && oneTableActionPermission.canDelete === false) {
+          canDelete = false;
+        }
+        if (oneTableActionPermission && oneTableActionPermission.canDelete !== void 0 && oneTableActionPermission.canDelete === true) {
+          if (oneTableActionPermission.deleteRowIndexes) {
+            if (oneTableActionPermission.deleteRowIndexes.length > 0) {
+              if (isFormJudge) {
+                canDelete = true;
+              } else {
+                const rowId = getEntityId(row);
+                if (rowId !== void 0 && oneTableActionPermission.deleteRowIndexes.indexOf(rowId) >= 0) {
+                  canDelete = true;
+                } else {
+                  canDelete = false;
+                }
+              }
+            } else {
+              canDelete = false;
+            }
+          }
+        }
+      }
+      return canDelete;
+    }
+    function addSubTableData(originalValue, formatValue, row, column, rowIndex) {
+      gridRef.value.createRow(listCode);
+    }
+    function removeSubTableData(originalValue, formatValue, row, column, rowIndex) {
+      gridRef.value.deleteRow(rowIndex, listCode, false);
+    }
+    function changeGridData(gridData) {
+      pageHelperUtil.setVariableValue(entity, dynamicFields, gridData);
+    }
+    function changeRowsPerpage(pageSize) {
+      console.log("表单组件--Item--changeRowsPerpage==pageSize=", pageSize);
+      if (!pageContext.subTablePageInfo) {
+        pageContext.subTablePageInfo = {};
+      }
+      pageContext.subTablePageInfo[prop] = { pageSize };
+    }
+    function setSelectOptions(valueSetOptions) {
+      const propName = valueSetOptions.key;
+      const options = valueSetOptions.value;
+      if (!pageContext.selectOptions) {
+        pageContext.selectOptions = {};
+      }
+      pageContext.selectOptions[propName] = options;
+    }
+    function fnProhibitToEdit(data) {
+      const myPageCode = pageContext.code;
+      const eventPageInfo = myPageCode + "_";
+      eventBus.$emit(eventPageInfo + "prohibit-edit", data);
+    }
+    function refresMainTableFields(entity2) {
+      const dataModel2 = pageContext.entity.data;
+      if (entity2) {
+        for (const key in entity2) {
+          dataModel2[key] = entity2[key];
+        }
+      }
+    }
+    function select(selection, row) {
+      selections.value = selection;
+      const params = {
+        selection,
+        row
+      };
+      eventUtil.gridSelectRecord(pageContext, configure, params);
+    }
+    function selectAll(selection) {
+      selections.value = selection;
+      const params = {
+        selection
+      };
+      eventUtil.gridSelectAllRecords(pageContext, configure, params);
+    }
+    function selectionChange(newSelection) {
+      const params = {
+        newSelection
+      };
+      eventUtil.gridSelectionChange(pageContext, configure, params);
+    }
+    function cellClickEvent(row, column, cell, event) {
+      const params = {
+        row,
+        column,
+        cell,
+        event
+      };
+      eventUtil.cellClick(pageContext, configure, params);
+    }
+    function cellDblClickEvent(row, column, cell, event) {
+      const params = {
+        row,
+        column,
+        cell,
+        event
+      };
+      eventUtil.cellDblClick(pageContext, configure, params);
+    }
+    function rowClickEvent(row, column, event) {
+      const params = {
+        row,
+        column,
+        event
+      };
+      eventUtil.rowClick(pageContext, configure, params);
+    }
+    function rowDblClickEvent(row, column, event) {
+      const params = {
+        row,
+        column,
+        event
+      };
+      eventUtil.rowDblClick(pageContext, configure, params);
+    }
+    function headerClickEvent(column, event) {
+      const params = {
+        column,
+        event
+      };
+      eventUtil.headerClick(pageContext, configure, params);
+    }
+    function changeFormData(formData) {
+      pageContext.entity.data = formData;
+    }
+    function validatorSunTableListData() {
+      return gridRef.value.validatorSunTableListData();
+    }
+    function createRow() {
+      return gridRef.value.createRow(listCode);
+    }
+    function getSelections() {
+      return selections.value;
+    }
+    function getSelectionIds() {
+      const dataIds = [];
+      if (selections.value) {
+        selections.value.forEach((item) => {
+          dataIds.push(item.id ? item.id : item.ID ? item.ID : null);
+        });
+      }
+      return dataIds;
+    }
+    function clearSelections() {
+      selections.value = [];
+    }
+    function getTableConfigure() {
+      return configure;
+    }
+    function getValue() {
+      return pageHelperUtil.getVariableValue(entity, dynamicFields);
+    }
+    function setValue(value) {
+      return pageHelperUtil.setVariableValue(entity, dynamicFields, value);
+    }
+    __expose({
+      createRow,
+      getSelections,
+      getSelectionIds,
+      clearSelections,
+      getTableConfigure,
+      validatorSunTableListData,
+      getValue,
+      setValue
+    });
+    return (_ctx, _cache) => {
+      const _component_super_grid = Vue.resolveComponent("super-grid");
+      return Vue.openBlock(), Vue.createElementBlock("div", null, [
+        listViewShowFlag.value ? (Vue.openBlock(), Vue.createBlock(_component_super_grid, {
+          key: 0,
+          ref_key: "gridRef",
+          ref: gridRef,
+          url: Vue.unref(baseURL) + "/common/super-forms/sub-table",
+          options: listViewOptions.value,
+          code: Vue.unref(listCode),
+          settings: Vue.unref(superGridSetting),
+          onSelect: select,
+          onSelectAll: selectAll,
+          onSelectionChange: selectionChange,
+          onCellClick: cellClickEvent,
+          onCellDblclick: cellDblClickEvent,
+          onRowClick: rowClickEvent,
+          onRowDblclick: rowDblClickEvent,
+          onHeaderClick: headerClickEvent,
+          onFnProhibitToEdit: fnProhibitToEdit,
+          onChangeGridData: changeGridData,
+          onReloadGrid: changeInitializationSubTable,
+          onRefresMainTableFields: refresMainTableFields,
+          onSetSelectOptions: setSelectOptions,
+          onChangeRowsPerPage: changeRowsPerpage,
+          onNewOpenGridDialog: Vue.unref(tableUtils.popupToPage),
+          onChangeFormData: changeFormData
+        }, null, 8, ["url", "options", "code", "settings", "onNewOpenGridDialog"])) : Vue.createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/assemblys/data/table/sub-table-runtime.vue2.js

@@ -0,0 +1,3 @@
+"use strict";
+const subTableRuntime_vue_vue_type_script_setup_true_lang = require("./sub-table-runtime.vue.js");
+module.exports = subTableRuntime_vue_vue_type_script_setup_true_lang;

package/dist/lib/components/runtime/views/assemblys/data/table/table-runtime.vue.js

@@ -0,0 +1,3 @@
+"use strict";
+const tableRuntime_vue_vue_type_script_setup_true_lang = require("./table-runtime.vue2.js");
+module.exports = tableRuntime_vue_vue_type_script_setup_true_lang;

package/dist/lib/components/runtime/views/assemblys/data/table/table-runtime.vue2.js

@@ -0,0 +1,88 @@
+"use strict";
+const Vue = require("vue");
+require("../../../../../../node_modules/.pnpm/agilebuilder-ui@1.0.28_vue@3.4.21/node_modules/agilebuilder-ui/lib/super-ui.js");
+require("../../../../../../node_modules/.pnpm/agilebuilder-ui@1.0.28_vue@3.4.21/node_modules/agilebuilder-ui/src/utils/request.js");
+require("../../../../../../node_modules/.pnpm/dayjs@1.11.11/node_modules/dayjs/dayjs.min.js");
+require("../../../../../../node_modules/.pnpm/agilebuilder-ui@1.0.28_vue@3.4.21/node_modules/agilebuilder-ui/src/i18n/i18n.js");
+require("../../../../../../node_modules/.pnpm/js-cookie@3.0.5/node_modules/js-cookie/dist/js.cookie.js");
+require("../../../../utils/global-refs.js");
+const subTableRuntime_vue_vue_type_script_setup_true_lang = require("./sub-table-runtime.vue.js");
+const mainTableRuntime_vue_vue_type_script_setup_true_lang = require("./main-table-runtime.vue.js");
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "table-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const pageType = props.pageContext.pageType;
+    const tableConfigure = Vue.ref(null);
+    const tableUuid = props.configure.uuid;
+    const superGridItems = props.pageContext.superGridItems;
+    const superGridSetting = superGridItems ? superGridItems[tableUuid] : null;
+    tableConfigure.value = superGridSetting ? superGridSetting.configure ? JSON.parse(superGridSetting.configure) : null : props.configure;
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    runtimeInfo.style;
+    runtimeInfo.class;
+    const gridRef = Vue.ref(null);
+    function validatorSunTableListData() {
+      if (pageType && pageType === "form") {
+        return gridRef.value.validatorSunTableListData();
+      }
+    }
+    function clearSelections() {
+      return gridRef.value.clearSelections();
+    }
+    function refresh() {
+      if (pageType && pageType === "list") {
+        return gridRef.value.refresh();
+      }
+    }
+    function createRow() {
+      return gridRef.value.createRow();
+    }
+    function getSelections() {
+      return gridRef.value.getSelections();
+    }
+    function getSelectionIds() {
+      return gridRef.value.getSelectionIds();
+    }
+    function getTableConfigure() {
+      return gridRef.value.getTableConfigure();
+    }
+    function isDeleteChange(value) {
+      if (pageType && pageType === "list") {
+        gridRef.value.isDeleteChange(value);
+      }
+    }
+    __expose({
+      refresh,
+      createRow,
+      clearSelections,
+      getSelections,
+      getSelectionIds,
+      getTableConfigure,
+      isDeleteChange,
+      validatorSunTableListData
+    });
+    return (_ctx, _cache) => {
+      return Vue.openBlock(), Vue.createElementBlock("div", null, [
+        Vue.unref(pageType) && Vue.unref(pageType) === "form" ? (Vue.openBlock(), Vue.createBlock(subTableRuntime_vue_vue_type_script_setup_true_lang, {
+          key: 0,
+          ref_key: "gridRef",
+          ref: gridRef,
+          pageContext: _ctx.pageContext,
+          configure: tableConfigure.value
+        }, null, 8, ["pageContext", "configure"])) : (Vue.openBlock(), Vue.createBlock(mainTableRuntime_vue_vue_type_script_setup_true_lang, {
+          key: 1,
+          ref_key: "gridRef",
+          ref: gridRef,
+          pageContext: _ctx.pageContext,
+          configure: tableConfigure.value
+        }, null, 8, ["pageContext", "configure"]))
+      ]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/assemblys/error-render.vue.d.ts

@@ -0,0 +1,22 @@
+declare const _default: import('vue').DefineComponent<{
+    configure: {
+        type: ObjectConstructor;
+        default: {
+            name: string;
+        };
+    };
+    selectWidget: ObjectConstructor;
+    indexObj: ObjectConstructor;
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    configure: {
+        type: ObjectConstructor;
+        default: {
+            name: string;
+        };
+    };
+    selectWidget: ObjectConstructor;
+    indexObj: ObjectConstructor;
+}>>, {
+    configure: Record<string, any>;
+}, {}>;
+export default _default;

package/dist/lib/components/runtime/views/assemblys/error-render.vue.js

@@ -0,0 +1,22 @@
+"use strict";
+const Vue = require("vue");
+const _hoisted_1 = { style: { "text-align": "center", "color": "red" } };
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "error-render",
+  props: {
+    configure: {
+      type: Object,
+      default: {
+        name: "未知"
+      }
+    },
+    selectWidget: Object,
+    indexObj: Object
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return Vue.openBlock(), Vue.createElementBlock("div", _hoisted_1, " 不能识别的组件类型【" + Vue.toDisplayString(__props.configure.name) + "】 ", 1);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/assemblys/error-render.vue2.js

@@ -0,0 +1,3 @@
+"use strict";
+const errorRender_vue_vue_type_script_setup_true_lang = require("./error-render.vue.js");
+module.exports = errorRender_vue_vue_type_script_setup_true_lang;

package/dist/lib/components/runtime/views/assemblys/form/checkbox/checkbox-runtime.vue.js

@@ -0,0 +1,3 @@
+"use strict";
+const checkboxRuntime_vue_vue_type_script_setup_true_lang = require("./checkbox-runtime.vue2.js");
+module.exports = checkboxRuntime_vue_vue_type_script_setup_true_lang;