super-page-runtime 2.0.39 → 2.0.40-beta1

package/dist/lib/components/runtime/utils/events/event-util.js

@@ -0,0 +1,616 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const commonUtil$1 = require("../../../../node_modules/.pnpm/agilebuilder-ui@1.0.28_vue@3.4.21/node_modules/agilebuilder-ui/src/utils/common-util.js");
+const standardEvent = require("./standard-event.js");
+const validatorUtil = require("./validator-util.js");
+const globalRefs = require("../global-refs.js");
+const util = require("../../../../node_modules/.pnpm/agilebuilder-ui@1.0.28_vue@3.4.21/node_modules/agilebuilder-ui/src/utils/util.js");
+const commonUtil = require("../common-util.js");
+const eventBus = require("../eventBus.js");
+const pageHelperUtil = require("../page-helper-util.js");
+const index = require("../../../../node_modules/.pnpm/element-plus@2.6.2_vue@3.4.21/node_modules/element-plus/es/components/message/index.js");
+function initPageEvents(pageDesign, pageContext) {
+  if (pageDesign && pageDesign.customEvents) {
+    const customEvents = transferToFunction(pageDesign.customEvents);
+    appendDefaultMethod(pageContext, customEvents);
+    console.log("initPage  customEvents", customEvents);
+    pageContext.customEvents = customEvents;
+  }
+}
+function getCustomFunc(pageContext, funcName) {
+  if (pageContext.customEvents) {
+    return pageContext.customEvents[funcName];
+  }
+}
+function appendDefaultMethod(pageContext, customEvents) {
+  if (!customEvents) {
+    return;
+  }
+  for (const pro in customEvents) {
+    const func = customEvents[pro];
+    func.get = function(code) {
+      if (code) {
+        return globalRefs.getComponentRefByCode(pageContext, code);
+      } else {
+        return void 0;
+      }
+    };
+    func.getByUuid = function(uuid) {
+      if (uuid) {
+        return globalRefs.getComponentRef(pageContext, uuid);
+      } else {
+        return void 0;
+      }
+    };
+    func.getPageContext = function() {
+      return pageContext;
+    };
+    func.getContextValue = function(fieldName) {
+      let contextData = pageContext && pageContext.entity ? pageContext.entity.context : null;
+      contextData = contextData ? contextData : {};
+      return pageHelperUtil.getValueFromSource(contextData, fieldName, "context");
+    };
+    func.getContext = function() {
+      return pageContext && pageContext.entity ? pageContext.entity.context : {};
+    };
+    func.getSystem = function() {
+      return pageContext && pageContext.entity ? pageContext.entity.system : {};
+    };
+    func.getTask = function() {
+      return pageContext && pageContext.entity ? pageContext.entity.task : {};
+    };
+    func.getRequest = function() {
+      return pageContext && pageContext.entity ? pageContext.entity.request : {};
+    };
+    func.getPage = function() {
+      return pageContext && pageContext.entity ? pageContext.entity.page : {};
+    };
+    func.getCustomFunc = function(funcName) {
+      return getCustomFunc(pageContext, funcName);
+    };
+  }
+}
+function removeCustomFuncFromWindow(pageDesign) {
+  if (pageDesign && pageDesign.customEvents) {
+    const customEvents = pageDesign.customEvents;
+    const customFuncs = customEvents.filter((item) => item.name === "customFunc" && item.jsContent);
+    if (customFuncs && customFuncs.length > 0) {
+      customFuncs.forEach((event) => {
+        delete window["$page_" + event.eventName];
+      });
+    }
+  }
+}
+function handleEvent($event, pageContext, configure, eventType, otherParams) {
+  return handleEventUtil($event, pageContext, configure, eventType, true, otherParams);
+}
+function getHandleEvent($event, pageContext, configure, eventType, otherParams) {
+  return handleEventUtil($event, pageContext, configure, eventType, false, otherParams);
+}
+function handleEventUtil($event, pageContext, configure, eventType, isExecute, otherParams) {
+  const pageCode = pageContext.code;
+  const pageVersion = pageContext.version;
+  const events = configure.runtime && configure.runtime.events ? configure.runtime.events : [];
+  let eventFun;
+  if (eventType && eventType === "click") {
+    const tableUuid = getTableUuid(pageContext, configure);
+    if (tableUuid) {
+      const gridRef = globalRefs.getComponentRef(pageContext, tableUuid);
+      const selections = gridRef.getSelections();
+      const selectionIds = gridRef.getSelectionIds();
+      if (!otherParams) {
+        otherParams = {};
+      }
+      otherParams["tableUuid"] = tableUuid;
+      otherParams["listCode"] = commonUtil.getListCode(pageCode, pageVersion, tableUuid);
+      const isListButton = isListPage(pageContext);
+      if (isListButton) {
+        otherParams["selections"] = selections;
+        otherParams["id"] = selectionIds && selectionIds.length > 0 ? selectionIds[0] : null;
+        otherParams["ids"] = selectionIds;
+      }
+      const tableConfigure = gridRef.getTableConfigure();
+      otherParams["tableConfigure"] = tableConfigure;
+    }
+    const eventParams = packageEventParams(pageContext, configure, $event, otherParams);
+    buttonClickEvent(pageContext, configure, eventParams);
+  } else {
+    eventFun = getEventFuncByType(pageContext, events, eventType);
+    if (isExecute) {
+      const eventParams = packageEventParams(pageContext, configure, $event, otherParams);
+      return callItemEvent(pageContext, configure, eventFun, eventParams);
+    } else {
+      return eventFun;
+    }
+  }
+}
+function getTableUuid(pageContext, configure) {
+  return configure.props.base.tableUuid ? configure.props.base.tableUuid : pageContext.tableUuids && pageContext.tableUuids.length > 0 ? pageContext.tableUuids[0] : null;
+}
+function packageEventParams(pageContext, configureObj, $event, otherParams) {
+  const params = {};
+  if (otherParams) {
+    for (const key in otherParams) {
+      params[key] = otherParams[key];
+    }
+  }
+  if ($event !== void 0 && $event !== null) {
+    params["_value"] = $event;
+  }
+  if (pageContext) {
+    params["pageContext"] = pageContext;
+  }
+  if (configureObj) {
+    params["configureObj"] = configureObj;
+  }
+  return params;
+}
+function buttonClickEvent(pageContext, configure, eventParams) {
+  const judgeFlag = standardEvent.judgeDataNumber(configure, eventParams["ids"]);
+  if (!judgeFlag) {
+    return;
+  }
+  canExecuteButton(eventParams).then((result) => {
+    if (result["canExecute"] === true) {
+      const events = configure.runtime && configure.runtime.events ? configure.runtime.events : [];
+      const beforeValidateFormFunc = getEventFuncByType(pageContext, events, "beforeValidateForm");
+      let beforeValidateFormResult;
+      if (beforeValidateFormFunc) {
+        beforeValidateFormResult = callItemEvent(
+          pageContext,
+          configure,
+          beforeValidateFormFunc,
+          eventParams
+        );
+      }
+      if (beforeValidateFormResult === void 0) {
+        beforeValidateFormResult = true;
+      }
+      if (!beforeValidateFormResult) {
+        return;
+      }
+      if (commonUtil$1.isPromise(beforeValidateFormResult)) {
+        beforeValidateFormResult.then((result2) => {
+          if (result2 && result2 === true) {
+            doValidateForm(pageContext, configure, eventParams);
+          }
+        });
+      } else {
+        doValidateForm(pageContext, configure, eventParams);
+      }
+    }
+  });
+}
+function doValidateForm(pageContext, configure, eventParams) {
+  const events = configure.runtime && configure.runtime.events ? configure.runtime.events : [];
+  const clickEventFunObj = getClickEventFuncByType(pageContext, events, "click");
+  if (clickEventFunObj) {
+    const isStandardEvent = clickEventFunObj.isStandard;
+    const event = clickEventFunObj.event;
+    isNotNeedValidateRequired(isStandardEvent, event);
+  }
+  validatorUtil.validateDataModelFunc(pageContext, configure, true).then(() => {
+    const beforeClickResult = doBeforeClickEvent(pageContext, configure, eventParams);
+    if (!beforeClickResult) {
+      return;
+    }
+    if (commonUtil$1.isPromise(beforeClickResult)) {
+      beforeClickResult.then((result) => {
+        if (result) {
+          doClickEvent(pageContext, configure, clickEventFunObj, eventParams);
+        }
+      });
+    } else {
+      doClickEvent(pageContext, configure, clickEventFunObj, eventParams);
+    }
+  });
+}
+function doBeforeClickEvent(pageContext, configure, otherParams) {
+  let result = true;
+  const events = configure.runtime && configure.runtime.events ? configure.runtime.events : [];
+  const beforeClickFunc = getEventFuncByType(pageContext, events, "beforeClick");
+  let beforeClickResult;
+  if (beforeClickFunc) {
+    beforeClickResult = callItemEvent(pageContext, configure, beforeClickFunc, null, otherParams);
+  }
+  if (beforeClickResult === void 0) {
+    result = true;
+  }
+  return result;
+}
+function doClickJumpPageEvent(pageContext, configure, eventParams) {
+  const myPageCode = pageContext.code;
+  const eventPageInfo = myPageCode + "_";
+  eventBus.$emit(eventPageInfo + "open-dialog", {
+    pageContext,
+    configureObj: configure,
+    eventParams
+  });
+}
+function isListPage(pageContext, configure) {
+  return pageContext.pageType && pageContext.pageType === "list" ? true : false;
+}
+function doClickCustomEvent(pageContext, configure, clickEventFuncObj, eventParams) {
+  const eventFunObj = clickEventFuncObj;
+  if (eventFunObj) {
+    const eventFun = eventFunObj["func"];
+    const isStandardEvent = eventFunObj["isStandard"];
+    const event = eventFunObj["event"];
+    const clickResult = callItemEvent(pageContext, configure, eventFun, eventParams);
+    const isListButton = isListPage(pageContext);
+    if (isNotDoAfterClick(isStandardEvent, event)) {
+      return;
+    }
+    if (commonUtil$1.isPromise(clickResult)) {
+      clickResult.then((result) => {
+        if (result) {
+          doAfterClickFunc(
+            pageContext,
+            configure,
+            eventParams,
+            isStandardEvent,
+            result,
+            isListButton
+          );
+        }
+      });
+    } else {
+      doAfterClickFunc(
+        pageContext,
+        configure,
+        eventParams,
+        isStandardEvent,
+        clickResult,
+        isListButton
+      );
+    }
+  }
+}
+function isNotDoAfterClick(isStandardEvent, clickEvent) {
+  return isStandardEvent && (clickEvent.eventName === "exportForm" || clickEvent.eventName === "exportPDF" || clickEvent.eventName === "import" || clickEvent.eventName === "assign" || clickEvent.eventName === "copyTask" || clickEvent.eventName === "addSigner" || clickEvent.eventName === "returnTaskTo" || clickEvent.eventName === "removeSigner");
+}
+function isNotNeedValidateRequired(isStandardEvent, clickEvent) {
+  return isStandardEvent && (clickEvent.eventName === "downloadTemplate" || clickEvent.eventName === "back" || clickEvent.eventName === "exportForm" || clickEvent.eventName === "exportPDF" || clickEvent.eventName === "lineEditCreate");
+}
+function doAfterClickEvent(pageContext, configure, otherParams) {
+  const events = configure.runtime && configure.runtime.events ? configure.runtime.events : [];
+  const afterClickFunc = getEventFuncByType(pageContext, events, "afterClick");
+  if (afterClickFunc) {
+    callItemEvent(pageContext, configure, afterClickFunc, null, otherParams);
+  }
+}
+function doAfterClickFunc(pageContext, configure, eventParams, isStandardEvent, result, isListButton) {
+  if (!isStandardEvent) {
+    standardEvent.dealAfterOperate(
+      pageContext,
+      configure,
+      result,
+      "",
+      // superPageRuntimeMessage.successfulOperation 开发人员自己加事件
+      isListButton
+    );
+  } else {
+    pageContext.result = result;
+  }
+  const events = configure.runtime && configure.runtime.events ? configure.runtime.events : [];
+  const afterClickFunc = getEventFuncByType(pageContext, events, "afterClick");
+  if (afterClickFunc) {
+    callItemEvent(pageContext, configure, afterClickFunc, eventParams);
+  }
+}
+function doClickEvent(pageContext, configure, clickEventFunObj, eventParams) {
+  const linkPage = configure.props.linkPage;
+  if (linkPage && linkPage.jumpPageUrl) {
+    doClickJumpPageEvent(pageContext, configure, eventParams);
+  } else {
+    doClickCustomEvent(pageContext, configure, clickEventFunObj, eventParams);
+  }
+}
+function getEventByEventName(pageContext, eventObj) {
+  const eventsObj = pageContext.customEvents;
+  if (eventsObj && eventObj) {
+    let key = "";
+    if (typeof eventObj === "object") {
+      key = eventObj.componentUuid + "_" + eventObj.name;
+    } else {
+      key = eventObj;
+    }
+    return eventsObj[key];
+  }
+}
+function getEventFuncByType(pageContext, events, eventType) {
+  if (events && eventType) {
+    const eventArr = events.filter((item) => item.name === eventType);
+    if (eventArr && eventArr.length > 0) {
+      const event = eventArr[0];
+      if (event.isStandard) {
+        return standardEvent.standardEvents[event.eventName];
+      } else {
+        return getEventByEventName(pageContext, event);
+      }
+    }
+  }
+}
+function getEventNameByType(events, eventType) {
+  if (events && eventType) {
+    const eventArr = events.filter((item) => item.name === eventType);
+    if (eventArr && eventArr.length > 0) {
+      const event = eventArr[0];
+      return event.eventName;
+    }
+  }
+}
+function getClickEventFuncByType(pageContext, events, eventType) {
+  if (events && eventType) {
+    const eventArr = events.filter((item) => item.name === eventType);
+    if (eventArr && eventArr.length > 0) {
+      const event = eventArr[0];
+      if (event.isStandard) {
+        return { func: standardEvent.standardEvents[event.eventName], isStandard: true, event };
+      } else {
+        return {
+          func: getEventByEventName(pageContext, event),
+          isStandard: false,
+          event
+        };
+      }
+    }
+  }
+}
+function callItemEvent(pageContext, configureObj, eventFun, eventParams, otherParams) {
+  if (!eventFun) {
+    return;
+  }
+  if (!eventParams) {
+    eventParams = {
+      pageContext,
+      configureObj
+      // 组件配置信息，包含如：跳转页面配置、判重配置等
+    };
+  }
+  if (otherParams && eventParams) {
+    for (const key in otherParams) {
+      eventParams[key] = otherParams[key];
+    }
+  }
+  return eventFun.apply(eventFun, [eventParams]);
+}
+function transferToFunction(customEvents) {
+  const eventsObj = {};
+  customEvents.forEach((event) => {
+    if (!event.isStandard && event.jsContent) {
+      if (event.name === "customFunc") {
+        let newFunc = null;
+        if (event.funcParam) {
+          const args = event.funcParam.split(",");
+          newFunc = new Function(args, event.jsContent);
+        } else {
+          newFunc = new Function(event.jsContent);
+        }
+        eventsObj[event.eventName] = newFunc;
+      } else {
+        let key = event.componentUuid + "_";
+        key += event.name;
+        eventsObj[key] = new Function("params", event.jsContent);
+      }
+    }
+  });
+  return eventsObj;
+}
+function canExecuteButton(params) {
+  const pageContext = params.pageContext;
+  const configureObj = params.configureObj;
+  const isListButton = isListPage(pageContext);
+  let entities = [];
+  if (isListButton) {
+    if (pageContext.editData) {
+      entities.push(pageContext.editData);
+    } else {
+      entities = params.selections;
+    }
+  } else {
+    const dataModel = pageContext.entity.data;
+    entities.push(dataModel);
+  }
+  const executableDataSetting = configureObj.props.base.condition;
+  return new Promise((resolve, reject) => {
+    if (executableDataSetting === void 0 || executableDataSetting === "" || entities === void 0 || entities.length === 0) {
+      resolve({
+        canExecute: true
+      });
+    } else {
+      const contextParameter = pageContext.entity.context;
+      const additionalParamMap = standardEvent.getAdditionalParamMap(pageContext);
+      const isSql = true;
+      const tableName = pageContext.tableName;
+      let isCanExecute = true;
+      let failMessage;
+      let failEntity;
+      for (let i = 0; i < entities.length; i++) {
+        const entity = entities[i];
+        for (let n = 0; n < executableDataSetting.length; n++) {
+          const conditionSetting = executableDataSetting[n];
+          const message = conditionSetting.toolTips;
+          const conditionList = conditionSetting.conditionList;
+          const canExecute = util.analysisCondition(
+            conditionList,
+            entity,
+            additionalParamMap,
+            contextParameter,
+            isSql,
+            tableName,
+            null,
+            pageContext
+          );
+          if (!canExecute) {
+            isCanExecute = false;
+            failMessage = message;
+            failEntity = entity;
+            break;
+          }
+        }
+      }
+      if (!isCanExecute) {
+        if (failMessage) {
+          index.ElMessage({
+            showClose: true,
+            type: "warning",
+            message: failMessage
+          });
+        }
+        resolve({
+          canExecute: false,
+          message: failMessage,
+          failEntity
+        });
+      } else {
+        resolve({
+          canExecute: true
+        });
+      }
+    }
+  });
+}
+function setTableEvents(options, tableEvents, pageContext, configureObj) {
+  if (tableEvents) {
+    addTableEvent("loadBeforeSend", loadBeforeSend({ pageContext, configureObj }), options);
+    addTableEvent("beforeRequest", beforeRequest({ pageContext, configureObj }), options);
+    addTableEvent("gridDataLoaded", gridDataLoaded({ pageContext, configureObj }), options);
+    addTableEvent("gridComplete", gridComplete({ pageContext, configureObj }), options);
+    addTableEvent("resizeHeight", resizeTableHeight({ pageContext, configureObj }), options);
+    if (!options["lineEditOptions"]) {
+      options["lineEditOptions"] = {};
+    }
+    addTableEvent(
+      "beforeInsertRow",
+      gridBeforeInsertRow({ pageContext, configureObj }),
+      options["lineEditOptions"]
+    );
+    addTableEvent(
+      "afterInsertRow",
+      gridAfterInsertRow({ pageContext, configureObj }),
+      options["lineEditOptions"]
+    );
+    addTableEvent(
+      "beforeDelete",
+      gridBeforeRemoveRow({ pageContext, configureObj }),
+      options["lineEditOptions"]
+    );
+    addTableEvent(
+      "afterDelete",
+      gridAfterRemoveRow({ pageContext, configureObj }),
+      options["lineEditOptions"]
+    );
+    addTableEvent(
+      "beforeEdit",
+      gridBeforeEdit({ pageContext, configureObj }),
+      options["lineEditOptions"]
+    );
+    addTableEvent(
+      "beforeRestore",
+      beforeRestore({ pageContext, configureObj }),
+      options["lineEditOptions"]
+    );
+    addTableEvent(
+      "beforeRestoreValidate",
+      beforeRestoreValidate({ pageContext, configureObj }),
+      options["lineEditOptions"]
+    );
+  }
+}
+function addTableEvent(gridEventType, eventFunc, options) {
+  if (eventFunc) {
+    options[gridEventType] = eventFunc;
+  }
+}
+function loadBeforeSend(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "beforeListLoad", params);
+}
+function beforeRequest(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "beforeRequest", params);
+}
+function gridDataLoaded(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "onListLoad", params);
+}
+function gridComplete(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "afterListLoad", params);
+}
+function resizeTableHeight(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "resizeTableHeight", params);
+}
+function beforeRestoreValidate(params) {
+  return getHandleEvent(
+    null,
+    params.pageContext,
+    params.configureObj,
+    "beforeRestoreValidate",
+    params
+  );
+}
+function beforeRestore(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "beforeRestore", params);
+}
+function gridBeforeEdit(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "beforeEdit", params);
+}
+function gridBeforeInsertRow(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "beforeAddRow", params);
+}
+function gridAfterInsertRow(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "afterAddRow", params);
+}
+function gridBeforeRemoveRow(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "beforeRemoveRow", params);
+}
+function gridAfterRemoveRow(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "afterRemoveRow", params);
+}
+function gridSelectRecord(pageContext, configureObj, params) {
+  return handleEvent(null, pageContext, configureObj, "select", params);
+}
+function gridSelectAllRecords(pageContext, configureObj, params) {
+  return handleEvent(null, pageContext, configureObj, "select-all", params);
+}
+function gridSelectionChange(pageContext, configureObj, params) {
+  return handleEvent(null, pageContext, configureObj, "selection-change", params);
+}
+function cellClick(pageContext, configureObj, params) {
+  return handleEvent(null, pageContext, configureObj, "cell-click", params);
+}
+function cellDblClick(pageContext, configureObj, params) {
+  return handleEvent(null, pageContext, configureObj, "cell-dblclick", params);
+}
+function rowClick(pageContext, configureObj, params) {
+  return handleEvent(null, pageContext, configureObj, "row-click", params);
+}
+function rowDblClick(pageContext, configureObj, params) {
+  return handleEvent(null, pageContext, configureObj, "row-dblclick", params);
+}
+function headerClick(pageContext, configureObj, params) {
+  return handleEvent(null, pageContext, configureObj, "header-click", params);
+}
+function fileUploadBeforeUpload(params) {
+  return getHandleEvent(null, params.pageContext, params.configureObj, "before-upload", params);
+}
+exports.canExecuteButton = canExecuteButton;
+exports.cellClick = cellClick;
+exports.cellDblClick = cellDblClick;
+exports.doAfterClickEvent = doAfterClickEvent;
+exports.doBeforeClickEvent = doBeforeClickEvent;
+exports.fileUploadBeforeUpload = fileUploadBeforeUpload;
+exports.getClickEventFuncByType = getClickEventFuncByType;
+exports.getCustomFunc = getCustomFunc;
+exports.getEventFuncByType = getEventFuncByType;
+exports.getEventNameByType = getEventNameByType;
+exports.getHandleEvent = getHandleEvent;
+exports.getTableUuid = getTableUuid;
+exports.gridSelectAllRecords = gridSelectAllRecords;
+exports.gridSelectRecord = gridSelectRecord;
+exports.gridSelectionChange = gridSelectionChange;
+exports.handleEvent = handleEvent;
+exports.headerClick = headerClick;
+exports.initPageEvents = initPageEvents;
+exports.removeCustomFuncFromWindow = removeCustomFuncFromWindow;
+exports.rowClick = rowClick;
+exports.rowDblClick = rowDblClick;
+exports.setTableEvents = setTableEvents;

package/dist/lib/components/runtime/utils/events/print-label.d.ts

@@ -0,0 +1,5 @@
+export declare function printLabel(params: any, templateUuid: string): void;
+declare const _default: {
+    printLabel: typeof printLabel;
+};
+export default _default;