super-page-runtime 0.0.1-tmp2

package/lib/src/utils/events/standard-event.js

@@ -0,0 +1,1623 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const commonUtil = require("../common-util.js");
+const http = require("agilebuilder-ui/src/utils/request");
+const util = require("agilebuilder-ui/src/utils/util");
+const elementPlus = require("element-plus");
+const vueRouter = require("vue-router");
+const auth = require("agilebuilder-ui/src/utils/auth");
+const globalRefs = require("../global-refs.js");
+const axios = require("axios");
+const eventUtil = require("./event-util.js");
+const storeUtil = require("../store-util.js");
+const standardEvents = {
+  // 表单标准事件保存save
+  save: function(params) {
+    console.log("表单标准事件保存save--params=", params);
+    return saveFunc(params, false);
+  },
+  // 列表标准事件保存saveList
+  saveList: function(params) {
+    console.log("列表标准事件保存saveList--params=", params);
+    return saveFunc(params, true);
+  },
+  // 表单标准事件导出报告exportForm
+  exportForm: function(params) {
+    console.log("表单标准事件导出报告exportForm--params=", params);
+    const pageContext = params.pageContext;
+    const pagCode = pageContext.code;
+    const eventPageInfo = pagCode + "_";
+    window["$eventBus"].$emit(eventPageInfo + "export-form-report", params);
+  },
+  // 表单标准事件导出报告exportPDF
+  exportPDF: function(params) {
+    console.log("表单标准事件导出报告exportPDF--params=", params);
+    const pageContext = params.pageContext;
+    pageContext.code;
+  },
+  // 表单标准事件提交submit
+  submit: function(params) {
+    console.log("表单标准事件提交submit--params=", params);
+    return submitForm(params, false, "submit", "/dsc/commons/submits");
+  },
+  // 列表标准事件提交submitList
+  submitList: function(params) {
+    console.log("列表标准事件提交submitList--params=", params);
+    return submitForm(params, true, "submit", "/dsc/commons/batch-submits");
+  },
+  // 表单标准事件同意agree
+  agree: function(params) {
+    console.log("表单标准事件同意agree--params=", params);
+    return submitForm(params, false, "agree", "/dsc/commons/approves");
+  },
+  // 列表标准事件同意agreeList
+  agreeList: function(params) {
+    console.log("列表标准事件同意agreeList--params=", params);
+    return submitForm(params, true, "agree", "/dsc/commons/batch-approves");
+  },
+  // 表单标准事件不同意disagree
+  disagree: function(params) {
+    console.log("表单标准事件不同意disagree--params=", params);
+    return submitForm(params, false, "disagree", "/dsc/commons/refuses");
+  },
+  // 列表标准事件不同意disagreeList
+  disagreeList: function(params) {
+    console.log("列表标准事件不同意disagreeList--params=", params);
+    return submitForm(params, true, "disagree", "/dsc/commons/batch-refuses");
+  },
+  // TODO: 待页面跳转功能完善后再实现
+  back: function(params) {
+    console.log("表单标准事件返回back--params=", params);
+  },
+  // 列表标准事件删除delete
+  delete: function(params) {
+    console.log("列表标准事件删除delete--params=", params);
+    return deleteFunc(params);
+  },
+  // 列表标准事件下载导入模板downloadTemplate
+  downloadTemplate: function(params) {
+    console.log("列表标准事件下载导入模板downloadTemplate--params=", params);
+    downloadTemplateFunc(params);
+  },
+  // 列表标准事件 导入import
+  import: function(params) {
+    console.log("列表标准事件 导入import--params=", params);
+    const pageContext = params.pageContext;
+    const pagCode = pageContext.code;
+    const eventPageInfo = pagCode + "_";
+    window["$eventBus"].$emit(eventPageInfo + "import-file", params);
+  },
+  // 列表标准事件 导出export
+  export: function(params) {
+    console.log("列表标准事件 导出export--params=", params);
+    return exportFunc(params);
+  },
+  // 列表标准事件 查询search
+  search: function(params) {
+    console.log("列表标准事件 查询search--params=", params);
+    const pageContext = params.pageContext;
+    const tableUuid = params.tableUuid;
+    const gridRef = globalRefs.getComponentRef(pageContext, tableUuid);
+    gridRef.refresh();
+  },
+  // 流程表单标准事件 暂存workflowSave
+  workflowSave: function(params) {
+    console.log("流程表单标准事件 暂存workflowSave--params=", params);
+    return workflowSaveFunc(params);
+  },
+  // 流程表单标准事件 提交流程submitProcess
+  submitProcess: function(params) {
+    console.log("流程表单标准事件 提交流程submitProcess--params=", params);
+    return submitProcessFunc(params);
+  },
+  // 流程表单标准事件 提交任务submitTask
+  submitTask: function(params) {
+    console.log("流程表单标准事件 提交任务submitTask--params=", params);
+    return completeTaskFunc(params, "SUBMIT");
+  },
+  // 流程表单标准事件 同意approve
+  approve: function(params) {
+    console.log("流程表单标准事件 同意approve--params=", params);
+    return completeTaskFunc(params, "APPROVE");
+  },
+  // 流程表单标准事件 不同意refuse
+  refuse: function(params) {
+    console.log("流程表单标准事件 不同意refuse--params=", params);
+    return completeTaskFunc(params, "REFUSE");
+  },
+  // 流程表单标准事件 已阅readed
+  readed: function(params) {
+    console.log("流程表单标准事件 已阅readed--params=", params);
+    return completeTaskFunc(params, "READED");
+  },
+  // 流程表单标准事件 赞成agreemen
+  agreement: function(params) {
+    console.log("流程表单标准事件 赞成agreement--params=", params);
+    return completeTaskFunc(params, "AGREEMENT");
+  },
+  // 流程表单标准事件 反对oppose
+  oppose: function(params) {
+    console.log("流程表单标准事件 反对oppose--params=", params);
+    return completeTaskFunc(params, "OPPOSE");
+  },
+  // 流程表单标准事件 弃权kiken
+  kiken: function(params) {
+    console.log("流程表单标准事件 弃权kiken--params=", params);
+    return completeTaskFunc(params, "KIKEN");
+  },
+  // 流程表单标准事件 指派assign
+  assign: function(params) {
+    console.log("流程表单标准事件 指派assign--params=", params);
+    return assignTask(params);
+  },
+  // 流程表单标准事件 抄送copyTask
+  copyTask: function(params) {
+    console.log("流程表单标准事件 抄送copyTask--params=", params);
+    return createCopyTask(params);
+  },
+  // 流程表单标准事件 加签addSigner
+  addSigner: function(params) {
+    console.log("流程表单标准事件 加签addSigner--params=", params);
+    return addSignerFunc(params);
+  },
+  // 流程表单标准事件 领取drawTask
+  drawTask: function(params) {
+    console.log("流程表单标准事件 领取drawTask--params=", params);
+    return drawTaskFunc(params);
+  },
+  // 放弃领取abandonReceive
+  abandonReceive: function(params) {
+    console.log("流程表单标准事件 放弃领取abandonReceive--params=", params);
+    return abandonReceiveFunc(params);
+  },
+  // 流程表单标准事件 驳回returnToPreviousTask
+  returnToPreviousTask: function(params) {
+    console.log("流程表单标准事件 驳回returnToPreviousTask--params=", params);
+    return returnToPreviousTaskFunc(params);
+  },
+  // 流程表单标准事件 强制结束endInstance
+  endInstance: function(params) {
+    console.log("流程表单标准事件 强制结束endInstance--params=", params);
+    return endInstanceFunc(params);
+  },
+  // 流程表单标准事件 退回returnTaskTo
+  returnTaskTo: function(params) {
+    console.log("流程表单标准事件 退回returnTaskTo--params=", params);
+    return returnTaskToFunc(params);
+  },
+  // 流程表单标准事件 减签removeSigner
+  removeSigner: function(params) {
+    console.log("流程表单标准事件 减签removeSigner--params=", params);
+    return removeSignerfunc(params);
+  },
+  // 流程表单标准事件 取回retrieveTask
+  retrieveTask: function(params) {
+    console.log("流程表单标准事件 取回retrieveTask--params=", params);
+    return retrieveTaskFunc(params);
+  },
+  viewDetail: function(params) {
+  },
+  lineEditCreate: function(params) {
+    console.log("列表行编辑 新建lineEditCreate--params=", params);
+    return lineEditCreateFunc(params);
+  }
+};
+function exportFormReport(pageContext, configureObj, templateFile, isPdf) {
+  const templateUUID = templateFile.templateUUID;
+  const fileName = templateFile.templateShowPath;
+  const system = pageContext.system;
+  const logSetting = configureObj.props.logSetting;
+  const additionalParamMap = pageContext.entity.request;
+  const isWorkflowForm = pageContext.workflowCode ? true : false;
+  const beanName = pageContext.beanName;
+  const button = configureObj.props.base;
+  const tableName = configureObj.tableName;
+  const viewModels = pageContext.entity.data;
+  const isPermission = button.isPermission === void 0 || button.isPermission === "true" || button.isPermission;
+  const param = {
+    entity: viewModels,
+    fileName: templateUUID,
+    // uuid
+    showName: fileName,
+    // 下载的文件名称
+    beanName,
+    isWorkflowForm,
+    // 是否是流程表单
+    functionCode: button.functionCode,
+    tableName,
+    isPermission: isPermission + "",
+    systemCode: system.code,
+    tableNames: pageContext.tableNames
+  };
+  if (logSetting) {
+    param["logSettingText"] = logSetting;
+  }
+  if (additionalParamMap) {
+    param["additionalParamMap"] = additionalParamMap;
+  }
+  let exportResult;
+  if (isPdf) {
+    exportResult = exportFormPdf(fileName, system, param);
+  } else {
+    exportResult = exportFormReportSuccess(fileName, system, param);
+  }
+  if (exportResult) {
+    exportResult.then(() => {
+      eventUtil.doAfterClickEvent(pageContext, configureObj);
+    });
+  }
+}
+function exportFormReportSuccess(fileName, system, param) {
+  return new Promise((resolve, reject) => {
+    const baseUrl = commonUtil.getBaseUrl(system);
+    const path = baseUrl + "/dsc/commons/export-reports";
+    axios.defaults.headers.common.Authorization = auth.getToken();
+    const request = axios.post(path, param, {
+      headers: {
+        "content-type": "application/x-www-form-urlencoded"
+      },
+      responseType: "blob"
+    });
+    request.then((response) => {
+      const blob = new Blob([response.data]);
+      let fileNameTwo = "报告.xlsx";
+      if (fileName) {
+        fileNameTwo = fileName;
+      }
+      const elink = document.createElement("a");
+      elink.download = fileNameTwo;
+      elink.style.display = "none";
+      elink.target = "_blank";
+      elink.href = URL.createObjectURL(blob);
+      document.body.appendChild(elink);
+      elink.click();
+      URL.revokeObjectURL(elink.href);
+      document.body.removeChild(elink);
+      resolve(true);
+    }).catch((error) => {
+      reject(error);
+    });
+  });
+}
+function exportFormPdf(fileName, system, param) {
+  return new Promise((resolve, reject) => {
+    const baseUrl = commonUtil.getBaseUrl(system);
+    const path = baseUrl + "/dsc/commons/export-pdf";
+    axios.defaults.headers.common.Authorization = auth.getToken();
+    const request = axios.post(path, param, {
+      headers: {
+        "content-type": "application/x-www-form-urlencoded"
+      },
+      responseType: "blob"
+    });
+    request.then((response) => {
+      const blob = new Blob([response.data]);
+      const elink = document.createElement("a");
+      elink.download = fileName.substring(0, fileName.lastIndexOf(".")) + ".pdf";
+      elink.style.display = "none";
+      elink.target = "_blank";
+      elink.href = URL.createObjectURL(blob);
+      document.body.appendChild(elink);
+      elink.click();
+      URL.revokeObjectURL(elink.href);
+      document.body.removeChild(elink);
+      resolve(true);
+    }).catch((error) => {
+      reject(error);
+    });
+  });
+}
+function saveFunc(params, isListButton) {
+  return new Promise((resolve, reject) => {
+    const pageContext = params.pageContext;
+    const configureObj = params.configureObj;
+    const mainDefaultValueColumns = params.mainDefaultValueColumns;
+    const dynamicColumnInfo = params.dynamicColumnInfo;
+    const successOperation = configureObj.props.base.successOperation;
+    let isUnControlVersion = false;
+    if (successOperation && successOperation === "noOperation") {
+      isUnControlVersion = true;
+    }
+    const request = getSaveFormRequest(
+      pageContext,
+      configureObj,
+      "/dsc/commons",
+      isUnControlVersion,
+      mainDefaultValueColumns,
+      dynamicColumnInfo
+    );
+    if (request) {
+      request.then((data) => {
+        dealAfterOperate(
+          pageContext,
+          configureObj,
+          data,
+          "superPageRuntimeMessage.successfulSave",
+          isListButton
+        );
+        resolve(data);
+      }).catch((error) => {
+        reject(error);
+      });
+    } else {
+      reject("保存时request不存在");
+    }
+  });
+}
+function getCommonFormRequestParam(pageContext, configureObj, isUnControlVersion, mainDefaultValueColumns, dynamicColumnInfo, ids) {
+  const isWorkflow = pageContext.workflowCode ? true : false;
+  const system = pageContext.system;
+  const isPermission = configureObj.props.base.isPermission === void 0 || configureObj.props.base.isPermission === "true" || configureObj.props.base.isPermission;
+  const param = {
+    entity: pageContext.entity.data,
+    pageModel: pageContext.entity.page,
+    tableName: pageContext.tableName,
+    formNoRuleCode: pageContext.formNoRuleCode,
+    isWorkflowEntity: isWorkflow,
+    functionCode: configureObj.props.base.functionCode,
+    isPermission: isPermission + "",
+    tableNames: pageContext.tableNames
+  };
+  if (ids) {
+    param["ids"] = ids;
+  }
+  if (pageContext.judgeHeavyList) {
+    if (commonUtil.isArrayFn(pageContext.judgeHeavyList)) {
+      param["judgeHeavyList"] = JSON.stringify(pageContext.judgeHeavyList);
+    } else {
+      param["judgeHeavyList"] = pageContext.judgeHeavyList;
+    }
+  }
+  const conversionCodes = configureObj.props.base.conversionCodes;
+  if (conversionCodes) {
+    if (commonUtil.isArrayFn(conversionCodes)) {
+      param["dataConversionRule"] = conversionCodes.join(",");
+    } else if (typeof conversionCodes === "string") {
+      param["dataConversionRule"] = conversionCodes;
+    }
+  }
+  const autoSetValueData = configureObj.props.base.setValueList;
+  if (autoSetValueData) {
+    if (commonUtil.isArrayFn(autoSetValueData)) {
+      param["autoSetValueData"] = autoSetValueData.join(",");
+    } else if (typeof autoSetValueData === "string") {
+      param["autoSetValueData"] = autoSetValueData;
+    }
+  }
+  const logSetting = configureObj.props.logSetting;
+  if (logSetting) {
+    param["logSettingText"] = logSetting;
+  }
+  if (!param["systemCode"]) {
+    param["systemCode"] = system.code;
+  }
+  const beanName = configureObj.props.base.beanName;
+  if (beanName) {
+    param["beanName"] = beanName;
+  }
+  if (dynamicColumnInfo) {
+    param["dynamicColumnInfo"] = dynamicColumnInfo;
+  }
+  if (mainDefaultValueColumns) {
+    param["mainDefaultValueColumns"] = mainDefaultValueColumns;
+  }
+  const additionalParamMap = pageContext.entity.request;
+  if (additionalParamMap) {
+    param["additionalParamMap"] = additionalParamMap;
+  }
+  if (isUnControlVersion !== void 0) {
+    param["unControlVersion"] = isUnControlVersion;
+  }
+  return param;
+}
+function getSaveFormRequest(pageContext, configureObj, url, isUnControlVersion, mainDefaultValueColumns, dynamicColumnInfo) {
+  const system = pageContext.system;
+  const param = getCommonFormRequestParam(
+    pageContext,
+    configureObj,
+    isUnControlVersion,
+    mainDefaultValueColumns,
+    dynamicColumnInfo,
+    null
+  );
+  return getSaveFormRequestByParam(system, param, url, pageContext.entity.data);
+}
+function getSaveFormRequestByParam(system, param, url, formData) {
+  const baseUrl = commonUtil.getBaseUrl(system);
+  let path = baseUrl + url;
+  path = commonUtil.getRealRestApiPath(path, system);
+  let request;
+  if (formData && (formData.id || formData.ID)) {
+    request = http.put(path, param);
+  } else {
+    request = http.post(path, param);
+  }
+  return request;
+}
+function dealAfterOperate(pageContext, configureObj, data, successTip, isListButton) {
+  if (isListButton === void 0) {
+    isListButton = configureObj.props.base.tableUuid ? true : false;
+  }
+  if (isListButton) {
+    dealAfterWithList(pageContext, configureObj, data, successTip);
+  } else {
+    dealAfterWithForm(pageContext, configureObj, data, successTip);
+  }
+}
+function dealAfterWithForm(pageContext, configureObj, data, successTip) {
+  if (data) {
+    const commonEntity = data;
+    let dataModel;
+    if (commonEntity.entity) {
+      dataModel = commonEntity.entity;
+    }
+    if (commonEntity.formNo) {
+      pageContext.initFormNo = commonEntity.formNo;
+    }
+    afterSuccessOperateInForm(pageContext, configureObj, dataModel);
+  }
+  if (successTip) {
+    elementPlus.ElMessage({
+      message: util.getI18n().t(successTip),
+      type: "success",
+      showClose: true
+    });
+  }
+}
+function afterSuccessOperateInForm(pageContext, configureObj, dataModel) {
+  let successOperation = configureObj.props.base.successOperation;
+  const isNeedValueMapping = configureObj.props.base.isNeedValueMapping;
+  console.log(
+    "afterSuccessOperateInForm---successOperation=-",
+    successOperation,
+    dataModel,
+    isNeedValueMapping
+  );
+  pageContext.workflowCode ? true : false;
+  if (!successOperation || successOperation === "" || successOperation === null) {
+    successOperation = "refresh";
+  }
+  if (successOperation === "noOperation") {
+    if (dataModel) {
+      pageContext.entity.data = dataModel;
+    }
+  } else if (successOperation === "refresh") {
+    if (dataModel && (dataModel.id || dataModel.ID)) {
+      const dataIdSessio = dataModel.ID == null ? dataModel.id : dataModel.ID;
+      const route = vueRouter.useRoute();
+      if (route.query._t_) {
+        auth.setSessionCache(route.query._t_ + "_id", dataIdSessio);
+      }
+    }
+  } else if (successOperation === "closeWindow" || successOperation === "closeWindowAndRefresh") {
+    console.log("afterSuccessOperateInForm--successOperation=--", successOperation);
+  }
+}
+function dealAfterWithList(pageContext, configureObj, row, successTip) {
+  let successOperation = configureObj.props.base.successOperation;
+  configureObj.props.base.isNeedValueMapping;
+  const tableUuid = configureObj.props.base.tableUuid;
+  if (!successOperation) {
+    successOperation = "refresh";
+  }
+  console.log("dealAfterWithList--");
+  if (successOperation === "refresh") {
+    if (tableUuid) {
+      const gridRef = globalRefs.getComponentRef(pageContext, tableUuid);
+      gridRef.refresh();
+    } else {
+      console.error("tableUuid is empty");
+    }
+  }
+  if (successTip) {
+    elementPlus.ElMessage({
+      message: util.getI18n().t(successTip),
+      type: "success",
+      showClose: true
+    });
+  }
+}
+function submitForm(params, isListButton, eventName, url) {
+  return new Promise((resolve, reject) => {
+    const pageContext = params.pageContext;
+    const configureObj = params.configureObj;
+    const mainDefaultValueColumns = params.mainDefaultValueColumns;
+    const dynamicColumnInfo = params.dynamicColumnInfo;
+    const ids = params.ids;
+    const successOperation = configureObj.props.base.successOperation;
+    let isUnControlVersion = false;
+    if (successOperation && successOperation === "noOperation") {
+      isUnControlVersion = true;
+    }
+    const request = getSubmitFormRequest(
+      pageContext,
+      configureObj,
+      url,
+      isUnControlVersion,
+      mainDefaultValueColumns,
+      dynamicColumnInfo,
+      eventName,
+      ids
+    );
+    if (request) {
+      request.then((data) => {
+        dealAfterOperate(
+          pageContext,
+          configureObj,
+          data,
+          "superPageRuntimeMessage.successfulSave",
+          isListButton
+        );
+        resolve(data);
+      }).catch((error) => {
+        reject(error);
+      });
+    } else {
+      reject("request不存在");
+    }
+  });
+}
+function getSubmitFormRequest(pageContext, configureObj, url, isUnControlVersion, mainDefaultValueColumns, dynamicColumnInfo, eventName, ids) {
+  return new Promise((resolve, reject) => {
+    const buttonName = configureObj.props.base.title;
+    const operationI18nTip = "superPageRuntimeMessage.whetherToConfirm" + commonUtil.upperFirstCase(eventName);
+    elementPlus.ElMessageBox.confirm(
+      util.getI18n().t(operationI18nTip, { name: buttonName }),
+      util.getI18n().t("superPageRuntimeMessage.tips"),
+      {
+        confirmButtonText: util.getI18n().t("superPageRuntimeMessage.sure"),
+        cancelButtonText: util.getI18n().t("superPageRuntimeMessage.cancel"),
+        type: "warning"
+      }
+    ).then(() => {
+      const system = pageContext.system;
+      const param = getCommonFormRequestParam(
+        pageContext,
+        configureObj,
+        isUnControlVersion,
+        mainDefaultValueColumns,
+        dynamicColumnInfo,
+        ids
+      );
+      getSaveFormRequestByParam(system, param, url, pageContext.entity.data).then((result) => {
+        resolve(result);
+      }).catch((error) => {
+        reject(error);
+      });
+    }).catch(() => {
+      reject("点击了取消按钮");
+    });
+  });
+}
+function deleteFunc(params) {
+  return new Promise((resolve, reject) => {
+    const ids = params.ids;
+    if (!ids || ids.length === 0) {
+      elementPlus.ElMessage({
+        showClose: true,
+        type: "warning",
+        message: util.getI18n().t("superPageRuntimeMessage.pleaseSelectRecord")
+      });
+      return;
+    }
+    elementPlus.ElMessageBox.confirm(
+      util.getI18n().t("superPageRuntimeMessage.whetherToConfirmDeletion"),
+      util.getI18n().t("superPageRuntimeMessage.tips"),
+      {
+        confirmButtonText: util.getI18n().t("superPageRuntimeMessage.sure"),
+        cancelButtonText: util.getI18n().t("superPageRuntimeMessage.cancel"),
+        type: "warning"
+      }
+    ).then(() => {
+      const pageContext = params.pageContext;
+      const configureObj = params.configureObj;
+      const system = pageContext.entity.system;
+      const tableName = pageContext.tableName;
+      const configureBase = configureObj.props.base;
+      const baseUrl = commonUtil.getBaseUrl(system);
+      let path = baseUrl + "/dsc/commons/" + tableName;
+      path = commonUtil.getRealRestApiPath(path, system);
+      const isPermission = configureBase.isPermission === void 0 || configureBase.isPermission === "true" || configureBase.isPermission;
+      const isWorkflow = pageContext.workflowCode ? true : false;
+      const param = {
+        ids,
+        functionCode: configureBase.functionCode,
+        isPermission: isPermission + "",
+        systemCode: system.code,
+        isWorkflowEntity: isWorkflow,
+        tableNames: pageContext.tableNames
+      };
+      if (configureBase.beanName) {
+        param["beanName"] = configureBase.beanName;
+      }
+      const deleteLogicSetting = configureObj.props.deleteLogicSetting;
+      if (deleteLogicSetting) {
+        if (typeof deleteLogicSetting === "object") {
+          param["deleteLogicSetting"] = JSON.stringify(deleteLogicSetting);
+        } else if (typeof deleteLogicSetting === "string") {
+          param["deleteLogicSetting"] = deleteLogicSetting;
+        }
+      }
+      const logSetting = configureObj.props.logSetting;
+      if (logSetting) {
+        param["logSettingText"] = logSetting;
+      }
+      const isSafeDelete = configureObj.props.base.isSafeDelete;
+      if (isSafeDelete) {
+        param["isSafeDelete"] = isSafeDelete;
+      }
+      http.delete(path, {
+        data: param
+      }).then((data) => {
+        const gridRef = globalRefs.getComponentRef(pageContext, params.tableUuid);
+        if (gridRef) {
+          gridRef.isDeleteChange(true);
+          gridRef.clearSelections();
+        }
+        dealAfterOperate(
+          pageContext,
+          configureObj,
+          data,
+          "superPageRuntimeMessage.successfulDelete",
+          true
+        );
+        resolve(true);
+      }).catch((e) => {
+        reject(e);
+      });
+    }).catch(() => {
+      reject();
+    });
+  });
+}
+function downloadTemplateFunc(params) {
+  const pageContext = params.pageContext;
+  const configureObj = params.configureObj;
+  const configureBase = configureObj.props.base;
+  const templateFilesResult = commonUtil.packageTemplateFiles(configureBase.templateFiles);
+  let templateUUID;
+  let templateShowPath;
+  if (templateFilesResult && templateFilesResult.length > 0) {
+    templateUUID = templateFilesResult[0].templateUUID;
+    templateShowPath = templateFilesResult[0].templateShowPath;
+  }
+  const system = pageContext.system;
+  const showName = templateShowPath;
+  let param = "?1=1";
+  if (templateUUID && showName && templateUUID !== "undefined" && showName !== "undefined" && templateUUID !== "null" && showName !== "null") {
+    param += "&fileName=" + encodeURI(templateUUID) + "&showName=" + encodeURI(showName);
+  } else if (showName) {
+    param += "&showName=" + encodeURI(showName);
+  }
+  const logSetting = configureObj.props.logSetting;
+  if (logSetting && logSetting !== "") {
+    param += "&logSettingText=" + logSetting;
+  }
+  if (system && system.code) {
+    param += "&systemCode=" + system.code;
+  }
+  const listCode = params.listCode;
+  if (listCode) {
+    param += "&listCode=" + listCode;
+  }
+  if (pageContext.beanName) {
+    param += "&beanName=" + pageContext.beanName;
+  }
+  if (configureBase.functionCode) {
+    param += "&functionCode=" + configureBase.functionCode;
+  }
+  if (pageContext.tableName) {
+    param += "&tableName=" + pageContext.tableName;
+  }
+  if (configureBase) {
+    const isPermission = configureBase.isPermission === void 0 || configureBase.isPermission === "true" || configureBase.isPermission;
+    param += "&isPermission=" + isPermission;
+  }
+  const baseUrl = commonUtil.getBaseUrl(system);
+  window.open(baseUrl + "/dsc/commons/download-files" + param);
+}
+function doImportFinally(params, fileObj) {
+  const pageContext = params.pageContext;
+  const buttonConfigureObj = params.configureObj;
+  const tableConfigure = params.tableConfigure;
+  const tableName = pageContext.tableName;
+  const buttonConfigureBase = buttonConfigureObj.props.base;
+  const param = new FormData();
+  param.append("multipartFile", fileObj);
+  if (tableName) {
+    param.append("tableName", tableName);
+  }
+  if (pageContext.importBeanName) {
+    param.append("importBeanName", pageContext.importBeanName);
+  }
+  if (pageContext.beanName) {
+    param.append("beanName", pageContext.beanName);
+  }
+  const listViewImportDuplicate = tableConfigure.props.listViewImportDuplicate;
+  if (listViewImportDuplicate) {
+    param.append("importDuplicateRule", listViewImportDuplicate);
+  }
+  const judgeHeavyList = pageContext.judgeHeavyList;
+  if (judgeHeavyList) {
+    param.append("judgeHeavyList", JSON.stringify(judgeHeavyList));
+  }
+  const formNoRuleCode = pageContext.formNoRuleCode;
+  if (formNoRuleCode) {
+    param.append("formNoRuleCode", formNoRuleCode);
+  }
+  const listCode = params.listCode;
+  if (listCode) {
+    param.append("listCode", listCode);
+  }
+  let isAsync = false;
+  if (buttonConfigureBase["isAsync"] !== void 0 && buttonConfigureBase["isAsync"] !== null) {
+    isAsync = buttonConfigureBase.isAsync;
+  } else {
+    isAsync = false;
+  }
+  param.append("isAsync", isAsync + "");
+  param.append("pageCode", pageContext.code);
+  const isWorkflowEntity = pageContext.workflowCode ? true : false;
+  if (isWorkflowEntity !== null && isWorkflowEntity !== void 0) {
+    param.append("isWorkflowEntity", isWorkflowEntity + "");
+  }
+  if (buttonConfigureBase.functionCode) {
+    param.append("functionCode", buttonConfigureBase.functionCode);
+  }
+  const additionalParamMap = pageContext.entity.request;
+  if (additionalParamMap) {
+    param.append("additionalParamMapStr", JSON.stringify(additionalParamMap));
+  }
+  const isPermission = buttonConfigureBase.isPermission === void 0 || buttonConfigureBase.isPermission === "true" || buttonConfigureBase.isPermission;
+  param.append("isPermission", isPermission + "");
+  const system = pageContext.entity.system;
+  const baseUrl = commonUtil.getBaseUrl(system);
+  let path = baseUrl + "/dsc/commons/import-data";
+  path = commonUtil.getRealRestApiPath(path, system);
+  http.post(path, param).then((data) => {
+    if (isAsync) {
+      elementPlus.ElMessage({
+        showClose: true,
+        type: "success",
+        message: util.getI18n().t("superPageRuntimeMessage.asyncImport")
+      });
+    } else {
+      let isSuccess = false;
+      if (data) {
+        isSuccess = false;
+        elementPlus.ElMessage({
+          dangerouslyUseHTMLString: true,
+          showClose: true,
+          type: "warning",
+          message: data
+        });
+      } else {
+        elementPlus.ElMessage({
+          showClose: true,
+          type: "success",
+          message: util.getI18n().t("superPageRuntimeMessage.successfulImport")
+        });
+        isSuccess = true;
+      }
+      dealAfterOperate(pageContext, buttonConfigureObj, data, null, true);
+      pageContext.result = isSuccess;
+      eventUtil.doAfterClickEvent(pageContext, buttonConfigureObj);
+    }
+  }).catch((error) => {
+    console.log("error==", error);
+  });
+}
+function judgeDataNumber(buttonConfigureObj, ids) {
+  const buttonConfigureBase = buttonConfigureObj.props.base;
+  if (buttonConfigureBase.conditionsForExecution && buttonConfigureBase.conditionsForExecution !== "") {
+    if (buttonConfigureBase.conditionsForExecution === "one") {
+      if (!ids || ids.length !== 1) {
+        elementPlus.ElMessage({
+          showClose: true,
+          type: "warning",
+          message: util.getI18n().t("superPageRuntimeMessage.thePreconditionOfTheButtonTo", {
+            message: util.getI18n().t("superPageRuntimeMessage.onlyOneRecordCanBeselected")
+          })
+        });
+        return false;
+      }
+    } else if (buttonConfigureBase.conditionsForExecution === "more") {
+      if (!ids || ids.length <= 0) {
+        elementPlus.ElMessage({
+          showClose: true,
+          type: "warning",
+          message: util.getI18n().t("superPageRuntimeMessage.thePreconditionOfTheButtonTo", {
+            message: util.getI18n().t("superPageRuntimeMessage.selectAtLeastOneRecord")
+          })
+        });
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function exportFunc(params) {
+  return new Promise((resolve, reject) => {
+    const pageContext = params.pageContext;
+    const configureBase = params.configureObj.props.base;
+    const listCode = params.listCode;
+    const selections = params.selections;
+    const dataParam = {};
+    if (selections && selections.length > 0) {
+      dataParam["data"] = selections;
+    }
+    let pageName = pageContext.label;
+    if (!pageName) {
+      pageName = pageContext.code;
+    }
+    let isAsync = false;
+    if (configureBase["isAsync"] !== void 0 && configureBase["isAsync"] !== null) {
+      isAsync = configureBase.isAsync;
+    } else {
+      isAsync = false;
+    }
+    const isPermission = configureBase.isPermission === void 0 || configureBase.isPermission === "true" || configureBase.isPermission;
+    const exportFileName = pageName;
+    window["$vueApp"].config.globalProperties.$exportDataNew(
+      dataParam,
+      exportFileName,
+      listCode,
+      configureBase.functionCode,
+      null,
+      null,
+      isAsync,
+      pageContext.code,
+      isPermission
+    );
+  });
+}
+function getWorkflowSaveParams(params) {
+  const pageContext = params.pageContext;
+  const configureObj = params.configureObj;
+  const dataModel = pageContext.entity.data;
+  const system = pageContext.entity.system;
+  const permissionPrefix = system.code + "." + pageContext.code;
+  let functionCode = configureObj.props.base.functionCode;
+  if (!functionCode) {
+    functionCode = permissionPrefix + ".xxx";
+  }
+  if (!dataModel.id && !dataModel.ID) {
+    dataModel["pageCode"] = pageContext.code;
+    dataModel["pageVersion"] = pageContext.version;
+  }
+  const param = {
+    entity: dataModel,
+    pageMoel: pageContext.entity.page,
+    formNoRuleCode: pageContext.formNoRuleCode,
+    tableName: pageContext.tableName,
+    emailTemplateCode: pageContext.emailTemplateCode,
+    definitionId: pageContext.definitionId,
+    functionCode,
+    systemCode: system.code,
+    tableNames: pageContext.tableNames
+  };
+  if (pageContext.completeTaskParam) {
+    param["completeTaskParam"] = {
+      taskId: pageContext.completeTaskParam.taskId,
+      opinion: pageContext.completeTaskParam.opinion
+    };
+  }
+  if (pageContext.judgeHeavyList) {
+    if (commonUtil.isArrayFn(pageContext.judgeHeavyList)) {
+      param["judgeHeavyList"] = JSON.stringify(pageContext.judgeHeavyList);
+    } else {
+      param["judgeHeavyList"] = pageContext.judgeHeavyList;
+    }
+  }
+  const conversionCodes = configureObj.props.base.conversionCodes;
+  if (conversionCodes) {
+    if (commonUtil.isArrayFn(conversionCodes)) {
+      param["dataConversionRule"] = conversionCodes.join(",");
+    } else if (typeof conversionCodes === "string") {
+      param["dataConversionRule"] = conversionCodes;
+    }
+  }
+  const autoSetValueData = configureObj.props.base.setValueList;
+  if (autoSetValueData) {
+    if (commonUtil.isArrayFn(autoSetValueData)) {
+      param["autoSetValueData"] = autoSetValueData.join(",");
+    } else if (typeof autoSetValueData === "string") {
+      param["autoSetValueData"] = autoSetValueData;
+    }
+  }
+  if (pageContext.beanName) {
+    param["beanName"] = pageContext.beanName;
+  }
+  const logSetting = configureObj.props.logSetting;
+  if (logSetting) {
+    param["logSettingText"] = logSetting;
+  }
+  if (!param.systemCode) {
+    param.systemCode = system.code;
+  }
+  const additionalParamMap = pageContext.entity.request;
+  if (additionalParamMap) {
+    param["additionalParamMap"] = additionalParamMap;
+    if (additionalParamMap.ids && additionalParamMap.ids.length > 0) {
+      param["ids"] = additionalParamMap.ids;
+    }
+  }
+  const successOperation = configureObj.props.base.successOperation;
+  if (successOperation && successOperation === "noOperation") {
+    param["unControlVersion"] = true;
+  }
+  param["isWorkflowEntity"] = true;
+  return param;
+}
+function workflowSaveFunc(params) {
+  return new Promise((resolve, reject) => {
+    const pageContext = params.pageContext;
+    const dataModel = pageContext.entity.data;
+    const system = pageContext.entity.system;
+    let path = commonUtil.getBaseUrl(system) + "/dsc/workflow-commons";
+    path = commonUtil.getRealRestApiPath(path, system);
+    if (!path) {
+      elementPlus.ElMessage({
+        showClose: true,
+        type: "warning",
+        message: util.getI18n().t("superPageRuntimeMessage.requestPathEmpty")
+      });
+      return;
+    }
+    const param = getWorkflowSaveParams(params);
+    let request;
+    if (dataModel.id || dataModel.ID) {
+      request = http.put(path, param);
+    } else {
+      request = http.post(path, param);
+    }
+    request.then((commonEntity) => {
+      let result = true;
+      if (commonEntity) {
+        result = dealCompleteTaskParam(commonEntity, false, pageContext, params, null);
+      }
+      if (result === true) {
+        elementPlus.ElMessage({
+          showClose: true,
+          type: "success",
+          message: util.getI18n().t("superPageRuntimeMessage.successfulSave")
+        });
+      }
+      resolve(true);
+    }).catch((error) => {
+      reject(error);
+    });
+  });
+}
+function dealCompleteTaskParam(commonEntity, isInit, pageContext, params, operationResult) {
+  const pageCode = pageContext.code;
+  const pageVersion = pageContext.version;
+  const formParam = commonEntity;
+  let taskId;
+  if (formParam) {
+    if (isInit && formParam.entity) {
+      pageContext.entity.data = formParam.entity;
+      pageContext.initFormNo = commonEntity.formNo;
+      pageContext.emailTemplateCode = commonEntity.emailTemplateCode;
+    }
+    const completeTaskResult = formParam.completeTaskResult;
+    if (completeTaskResult) {
+      const completeTaskTipType = completeTaskResult.completeTaskTipType;
+      if (completeTaskTipType && completeTaskTipType === "MESSAGE") {
+        const message = completeTaskResult.content;
+        elementPlus.ElMessage({
+          showClose: true,
+          type: "warning",
+          message
+        });
+        return false;
+      }
+    }
+    if (formParam.completeTaskParam) {
+      const completeTaskParam = formParam.completeTaskParam;
+      taskId = completeTaskParam.taskId;
+      if (params) {
+        params.taskId = taskId;
+      }
+      storeUtil.setStoreInfo(pageCode, pageVersion, "_completeTaskParam", completeTaskParam);
+      pageContext.fieldPermissions = completeTaskParam.fieldPermissions;
+      pageContext.actionPermissions = completeTaskParam.actionPermissions;
+      pageContext.workflowButtonComponent = completeTaskParam.buttonComponent;
+      pageContext.completeTaskParam = completeTaskParam;
+    }
+    storeUtil.setStoreInfo(pageCode, pageVersion, "_currentActivityName", formParam.taskName);
+  }
+  if (params) {
+    params.operationResult = operationResult;
+  }
+  if (!isInit) {
+    dealAfterOperate(pageContext, params.configureObj, commonEntity, null, false);
+  }
+  return true;
+}
+function submitProcessFunc(params) {
+  return new Promise((resolve, reject) => {
+    const pageContext = params.pageContext;
+    const system = pageContext.entity.system;
+    let path = commonUtil.getBaseUrl(system) + "/dsc/workflow-commons/submit";
+    path = commonUtil.getRealRestApiPath(path, system);
+    if (!path) {
+      elementPlus.ElMessage({
+        showClose: true,
+        type: "warning",
+        message: util.getI18n().t("superPageRuntimeMessage.requestPathEmpty")
+      });
+      return;
+    }
+    const param = getWorkflowSaveParams(params);
+    const request = http.post(path, param);
+    if (request) {
+      request.then((commonEntity) => {
+        let result = true;
+        if (commonEntity) {
+          result = dealCompleteTaskParam(commonEntity, false, pageContext, params, null);
+        }
+        if (result === true) {
+          elementPlus.ElMessage({
+            showClose: true,
+            type: "success",
+            message: util.getI18n().t("superPageRuntimeMessage.successfulSubmit")
+          });
+        }
+        resolve(true);
+      }).catch((error) => {
+        reject(error);
+      });
+    }
+  });
+}
+function completeTaskFunc(params, operationResult) {
+  return new Promise((resolve, reject) => {
+    const pageContext = params.pageContext;
+    const system = pageContext.entity.system;
+    let path = commonUtil.getBaseUrl(system) + "/dsc/workflow-commons/complete-tasks";
+    path = commonUtil.getRealRestApiPath(path, system);
+    if (!path) {
+      elementPlus.ElMessage({
+        showClose: true,
+        type: "warning",
+        message: util.getI18n().t("superPageRuntimeMessage.requestPathEmpty")
+      });
+      return;
+    }
+    const param = getWorkflowSaveParams(params);
+    param["completeTaskParam"] = {
+      operationResult,
+      taskId: pageContext.completeTaskParam ? pageContext.completeTaskParam.taskId : null,
+      opinion: pageContext.completeTaskParam ? pageContext.completeTaskParam.opinion : null
+    };
+    const request = http.post(path, param);
+    request.then((commonEntity) => {
+      let result = true;
+      if (commonEntity) {
+        result = dealCompleteTaskParam(commonEntity, false, pageContext, params, operationResult);
+      }
+      if (result === true) {
+        elementPlus.ElMessage({
+          showClose: true,
+          type: "success",
+          message: util.getI18n().t("superPageRuntimeMessage.successfulCompleteTask")
+        });
+      }
+      resolve(true);
+    }).catch((error) => {
+      reject(error);
+    });
+  });
+}
+function assignTask(params) {
+  const pageContext = params.pageContext;
+  const pagCode = pageContext.code;
+  const eventPageInfo = pagCode + "_";
+  window["$eventBus"].$emit(eventPageInfo + "assign-task", params);
+}
+function doAssign(params, selectNodeInfo) {
+  if (selectNodeInfo) {
+    const pageContext = params.pageContext;
+    const configureObj = params.configureObj;
+    const system = pageContext.entity.system;
+    const path = commonUtil.getBaseUrl(system) + "/dsc/workflow-commons/assigns";
+    const assigneeId = selectNodeInfo.id ? selectNodeInfo.id : selectNodeInfo.ID ? selectNodeInfo.ID : null;
+    const requestParam = getWorkflowSaveParams(params);
+    requestParam["assigneeId"] = assigneeId;
+    transactTask(params, requestParam, path, "superPageRuntimeMessage.successfulAssign").then(
+      (result) => {
+        eventUtil.doAfterClickEvent(pageContext, configureObj);
+      }
+    );
+  }
+}
+function getTransactTaskParam(params) {
+  const pageContext = params.pageContext;
+  const dataModel = pageContext.entity.data;
+  const pageModel = pageContext.entity.page;
+  const system = pageContext.entity.system;
+  const permissionPrefix = system.code + "." + pageContext.code;
+  const additionalParamMap = pageContext.entity.request;
+  const dataId = dataModel.ID !== void 0 && dataModel.ID !== null ? dataModel.ID : dataModel.id;
+  ({
+    beanName: pageContext.beanName,
+    id: dataId,
+    entity: dataModel,
+    pageModel,
+    additionalParamMap,
+    tableName: pageContext.tableName,
+    functionCode: permissionPrefix + ".xxx",
+    isWorkflowEntity: true,
+    tableNames: pageContext.tableNames
+  });
+  ({
+    taskId: pageContext.completeTaskParam.taskId,
+    systemCode: system.code
+  });
+}
+function addSignerFunc(params) {
+  const pageContext = params.pageContext;
+  const pagCode = pageContext.code;
+  const eventPageInfo = pagCode + "_";
+  window["$eventBus"].$emit(eventPageInfo + "add-signer", params);
+}
+function doAddSigner(params, selectNodeInfo) {
+  if (selectNodeInfo) {
+    const pageContext = params.pageContext;
+    const buttonConfigureObj = params.configureObj;
+    const system = pageContext.entity.system;
+    let path = commonUtil.getBaseUrl(system) + "/dsc/workflow-commons/add-signers";
+    path = commonUtil.getRealRestApiPath(path, system);
+    if (!path) {
+      elementPlus.ElMessage({
+        showClose: true,
+        type: "warning",
+        message: util.getI18n().t("superPageRuntimeMessage.requestPathEmpty")
+      });
+      return;
+    }
+    const requestParams = getTransactTaskParam(params);
+    requestParams["completeTaskParam"].transactors = selectNodeInfo.loginNames.join(",").split(",");
+    const request = http.post(path, requestParams);
+    if (request) {
+      request.then((commonEntity) => {
+        elementPlus.ElMessage({
+          showClose: true,
+          type: "success",
+          message: util.getI18n().t("superPageRuntimeMessage.successfulOperation")
+        });
+        if (commonEntity.entity) {
+          dealAfterOperate(pageContext, buttonConfigureObj, commonEntity, null, false);
+        }
+        eventUtil.doAfterClickEvent(pageContext, buttonConfigureObj);
+      });
+    }
+  }
+}
+function createCopyTask(params) {
+  const pageContext = params.pageContext;
+  const pagCode = pageContext.code;
+  const eventPageInfo = pagCode + "_";
+  window["$eventBus"].$emit(eventPageInfo + "copy-task", params);
+}
+function doCreateCopyTask(params, selectNodeInfo) {
+  if (selectNodeInfo) {
+    const pageContext = params.pageContext;
+    const buttonConfigureObj = params.configureObj;
+    const system = pageContext.entity.system;
+    let path = commonUtil.getBaseUrl(system) + "/dsc/workflow-commons/add-signers";
+    path = commonUtil.getRealRestApiPath(path, system);
+    if (!path) {
+      elementPlus.ElMessage({
+        showClose: true,
+        type: "warning",
+        message: util.getI18n().t("superPageRuntimeMessage.requestPathEmpty")
+      });
+      return;
+    }
+    const requestParams = getTransactTaskParam(params);
+    requestParams["completeTaskParam"].transactors = selectNodeInfo.userIds.join(",").split(",");
+    const request = http.post(path, requestParams);
+    if (request) {
+      request.then((commonEntity) => {
+        elementPlus.ElMessage({
+          showClose: true,
+          type: "success",
+          message: util.getI18n().t("superPageRuntimeMessage.successfulOperation")
+        });
+        eventUtil.doAfterClickEvent(pageContext, buttonConfigureObj);
+      });
+    }
+  }
+}
+function transactTask(params, requestParam, path, successMessageTip) {
+  return new Promise((resolve, reject) => {
+    const pageContext = params.pageContext;
+    const system = pageContext.entity.system;
+    path = commonUtil.getRealRestApiPath(path, system);
+    if (!path) {
+      elementPlus.ElMessage({
+        showClose: true,
+        type: "warning",
+        message: util.getI18n().t("superPageRuntimeMessage.requestPathEmpty")
+      });
+      return;
+    }
+    const request = http.post(path, requestParam);
+    if (request) {
+      request.then((commonEntity) => {
+        let result = true;
+        if (commonEntity) {
+          result = dealCompleteTaskParam(commonEntity, false, pageContext, params, null);
+        }
+        if (result === true) {
+          elementPlus.ElMessage({
+            showClose: true,
+            type: "success",
+            message: util.getI18n().t(successMessageTip)
+          });
+        }
+        resolve(true);
+      }).catch((error) => {
+        reject(error);
+      });
+    }
+  });
+}
+function drawTaskFunc(params) {
+  const pageContext = params.pageContext;
+  const system = pageContext.entity.system;
+  const path = commonUtil.getBaseUrl(system) + "/dsc/workflow-commons/draw-tasks";
+  const requestParam = getWorkflowSaveParams(params);
+  return transactTask(params, requestParam, path, "superPageRuntimeMessage.successfulDrawTask");
+}
+function abandonReceiveFunc(params) {
+  const pageContext = params.pageContext;
+  const system = pageContext.entity.system;
+  const path = commonUtil.getBaseUrl(system) + "/dsc/workflow-commons/abandon-receives";
+  const requestParam = getWorkflowSaveParams(params);
+  return transactTask(
+    params,
+    requestParam,
+    path,
+    "superPageRuntimeMessage.successfulAbandonReceive"
+  );
+}
+function returnToPreviousTaskFunc(params) {
+  const pageContext = params.pageContext;
+  const system = pageContext.entity.system;
+  const path = commonUtil.getBaseUrl(system) + "/dsc/workflow-commons/return-to-previous-tasks";
+  const requestParam = getWorkflowSaveParams(params);
+  return transactTask(
+    params,
+    requestParam,
+    path,
+    "superPageRuntimeMessage.successfulReturnToPreviousTask"
+  );
+}
+function endInstanceFunc(params) {
+  const pageContext = params.pageContext;
+  const system = pageContext.entity.system;
+  const path = commonUtil.getBaseUrl(system) + "/dsc/workflow-commons/end-instance";
+  const requestParam = getWorkflowSaveParams(params);
+  return transactTask(params, requestParam, path, "superPageRuntimeMessage.successfulEndInstance");
+}
+function returnTaskToFunc(params) {
+  const pageContext = params.pageContext;
+  const pagCode = pageContext.code;
+  const eventPageInfo = pagCode + "_";
+  window["$eventBus"].$emit(eventPageInfo + "choose-return-node", params);
+}
+function getTaskInformitions(params) {
+  const pageContext = params.pageContext;
+  const system = pageContext.entity.system;
+  const completeTaskParam = pageContext.completeTaskParam;
+  let path = commonUtil.getBaseUrl(system) + "/dsc/workflow-commons/returnable-task/" + completeTaskParam.taskId;
+  path = commonUtil.getRealRestApiPath(path, system);
+  if (!path) {
+    elementPlus.ElMessage({
+      showClose: true,
+      type: "warning",
+      message: util.getI18n().t("superPageRuntimeMessage.requestPathEmpty")
+    });
+    return;
+  }
+  const permissionPrefix = system.code + "." + pageContext.code;
+  const additionalParamMap = pageContext.entity.request;
+  const requestParams = {
+    beanName: pageContext.beanName,
+    additionalParamMap,
+    tableName: pageContext.tableName,
+    functionCode: permissionPrefix + ".xxx"
+  };
+  return http.post(path, requestParams);
+}
+function doReturnTaskTo(params, selectTaskNode) {
+  const pageContext = params.pageContext;
+  const configureObj = params.configureObj;
+  const system = pageContext.entity.system;
+  const path = commonUtil.getBaseUrl(system) + "/dsc/workflow-commons/returnTaskTo";
+  const requestParam = getWorkflowSaveParams(params);
+  if (selectTaskNode.nodeName) {
+    requestParam["returnToNodeName"] = selectTaskNode.nodeName;
+  }
+  if (selectTaskNode.nodeId) {
+    requestParam["returnToNodeId"] = selectTaskNode.nodeId;
+  }
+  transactTask(params, requestParam, path, "superPageRuntimeMessage.successfulReturnTaskTo").then(
+    (result) => {
+      eventUtil.doAfterClickEvent(pageContext, configureObj);
+    }
+  );
+}
+function removeSignerfunc(params) {
+  const pageContext = params.pageContext;
+  const pagCode = pageContext.code;
+  const eventPageInfo = pagCode + "_";
+  window["$eventBus"].$emit(eventPageInfo + "remove-signer", params);
+}
+function getRemoveSigner(params) {
+  const pageContext = params.pageContext;
+  const system = pageContext.entity.system;
+  let path = commonUtil.getBaseUrl(system) + "/dsc/workflow-commons/get-remove-signers";
+  const requestParam = getWorkflowSaveParams(params);
+  path = commonUtil.getRealRestApiPath(path, system);
+  if (!path) {
+    elementPlus.ElMessage({
+      showClose: true,
+      type: "warning",
+      message: util.getI18n().t("superPageRuntimeMessage.requestPathEmpty")
+    });
+    return;
+  }
+  return http.post(path, requestParam);
+}
+function doRemoveSigners(params, selectRemoveTasks) {
+  if (selectRemoveTasks) {
+    const pageContext = params.pageContext;
+    const configureObj = params.configureObj;
+    const system = pageContext.entity.system;
+    let path = commonUtil.getBaseUrl(system) + "/dsc/workflow-commons/remove-signers";
+    path = commonUtil.getRealRestApiPath(path, system);
+    if (!path) {
+      this.$message({
+        showClose: true,
+        type: "warning",
+        message: this.$t("superPageRuntimeMessage.requestPathEmpty")
+      });
+      return;
+    }
+    const taskIds = selectRemoveTasks.map((task) => task.id ? task.id : task.ID ? task.ID : null);
+    const requestParam = getWorkflowSaveParams(params);
+    requestParam["ids"] = taskIds;
+    const request = http.post(path, requestParam);
+    if (request) {
+      request.then((commonEntity) => {
+        dealAfterOperate(
+          pageContext,
+          configureObj,
+          commonEntity,
+          "superPageRuntimeMessage.successfulOperation",
+          false
+        );
+        eventUtil.doAfterClickEvent(pageContext, configureObj);
+      });
+    }
+  }
+}
+function retrieveTaskFunc(params) {
+  const pageContext = params.pageContext;
+  const system = pageContext.entity.system;
+  const path = commonUtil.getBaseUrl(system) + "/dsc/workflow-commons/retrieves";
+  const requestParam = getWorkflowSaveParams(params);
+  return transactTask(params, requestParam, path, "superPageRuntimeMessage.successfulRetrieve");
+}
+function lineEditCreateFunc(params) {
+  const pageContext = params.pageContext;
+  const tableUuid = params["tableUuid"];
+  const gridRef = globalRefs.getComponentRef(pageContext, tableUuid);
+  if (gridRef) {
+    gridRef.createRow(params);
+  }
+}
+function isVisibleWorkflowButton(standardEventName, buttonInfo, completeTaskParam) {
+  let isVisible = false;
+  if (standardEventName && buttonInfo) {
+    if (standardEventName === "workflowSave") {
+      isVisible = isVisibleWorkflowSave(buttonInfo);
+    } else if (standardEventName === "submitProcess") {
+      isVisible = isVisibleSubmitProcess(buttonInfo);
+    } else if (standardEventName === "submitTask") {
+      isVisible = isVisibleSubmitTask(buttonInfo);
+    } else if (standardEventName === "drawTask") {
+      isVisible = isVisibleDrawTask(buttonInfo);
+    } else if (standardEventName === "abandonReceive") {
+      isVisible = isVisibleAbandonReceive(buttonInfo);
+    } else if (standardEventName === "approve" || standardEventName === "refuse") {
+      isVisible = isVisibleApproveOrRefuse(buttonInfo);
+    } else if (standardEventName === "readed") {
+      isVisible = isVisibleReaded(buttonInfo);
+    } else if (standardEventName === "assign") {
+      isVisible = isVisibleAssignTask(buttonInfo);
+    } else if (standardEventName === "copyTask") {
+      isVisible = isVisibleCopyTask(buttonInfo);
+    } else if (standardEventName === "addSigner") {
+      isVisible = isVisibleAddSigner(buttonInfo);
+    } else if (standardEventName === "removeSigner") {
+      isVisible = isVisibleRemoveSigner(buttonInfo);
+    } else if (standardEventName === "retrieveTask") {
+      isVisible = isVisibleRetrieveTask(buttonInfo);
+    } else if (standardEventName === "agreement" || standardEventName === "oppose") {
+      isVisible = isVisibleAgreementOrOppose(buttonInfo);
+    } else if (standardEventName === "kiken") {
+      isVisible = isVisibleKiken(buttonInfo);
+    } else if (isShowOtherWorkflowBtn(buttonInfo, completeTaskParam)) {
+      if (standardEventName === "returnToPreviousTask") {
+        isVisible = isVisibleReturnToPreviousTask(buttonInfo);
+      } else {
+        isVisible = true;
+      }
+    }
+  }
+  return isVisible;
+}
+function isVisibleWorkflowSave(buttonInfo) {
+  if (typeof buttonInfo["processState"] === "undefined" || buttonInfo["processState"] === null || buttonInfo["processState"] === "UNSUBMIT" && buttonInfo["active"] === "WAIT_TRANSACT") {
+    if (typeof buttonInfo["processState"] === "undefined" || buttonInfo["showButtonSave"] === true) {
+      return true;
+    }
+  }
+  if (buttonInfo["processState"] && buttonInfo["processState"] === "SUBMIT") {
+    if (buttonInfo["processingMode"] !== "TYPE_READ" && buttonInfo["showButtonSave"] && (buttonInfo["active"] === "WAIT_TRANSACT" || buttonInfo["active"] === "WAIT_DESIGNATE_TRANSACTOR" || buttonInfo["active"] === "WAIT_CHOICE_TACHE" || buttonInfo["active"] === "DRAW_WAIT")) {
+      return true;
+    }
+  }
+  return false;
+}
+function isVisibleSubmitProcess(buttonInfo) {
+  if (typeof buttonInfo["processState"] === "undefined" || buttonInfo["processState"] === null || buttonInfo["processState"] === "UNSUBMIT" && buttonInfo["active"] === "WAIT_TRANSACT") {
+    if (typeof buttonInfo["processState"] === "undefined" || buttonInfo["showButtonSave"] === true) {
+      return true;
+    }
+  }
+  return false;
+}
+function isVisibleSubmitTask(buttonInfo) {
+  if (buttonInfo["processState"] && buttonInfo["processState"] === "SUBMIT") {
+    if (buttonInfo["active"] === "WAIT_TRANSACT" && buttonInfo["processingMode"] === "EDIT") {
+      return true;
+    }
+  }
+  return false;
+}
+function isVisibleDrawTask(buttonInfo) {
+  if (buttonInfo["processState"] && buttonInfo["processState"] === "SUBMIT") {
+    if (buttonInfo["active"] && (buttonInfo["active"] === "DRAW_WAIT" || buttonInfo["active"] === "DEPT_DRAW_WAIT") && buttonInfo["showButtonDraw"]) {
+      return true;
+    }
+  }
+  return false;
+}
+function isVisibleAbandonReceive(buttonInfo) {
+  if (buttonInfo["processState"] && buttonInfo["processState"] === "SUBMIT") {
+    if ((buttonInfo["drawTask"] && buttonInfo["active"] === "WAIT_TRANSACT" || buttonInfo["canAbandonDeptTask"] && buttonInfo["active"] === "WAIT_TRANSACT") && buttonInfo["showButtonAbandon"]) {
+      return true;
+    }
+  }
+  return false;
+}
+function isVisibleApproveOrRefuse(buttonInfo) {
+  if (buttonInfo["processState"] && buttonInfo["processState"] === "SUBMIT") {
+    if (buttonInfo["active"] === "WAIT_TRANSACT" && (buttonInfo["processingMode"] === "APPROVE" || buttonInfo["processingMode"] === "COUNTERSIGN")) {
+      return true;
+    }
+  }
+  return false;
+}
+function isVisibleAddSigner(buttonInfo) {
+  if (buttonInfo["processState"] && buttonInfo["processState"] === "SUBMIT") {
+    if (buttonInfo["active"] === "WAIT_TRANSACT" && (buttonInfo["processingMode"] === "APPROVE" || buttonInfo["processingMode"] === "COUNTERSIGN") && buttonInfo["processingMode"] === "COUNTERSIGN" && buttonInfo["showButtonAddCounter"]) {
+      return true;
+    }
+  }
+  return false;
+}
+function isVisibleRemoveSigner(buttonInfo) {
+  if (buttonInfo["processState"] && buttonInfo["processState"] === "SUBMIT") {
+    if (buttonInfo["active"] === "WAIT_TRANSACT" && (buttonInfo["processingMode"] === "APPROVE" || buttonInfo["processingMode"] === "COUNTERSIGN") && buttonInfo["processingMode"] === "COUNTERSIGN" && buttonInfo["showButtonDelCounter"]) {
+      return true;
+    }
+  }
+  return false;
+}
+function isVisibleAgreementOrOppose(buttonInfo) {
+  if (buttonInfo["processState"] && buttonInfo["processState"] === "SUBMIT") {
+    if (buttonInfo["active"] === "WAIT_TRANSACT" && buttonInfo["processingMode"] === "VOTE") {
+      return true;
+    }
+  }
+  return false;
+}
+function isVisibleKiken(buttonInfo) {
+  if (buttonInfo["processState"] && buttonInfo["processState"] === "SUBMIT") {
+    if (buttonInfo["active"] === "WAIT_TRANSACT" && buttonInfo["processingMode"] === "VOTE" && buttonInfo["showButtonKiken"]) {
+      return true;
+    }
+  }
+  return false;
+}
+function isVisibleCopyTask(buttonInfo) {
+  if (buttonInfo["processState"] && buttonInfo["processState"] === "SUBMIT") {
+    if (buttonInfo["active"] === "WAIT_TRANSACT" && buttonInfo["processingMode"] !== "TYPE_READ" && buttonInfo["showButtonCopy"]) {
+      return true;
+    }
+  }
+  return false;
+}
+function isVisibleAssignTask(buttonInfo) {
+  if (buttonInfo["processState"] && buttonInfo["processState"] === "SUBMIT") {
+    if (buttonInfo["processingMode"] !== "TYPE_READ" && (buttonInfo["active"] === "WAIT_TRANSACT" || buttonInfo["active"] === "DRAW_WAIT")) {
+      return true;
+    }
+  }
+  return false;
+}
+function isVisibleRetrieveTask(buttonInfo) {
+  if (buttonInfo["processState"] && buttonInfo["processState"] === "SUBMIT") {
+    if (showRetrieve(buttonInfo)) {
+      return true;
+    }
+  }
+  return false;
+}
+function showRetrieve(buttonInfo) {
+  if (buttonInfo["active"] !== "COMPLETED") {
+    return false;
+  }
+  if (buttonInfo["processingMode"] === "TYPE_READ") {
+    return false;
+  }
+  if (!buttonInfo["showButtonGetBack"]) {
+    return false;
+  }
+  return true;
+}
+function isVisibleReaded(buttonInfo) {
+  if (buttonInfo["active"] === "WAIT_TRANSACT" && buttonInfo["processingMode"] === "TYPE_READ") {
+    return true;
+  }
+  return false;
+}
+function isVisibleReturnToPreviousTask(buttonInfo) {
+  if (buttonInfo["rebuttable"]) {
+    return true;
+  }
+  return false;
+}
+function isShowOtherWorkflowBtn(buttonInfo, completeTaskParam) {
+  return buttonInfo["processState"] && buttonInfo["processState"] === "SUBMIT" && buttonInfo["processingMode"] !== "TYPE_READ" && !isTaskComplete(completeTaskParam);
+}
+function isTaskComplete(completeTaskParam) {
+  const taskParam = completeTaskParam;
+  let taskComplete = true;
+  if (taskParam) {
+    taskComplete = taskParam.taskComplete;
+  }
+  return taskComplete;
+}
+exports.dealAfterOperate = dealAfterOperate;
+exports.dealCompleteTaskParam = dealCompleteTaskParam;
+exports.doAddSigner = doAddSigner;
+exports.doAssign = doAssign;
+exports.doCreateCopyTask = doCreateCopyTask;
+exports.doImportFinally = doImportFinally;
+exports.doRemoveSigners = doRemoveSigners;
+exports.doReturnTaskTo = doReturnTaskTo;
+exports.exportFormReport = exportFormReport;
+exports.getRemoveSigner = getRemoveSigner;
+exports.getSaveFormRequest = getSaveFormRequest;
+exports.getTaskInformitions = getTaskInformitions;
+exports.isVisibleWorkflowButton = isVisibleWorkflowButton;
+exports.judgeDataNumber = judgeDataNumber;
+exports.standardEvents = standardEvents;