super-page-runtime 0.0.2-tmp7 → 1.0.1

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

@@ -0,0 +1,526 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const commonUtil_js = require("D:/MyToolbox/ws-idea/agile-builder/dev-platform/agile-builder-super-design/node_modules/.pnpm/agilebuilder-ui@1.0.13_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 index_mjs = require("D:/MyToolbox/ws-idea/agile-builder/dev-platform/agile-builder-super-design/node_modules/.pnpm/element-plus@2.6.2_vue@3.4.21/node_modules/element-plus/es/index.mjs");
+const util_js = require("D:/MyToolbox/ws-idea/agile-builder/dev-platform/agile-builder-super-design/node_modules/.pnpm/agilebuilder-ui@1.0.13_vue@3.4.21/node_modules/agilebuilder-ui/src/utils/util.js");
+const commonUtil = require("../common-util.js");
+const eventBus = require("../eventBus.js");
+function initPageEvents(pageDesign, pageContext) {
+  if (pageDesign && pageDesign.customEvents) {
+    pageContext.customEvents = transferToFunction(pageDesign.customEvents);
+  }
+}
+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.events;
+  const componentType = configure.name;
+  let eventFun;
+  if (eventType && eventType === "click" && componentType === "button-detail") {
+    const tableUuid = configure.props.base.tableUuid ? configure.props.base.tableUuid : pageContext.tableUuids && pageContext.tableUuids.length > 0 ? pageContext.tableUuids[0] : null;
+    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["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 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;
+  }
+  params["pageContext"] = pageContext;
+  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.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_js.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.events;
+  let isEnableRequired;
+  const clickEventFunObj = getClickEventFuncByType(pageContext, events, "click");
+  if (clickEventFunObj) {
+    const isStandardEvent = clickEventFunObj.isStandard;
+    const event = clickEventFunObj.event;
+    const isNotNeedValidate = isNotNeedValidateRequired(isStandardEvent, event);
+    if (isNotNeedValidate) {
+      isEnableRequired = false;
+    }
+  }
+  validatorUtil.validateDataModelFunc(pageContext, configure, isEnableRequired).then(() => {
+    const beforeClickResult = doBeforeClickEvent(pageContext, configure, eventParams);
+    if (!beforeClickResult) {
+      return;
+    }
+    if (commonUtil_js.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.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_js.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.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.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, eventName) {
+  const eventsObj = pageContext.customEvents;
+  if (eventsObj && eventsObj[eventName]) {
+    return eventsObj[eventName];
+  }
+}
+function getEventFuncByType(pageContext, events, eventType) {
+  if (events && eventType) {
+    const eventArr = events.filter((item) => item.name === eventType && item.eventName);
+    if (eventArr && eventArr.length > 0) {
+      const event = eventArr[0];
+      if (event.isStandard) {
+        return standardEvent.standardEvents[event.eventName];
+      } else {
+        return getEventByEventName(pageContext, event.eventName);
+      }
+    }
+  }
+}
+function getClickEventFuncByType(pageContext, events, eventType) {
+  if (events && eventType) {
+    const eventArr = events.filter((item) => item.name === eventType && item.eventName);
+    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.eventName),
+          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(eventParams);
+}
+function transferToFunction(customEvents) {
+  const eventsObj = {};
+  customEvents.forEach((event) => {
+    if (event.jsContent) {
+      eventsObj[event.eventName] = new Function("params", event.jsContent);
+      if (event.name === "customFunc") {
+        if (event.funcParam) {
+          window["$page_" + event.eventName] = new Function(event.funcParam, event.jsContent);
+        } else {
+          window["$page_" + event.eventName] = new Function(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 = pageContext.entity.request;
+      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_js.analysisCondition(
+            conditionList,
+            entity,
+            additionalParamMap,
+            contextParameter,
+            isSql,
+            tableName,
+            null
+          );
+          if (!canExecute) {
+            isCanExecute = false;
+            failMessage = message;
+            failEntity = entity;
+            break;
+          }
+        }
+      }
+      if (!isCanExecute) {
+        if (failMessage) {
+          index_mjs.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);
+}
+exports.canExecuteButton = canExecuteButton;
+exports.cellClick = cellClick;
+exports.cellDblClick = cellDblClick;
+exports.doAfterClickEvent = doAfterClickEvent;
+exports.doBeforeClickEvent = doBeforeClickEvent;
+exports.getClickEventFuncByType = getClickEventFuncByType;
+exports.getEventFuncByType = getEventFuncByType;
+exports.getHandleEvent = getHandleEvent;
+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/standard-event.d.ts

@@ -0,0 +1,61 @@
+export declare const standardEvents: {
+    save: (params: any) => Promise<unknown>;
+    saveList: (params: any) => Promise<unknown>;
+    exportForm: (params: any) => void;
+    exportPDF: (params: any) => void;
+    submit: (params: any) => Promise<unknown>;
+    submitList: (params: any) => Promise<unknown>;
+    agree: (params: any) => Promise<unknown>;
+    agreeList: (params: any) => Promise<unknown>;
+    disagree: (params: any) => Promise<unknown>;
+    disagreeList: (params: any) => Promise<unknown>;
+    back: (params: any) => void;
+    delete: (params: any) => Promise<unknown>;
+    downloadTemplate: (params: any) => void;
+    import: (params: any) => void;
+    export: (params: any) => Promise<unknown>;
+    search: (params: any) => void;
+    workflowSave: (params: any) => Promise<unknown>;
+    submitProcess: (params: any) => Promise<unknown>;
+    submitTask: (params: any) => Promise<unknown>;
+    approve: (params: any) => Promise<unknown>;
+    refuse: (params: any) => Promise<unknown>;
+    readed: (params: any) => Promise<unknown>;
+    agreement: (params: any) => Promise<unknown>;
+    oppose: (params: any) => Promise<unknown>;
+    kiken: (params: any) => Promise<unknown>;
+    assign: (params: any) => void;
+    copyTask: (params: any) => void;
+    addSigner: (params: any) => void;
+    drawTask: (params: any) => Promise<unknown>;
+    abandonReceive: (params: any) => Promise<unknown>;
+    returnToPreviousTask: (params: any) => Promise<unknown>;
+    endInstance: (params: any) => Promise<unknown>;
+    returnTaskTo: (params: any) => void;
+    removeSigner: (params: any) => void;
+    retrieveTask: (params: any) => Promise<unknown>;
+    viewDetail: (params: any) => void;
+    lineEditCreate: (params: any) => void;
+};
+export declare function exportFormReport(pageContext: any, configureObj: any, templateFile: any, isPdf: any): void;
+export declare function getSaveFormRequest(pageContext: any, configureObj: any, url: any, isUnControlVersion: any, mainDefaultValueColumns: any, dynamicColumnInfo: any): any;
+/**
+ * 按钮执行后页面处理方式：刷新、关闭弹框等等
+ * @param pageContext
+ * @param configureObj
+ * @param data
+ * @param successTip
+ * @param isListButton
+ */
+export declare function dealAfterOperate(pageContext: any, configureObj: any, data: any, successTip: any, isListButton?: boolean): void;
+export declare function doImportFinally(params: any, fileObj: any): void;
+export declare function judgeDataNumber(buttonConfigureObj: any, ids: any): boolean;
+export declare function dealCompleteTaskParam(commonEntity: any, isInit: any, pageContext: any, params?: any, operationResult?: any): boolean;
+export declare function doAssign(params: any, selectNodeInfo: any): void;
+export declare function doAddSigner(params: any, selectNodeInfo: any): void;
+export declare function doCreateCopyTask(params: any, selectNodeInfo: any): void;
+export declare function getTaskInformitions(params: any): any;
+export declare function doReturnTaskTo(params: any, selectTaskNode: any): void;
+export declare function getRemoveSigner(params: any): any;
+export declare function doRemoveSigners(params: any, selectRemoveTasks: any): void;
+export declare function isVisibleWorkflowButton(standardEventName: any, buttonInfo: any, completeTaskParam: any): boolean;