super-page-runtime 0.0.1-tmp2

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

@@ -0,0 +1,640 @@
+"use strict";
+const vue = require("vue");
+const eventUtil = require("../../../../../src/utils/events/event-util.js");
+const commonUtil = require("../../../../../src/utils/common-util.js");
+const standardEvent = require("../../../../../src/utils/events/standard-event.js");
+const commonUtil$1 = require("agilebuilder-ui/src/utils/common-util");
+const tableUtils = require("../../../../../src/utils/table-utils.js");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "main-table-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const pageContext = props.pageContext;
+    const configure = props.configure;
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    const runtimeStyle = runtimeInfo.style;
+    const runtimeClass = runtimeInfo.class;
+    const system = pageContext.entity.system;
+    const tableName = pageContext.tableName;
+    const baseURL = window["$vueApp"].config.globalProperties.baseURL;
+    const operationButtonObj = vue.ref(null);
+    const eventName = vue.ref(null);
+    const listOptions = vue.ref({});
+    listOptions.value = getOptions();
+    const gridRef = vue.ref(null);
+    const urlToListData = getUrlToListData(system);
+    const listCode = commonUtil.getListCode(pageContext.code, pageContext.version, configure.uuid);
+    const myPageCode = pageContext.code;
+    const eventPageInfo = myPageCode + "_" + listCode;
+    const selections = vue.ref([]);
+    const listToolbarFormData = pageContext.entity.page;
+    const searchFormInfo = vue.ref({ data: [] });
+    const superGridItems = pageContext.superGridItems;
+    const superGridSetting = superGridItems ? superGridItems[configure.uuid] : null;
+    console.log("superGridSetting1111===", superGridItems, superGridSetting);
+    vue.onMounted(() => {
+      window.addEventListener("message", recieveMessage);
+      window["$eventBus"].$on(
+        eventPageInfo + "-close-component-page-dialog",
+        function({ jumpInfo, popEntity, popPageCode }) {
+          gridRef.value.closePageDialog({
+            entity: popEntity,
+            pageCode: popPageCode,
+            jumpInfo
+          });
+        }
+      );
+      window["$eventBus"].$on(eventPageInfo + "_close-dialog-get-entity", () => {
+        window["$eventBus"].$emit(eventPageInfo + "_close-super-dialog");
+      });
+    });
+    vue.watch(
+      () => props.pageContext.searchFormData,
+      (searchFormData) => {
+        searchFormInfo.value.data = searchFormData;
+      }
+    );
+    vue.watch(
+      () => props.pageContext.entity.data,
+      (searchFormData) => {
+        searchGridData(props.pageContext.entity.data);
+      }
+    );
+    vue.watch(
+      () => props.pageContext.entity.page,
+      (searchFormData) => {
+        searchGridData(props.pageContext.entity.page);
+      }
+    );
+    vue.onUnmounted(() => {
+      window["$eventBus"].$off(eventPageInfo + "-close-component-page-dialog");
+      window["$eventBus"].$off(eventPageInfo + "_close-dialog-get-entity");
+    });
+    function getUrlToListData(system2) {
+      let urlToListData2;
+      if (!pageContext.isTest) {
+        urlToListData2 = baseURL + "/dsc/commons/list";
+        if (urlToListData2) {
+          urlToListData2 = commonUtil.getRealRestApiPath(urlToListData2, system2);
+        }
+      }
+      return urlToListData2;
+    }
+    function getOptions() {
+      const system2 = pageContext.entity.system;
+      const permissionPrefix = system2.code + "." + pageContext.code;
+      let initSearchForm = configure.props && configure.props.dataOrigin ? configure.props.dataOrigin.sqlFilterCondition : null;
+      if (typeof initSearchForm === "undefined" || initSearchForm === null) {
+        initSearchForm = [];
+      }
+      const options = {
+        isSql: true,
+        extraParam: {
+          beanName: pageContext.beanName,
+          functionCode: permissionPrefix + ".list",
+          tableName,
+          systemCode: system2.code
+          // 系统编码传给列表数据后台请求
+        },
+        initSearchForm,
+        lineEditOptions: {
+          aftersaveIsCreateRow: false,
+          autoSave: false,
+          enter: enterSave,
+          esc: escRestorRow
+        },
+        indexContinuous: configure.props && configure.props.otherSettings ? configure.props.otherSettings.serialNumberContinuous : false,
+        initSearch: configure.props && configure.props.base.initializationQuery ? configure.props.base.initializationQuery : true,
+        // 初始化时是否查询，默认是查询
+        resizeHeight: resizeListHeight,
+        pageCode: pageContext.code,
+        pageVersion: pageContext.version,
+        // pageHeight: pageHeight, // 页面的高度 //TODO: pageHeight如何获得，页面高度，计算列表高度应该会用
+        additionalParamMap: pageContext.entity.request,
+        // 将路由参数传给列表组件
+        showOverflowTooltip: !!(configure.props && configure.props.otherSettings && (configure.props.otherSettings.isBreakLine === void 0 || configure.props.otherSettings.isBreakLine === false)),
+        // 单元格内容是否换行显示
+        isEnableEnterEvent: configure.props && configure.props.otherSettings && configure.props.otherSettings.isEnableEnterEvent,
+        // 是否启用回车事件
+        // 当前系统，表示是当前的自定义系统信息
+        system: system2,
+        isWithDataPermission: configure.props && configure.props.otherSettings && configure.props.otherSettings.isWithDataPermission ? configure.props.otherSettings.isWithDataPermission : false,
+        pageDevMode: false,
+        isWorkflowEntity: pageContext.workflowCode ? true : false,
+        tableClass: runtimeClass,
+        tableStyle: runtimeStyle,
+        pageContext,
+        configureObj: configure
+      };
+      setSortInfo(options);
+      myGetDataTypeMap(options);
+      setTreeSetting(options);
+      setGridEvents(options);
+      return options;
+    }
+    function setSortInfo(options) {
+      if (configure.props && configure.props.dataOrigin && configure.props.dataOrigin.sortFields) {
+        options.initSortInfo = [];
+        this.colSetting.options.sortFields.forEach((item) => {
+          const sortInfo = {
+            order: item.sortOrder
+          };
+          sortInfo["prop"] = item.propDbName;
+          options.initSortInfo.push(sortInfo);
+        });
+      }
+    }
+    function myGetDataTypeMap(options) {
+      if (!system || !tableName) {
+        return;
+      }
+      tableUtils.getDataTypeMap(system, tableName).then((result) => {
+        pageContext["dataTypeMaps"][tableName] = result["dataTypeMap"];
+        setOperationButtons(options);
+      });
+    }
+    function setOperationButtons(options) {
+      const showOperation = configure.props && configure.props.base ? configure.props.base.showOperation : false;
+      const operationButtons = configure.btnList;
+      if (showOperation && operationButtons) {
+        const operationButtons2 = [];
+        operationButtons2.forEach((buttonConfigure) => {
+          const myButtonSet = {};
+          const myButtonProps = Object.assign({}, buttonConfigure.props.base);
+          myButtonProps.elementType = "el-button";
+          if (buttonConfigure.isPermission === void 0 || buttonConfigure.isPermission + "" === "true") {
+            if (buttonConfigure.functionCode) {
+              myButtonProps.permission = buttonConfigure.functionCode;
+            }
+          }
+          myButtonSet["props"] = myButtonProps;
+          myButtonSet["onClick"] = getOperationButtonClickEvent(buttonConfigure);
+          operationButtons2.push(myButtonSet);
+        });
+        if (!options.operations) {
+          options.operations = {};
+        }
+        options.operations.operation = operationButtons2;
+      }
+    }
+    function setTreeSetting(options) {
+      const dataOrigin = configure.props ? configure.props.dataOrigin : {};
+      if (dataOrigin.treeTable) {
+        let parentPropDbName;
+        const parentPropInfo = dataOrigin.rowKey;
+        if (parentPropInfo && parentPropInfo.indexOf("~~") > 0) {
+          parentPropDbName = parentPropInfo.substring(parentPropInfo.indexOf("~~") + 2);
+        } else {
+          parentPropDbName = parentPropInfo;
+        }
+        options.parentProp = parentPropDbName;
+        if (options.parentProp) {
+          const isLazy = dataOrigin.lazy;
+          const defaultExpandAll = dataOrigin.defaultExpandAll;
+          if (isLazy === void 0 || isLazy === null) {
+            options.lazy = true;
+          } else {
+            options.lazy = isLazy;
+          }
+          if (defaultExpandAll === void 0 || defaultExpandAll === null) {
+            options.defaultExpandAll = false;
+          } else {
+            options.defaultExpandAll = defaultExpandAll;
+          }
+          const listViewTreeTableSetting = {
+            parentProp: parentPropDbName,
+            lazy: options.lazy,
+            defaultExpandAll: options.defaultExpandAll
+          };
+          options.extraParam.listViewTreeSetting = JSON.stringify(listViewTreeTableSetting);
+          options.subRowUrl = baseURL + "/dsc/commons/list-subs";
+        }
+      }
+    }
+    function setGridEvents(options) {
+      const tableEvents = configure.events;
+      eventUtil.setTableEvents(options, tableEvents, pageContext, configure);
+      const customEvents = pageContext.customEvents;
+      if (customEvents) {
+        options.eventCallBack = customEvents;
+        const rowStyleEvent = eventUtil.getEventFuncByType(pageContext, tableEvents, "rowStyle");
+        if (rowStyleEvent) {
+          options.rowStyleRender = rowStyleEvent;
+        }
+      }
+    }
+    function enterSave(rowIndex, column, row, orgRow) {
+      saveRow(null, null, row, column, rowIndex);
+    }
+    function saveRow(originalValue, formatValue, row, column, rowIndex) {
+      const buttonConfigure = operationButtonObj.value[eventName.value];
+      listOptions.value["lineEditOptions"]["beforeSave"] = beforeSaveRow;
+      pageContext.editData = row;
+      eventUtil.canExecuteButton({ pageContext, configureObj: buttonConfigure }).then((result) => {
+        if (result["canExecute"] === true) {
+          listOptions.value["lineEditOptions"]["saveRow"] = saveLineEditRow;
+          gridRef.value.saveRow(rowIndex, listCode).then(() => {
+            const otherParams = {
+              originalValue,
+              formatValue,
+              row,
+              column,
+              rowIndex
+            };
+            eventUtil.doAfterClickEvent(pageContext, buttonConfigure, otherParams);
+          });
+        }
+      }).finally(() => {
+        pageContext.editData = null;
+      });
+    }
+    function getOperationButtonClickEvent(buttonConfigure) {
+      let onClick;
+      eventName.value = buttonConfigure.eventName;
+      operationButtonObj.value[eventName.value] = buttonConfigure;
+      if (eventName.value === "lineEditSave") {
+        onClick = saveRow;
+      } else if (eventName.value === "restoreEdit") {
+        onClick = restoreRow;
+      } else if (eventName.value === "lineEditUpdate") {
+        onClick = editRow;
+      } else if (eventName.value === "lineEditDelete") {
+        onClick = deleteRow;
+      } else {
+        onClick = customButtonClick;
+      }
+      if (!onClick) {
+        onClick = function() {
+        };
+      }
+      return onClick;
+    }
+    function beforeSaveRow(row, columns, dataTypeMap, dynamicColumnInfo, additionalParamMap, mainDefaultValueColumns) {
+      const buttonConfigure = operationButtonObj.value[eventName.value];
+      const otherParams = {
+        dynamicColumnInfo,
+        mainDefaultValueColumns,
+        dataTypeMap,
+        row,
+        columns
+      };
+      return eventUtil.doBeforeClickEvent(pageContext, buttonConfigure, otherParams);
+    }
+    function saveLineEditRow(row, columns, dataTypeMap, dynamicColumnInfo, additionalParamMap, mainDefaultValueColumns) {
+      const buttonConfigure = operationButtonObj.value[eventName.value];
+      return new Promise((resolve, reject) => {
+        standardEvent.getSaveFormRequest(
+          pageContext,
+          buttonConfigure,
+          "/dsc/commons",
+          false,
+          mainDefaultValueColumns,
+          dynamicColumnInfo
+        ).then((commonEntity) => {
+          if (commonEntity) {
+            resolve(commonEntity.entity);
+          } else {
+            resolve({});
+          }
+        }).catch((error) => {
+          reject(error);
+        });
+      });
+    }
+    function escRestorRow(rowIndex, column, row, orgRow) {
+      restoreRow(null, null, row, column, rowIndex);
+    }
+    function restoreRow(originalValue, formatValue, row, column, rowIndex) {
+      const buttonConfigure = operationButtonObj.value[eventName.value];
+      const otherParams = {
+        originalValue,
+        formatValue,
+        row,
+        column,
+        rowIndex
+      };
+      const beforeClickResult = eventUtil.doBeforeClickEvent(pageContext, buttonConfigure, otherParams);
+      if (!beforeClickResult) {
+        return;
+      }
+      if (commonUtil$1.isPromise(beforeClickResult)) {
+        beforeClickResult.then((result) => {
+          if (result) {
+            gridRef.value.restoreRow(rowIndex, listCode);
+          }
+        });
+      } else {
+        gridRef.value.restoreRow(rowIndex, listCode);
+      }
+      const afterOtherParams = {
+        originalValue,
+        formatValue,
+        row,
+        column,
+        rowIndex
+      };
+      eventUtil.doAfterClickEvent(pageContext, configure, afterOtherParams);
+    }
+    function editRow(originalValue, formatValue, row, column, rowIndex) {
+      const buttonConfigure = operationButtonObj.value[eventName.value];
+      const otherParams = {
+        originalValue,
+        formatValue,
+        row,
+        column,
+        rowIndex
+      };
+      const beforeClickResult = eventUtil.doBeforeClickEvent(pageContext, buttonConfigure, otherParams);
+      if (!beforeClickResult) {
+        return;
+      }
+      if (commonUtil$1.isPromise(beforeClickResult)) {
+        beforeClickResult.then((result) => {
+          if (result) {
+            editRowReal(originalValue, formatValue, row, column, rowIndex, buttonConfigure);
+          }
+        });
+      } else {
+        editRowReal(originalValue, formatValue, row, column, rowIndex, buttonConfigure);
+      }
+    }
+    function editRowReal(originalValue, formatValue, row, column, rowIndex, buttonConfigure) {
+      pageContext.editData = row;
+      eventUtil.canExecuteButton({ pageContext, configureObj: buttonConfigure }).then((result) => {
+        if (result["canExecute"] === true) {
+          gridRef.value.editRow(rowIndex, listCode);
+          const afterOtherParams = {
+            originalValue,
+            formatValue,
+            row,
+            column,
+            rowIndex
+          };
+          eventUtil.doAfterClickEvent(pageContext, configure, afterOtherParams);
+        }
+      }).finally(() => {
+        pageContext.editData = null;
+      });
+    }
+    function deleteRow(originalValue, formatValue, row, column, rowIndex) {
+      const buttonConfigure = operationButtonObj.value[eventName.value];
+      const otherParams = {
+        originalValue,
+        formatValue,
+        row,
+        column,
+        rowIndex
+      };
+      const beforeClickResult = eventUtil.doBeforeClickEvent(pageContext, buttonConfigure, otherParams);
+      if (!beforeClickResult) {
+        return;
+      }
+      if (commonUtil$1.isPromise(beforeClickResult)) {
+        beforeClickResult.then((result) => {
+          if (result) {
+            deleteRowReal(originalValue, formatValue, row, column, rowIndex, buttonConfigure);
+          }
+        });
+      } else {
+        deleteRowReal(originalValue, formatValue, row, column, rowIndex, buttonConfigure);
+      }
+    }
+    function deleteRowReal(originalValue, formatValue, row, column, rowIndex, buttonConfigure) {
+      if (row.id || row.ID) {
+        pageContext.editData = row;
+        eventUtil.canExecuteButton({ pageContext, configureObj: buttonConfigure }).then((result) => {
+          if (result["canExecute"] === true) {
+            const ids = [];
+            if (row.id) {
+              ids.push(row.id);
+            } else {
+              ids.push(row.ID);
+            }
+            standardEvent.standardEvents.delete({
+              pageContext,
+              configureObj: buttonConfigure,
+              ids,
+              tableUuid: listCode
+            });
+          }
+        }).finally(() => {
+          pageContext.editData = null;
+        });
+      } else {
+        restoreRow(originalValue, formatValue, row, column, rowIndex);
+        const afterOtherParams = {
+          originalValue,
+          formatValue,
+          row,
+          column,
+          rowIndex
+        };
+        eventUtil.doAfterClickEvent(pageContext, configure, afterOtherParams);
+      }
+    }
+    function searchGridData(data) {
+      if (!pageContext["dataTypeMaps"] || !pageContext["dataTypeMaps"][tableName]) {
+        return;
+      }
+      const dataTypeObj = pageContext["dataTypeMaps"][tableName];
+      let toolbarFieldParam = [];
+      if (data) {
+        for (var key in data) {
+          const value = data[key];
+          if (value !== null && value !== void 0 && value !== "") {
+            if (value instanceof Array) {
+              if (value.length > 0) {
+                const multipleFieldParam = [];
+                for (var i = 0; i < value.length; i++) {
+                  const fieldParam = {};
+                  if (i === 0) {
+                    fieldParam["leftBracket"] = "((";
+                  } else {
+                    fieldParam["leftBracket"] = "(";
+                  }
+                  fieldParam["propName"] = key;
+                  fieldParam["propDbName"] = key;
+                  fieldParam["dataType"] = dataTypeObj[key] ? dataTypeObj[key] : "TEXT";
+                  fieldParam["operator"] = "EQ";
+                  fieldParam["propValue"] = value[i];
+                  if (i === value.length - 1) {
+                    fieldParam["rightBracket"] = "))";
+                    fieldParam["joinSign"] = "and";
+                  } else {
+                    fieldParam["rightBracket"] = ")";
+                    fieldParam["joinSign"] = "or";
+                  }
+                  multipleFieldParam.push(fieldParam);
+                }
+                toolbarFieldParam = toolbarFieldParam.concat(multipleFieldParam);
+              }
+            } else {
+              const fieldParam = {};
+              fieldParam["leftBracket"] = "(";
+              fieldParam["propName"] = key;
+              fieldParam["propDbName"] = key;
+              fieldParam["dataType"] = dataTypeObj[key] ? dataTypeObj[key] : "TEXT";
+              fieldParam["operator"] = "EQ";
+              fieldParam["propValue"] = value;
+              fieldParam["rightBracket"] = ")";
+              fieldParam["joinSign"] = "and";
+              toolbarFieldParam.push(fieldParam);
+            }
+          }
+        }
+      }
+      gridRef.value.toolbarRefresh(null, null, toolbarFieldParam);
+    }
+    function resizeListHeight(params) {
+    }
+    function customButtonClick(originalValue, formatValue, row, column, rowIndex, button) {
+      const otherParams = {
+        originalValue,
+        formatValue,
+        row,
+        column,
+        rowIndex,
+        button
+      };
+      const buttonConfigure = operationButtonObj.value[eventName.value];
+      eventUtil.getHandleEvent(null, pageContext, buttonConfigure, "click", otherParams);
+    }
+    function recieveMessage(event) {
+      if (event.data === "close_open_win") {
+        gridRef.value.refresh();
+      }
+    }
+    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 validatorSunTableListData() {
+      return gridRef.value.validatorSunTableListData();
+    }
+    function clearSelections() {
+      selections.value = [];
+    }
+    function refresh() {
+      return gridRef.value.refresh();
+    }
+    function createRow() {
+      return gridRef.value.createRow(listCode);
+    }
+    function getSelections() {
+      return selections.value;
+    }
+    function getSelectionIds() {
+      const dataIds = [];
+      if (selections.value !== null) {
+        selections.value.forEach((item) => {
+          dataIds.push(item.id ? item.id : item.ID ? item.ID : null);
+        });
+      }
+      return dataIds;
+    }
+    function getTableConfigure() {
+      return configure;
+    }
+    function isDeleteChange(value) {
+      gridRef.value.isDeleteChange(value);
+    }
+    __expose({
+      refresh,
+      createRow,
+      clearSelections,
+      getSelections,
+      getSelectionIds,
+      getTableConfigure,
+      isDeleteChange,
+      validatorSunTableListData
+    });
+    return (_ctx, _cache) => {
+      const _component_super_grid = vue.resolveComponent("super-grid");
+      return vue.openBlock(), vue.createElementBlock("div", null, [
+        vue.createVNode(_component_super_grid, {
+          ref_key: "gridRef",
+          ref: gridRef,
+          url: vue.unref(urlToListData),
+          options: listOptions.value,
+          code: vue.unref(superGridSetting) ? null : vue.unref(listCode),
+          settings: vue.unref(superGridSetting),
+          "search-form-info": searchFormInfo.value,
+          "list-toolbar-form-data": vue.unref(listToolbarFormData),
+          onSelect: select,
+          onSelectAll: selectAll,
+          onSelectionChange: selectionChange,
+          onCellClick: cellClickEvent,
+          onCellDblclick: cellDblClickEvent,
+          onRowClick: rowClickEvent,
+          onRowDblclick: rowDblClickEvent,
+          onHeaderClick: headerClickEvent,
+          onRefresh: clearSelections,
+          onNewOpenGridDialog: vue.unref(tableUtils.popupToPage)
+        }, null, 8, ["url", "options", "code", "settings", "search-form-info", "list-toolbar-form-data", "onNewOpenGridDialog"])
+      ]);
+    };
+  }
+});
+module.exports = _sfc_main;

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

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