super-page-runtime 2.0.39 → 2.0.40-beta1

package/dist/lib/components/runtime/utils/events/validator-util.d.ts

@@ -0,0 +1,12 @@
+export declare function setObjectPropRule(prop: any, rules: any, leafRule: any): {};
+export declare function validator(entity: any, rules: any, columns: any, rowIndex: any, isSql: any): any;
+export declare function validateDataModelFunc(pageContext: any, configureObj: any, isEnableRequired: any): Promise<unknown>;
+/**
+ * 封装自定义校验规则
+ * @param orgCustomRules 自定义规则
+ * @param orgRules 原来的表单规则
+ * @returns 添加了自定义规则后的规则
+ */
+export declare function packageCustomRules(orgCustomRules: any, orgRules: any): any;
+export declare function i18nValidateRulesMessage(rules: any): {};
+export declare function getWorkflowRules(pageContext: any): any;

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

@@ -0,0 +1,416 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index$1 = require("../../../../node_modules/.pnpm/async-validator@4.2.5/node_modules/async-validator/dist-web/index.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 standardEvent = require("./standard-event.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 setObjectPropRule(prop, rules, leafRule) {
+  const rule = {};
+  if (!rules) {
+    rules = {};
+  }
+  let num = 0;
+  const props = prop.split(".");
+  props.forEach((subProp) => {
+    let objectRule;
+    if (num === props.length - 1) {
+      objectRule = getEndObjectRule(rule, props, subProp);
+      objectRule.fields[subProp] = leafRule;
+    } else {
+      let lastObjectRule;
+      if (num === 0) {
+        objectRule = rules;
+      } else {
+        lastObjectRule = getLastObjectRule(rule, props, props[num - 1]);
+        objectRule = lastObjectRule.fields;
+      }
+      if (!objectRule[subProp]) {
+        objectRule[subProp] = {
+          type: "object",
+          required: true,
+          fields: {}
+        };
+      }
+      if (num === 0) {
+        rule[subProp] = objectRule[subProp];
+      } else {
+        lastObjectRule.fields[subProp] = objectRule[subProp];
+      }
+    }
+    num++;
+  });
+  return rule;
+}
+function getLastObjectRule(rule, props, currentProp) {
+  let lastObjectdRule;
+  for (let i = 0; i < props.length; i++) {
+    const subProp = props[i];
+    if (i === 0) {
+      lastObjectdRule = rule[subProp];
+    } else {
+      lastObjectdRule = lastObjectdRule.fields[props[i]];
+    }
+    if (subProp === currentProp) {
+      break;
+    }
+  }
+  return lastObjectdRule;
+}
+function getEndObjectRule(rule, props, currentProp) {
+  let lastObjectdRule;
+  for (let i = 0; i < props.length; i++) {
+    if (i === 0) {
+      lastObjectdRule = rule[props[i]];
+    } else {
+      lastObjectdRule = lastObjectdRule.fields[props[i]];
+    }
+    if (i !== props.length - 1) {
+      const leafSubProp = props[i + 1];
+      if (leafSubProp === currentProp) {
+        break;
+      }
+    }
+  }
+  return lastObjectdRule;
+}
+function getValidator(columns) {
+  const rules = {};
+  if (columns) {
+    columns.forEach((editField) => {
+      const prop = editField.model;
+      if (prop && editField.validations) {
+        const validations = editField.validations;
+        if (prop.indexOf(".") > 0) {
+          setObjectPropRule(editField.prop, rules, validations);
+        } else {
+          if (validations && validations.length > 0) {
+            rules[prop] = [...validations];
+          }
+        }
+      }
+    });
+  }
+  return rules;
+}
+function validator(entity, rules, columns, rowIndex, isSql) {
+  return validatorEntity(entity, rules, columns, rowIndex, true, isSql);
+}
+function sublistVerify(rules) {
+  if (!rules) {
+    return;
+  }
+  Object.keys(rules).forEach((item) => {
+    if (item.indexOf(".") >= 0) {
+      let ruleKetArr = [];
+      ruleKetArr = item.split(".");
+      if (rules[ruleKetArr[0]]) {
+        rules[ruleKetArr[0]].fields[ruleKetArr[1]] = rules[item][0];
+      } else {
+        rules[ruleKetArr[0]] = new Object();
+        rules[ruleKetArr[0]].fields = new Object();
+        rules[ruleKetArr[0]].fields[ruleKetArr[1]] = rules[item][0];
+        rules[ruleKetArr[0]].type = "object";
+      }
+      delete rules[item];
+    }
+  });
+  return rules;
+}
+function validatorEntity(entity, rules, columns, rowIndex, isShouldRepeateValdate, isSql) {
+  let validateRules = sublistVerify(rules);
+  if ((!rules || rules === null) && columns) {
+    validateRules = getValidator(columns);
+  }
+  if (!validateRules || Object.keys(validateRules).length === 0) {
+    entity["validateErrorField"] = "";
+    return true;
+  }
+  let result;
+  const validator2 = new index$1(validateRules);
+  validator2.validate(
+    entity,
+    {
+      first: true
+    },
+    (errors, fields) => {
+      let fieldName;
+      if (errors) {
+        result = errors[0].message;
+        fieldName = errors[0]["field"];
+        if (typeof rowIndex !== "undefined" && rowIndex !== null) {
+          result = util.getI18n().t("superPageRuntimeMessage.recordLine", {
+            row: rowIndex + 1
+          }) + "，" + result;
+        }
+        index.ElMessage({
+          message: result,
+          showClose: true,
+          type: "warning",
+          duration: 3 * 1e3
+        });
+        console.log("errors", errors, "fields", fields);
+      } else {
+        result = true;
+      }
+      if (fieldName && isShouldRepeateValdate === true) {
+        const reg1 = /[A-Z]+/;
+        if (isSql !== void 0 && isSql === true && reg1.test(fieldName) && entity[fieldName.toLowerCase()] !== void 0) {
+          const copyEntity = JSON.parse(JSON.stringify(entity));
+          copyEntity[fieldName.toUpperCase()] = entity[fieldName.toLowerCase()];
+          delete copyEntity[fieldName.toLowerCase()];
+          result = validatorEntity(copyEntity, rules, columns, rowIndex, false, isSql);
+        }
+      }
+    }
+  );
+  return result;
+}
+function validateDataModelFunc(pageContext, configureObj, isEnableRequired) {
+  const dataModel = pageContext.entity.data;
+  const pageModel = pageContext.entity.page;
+  const data = { ...pageModel, ...dataModel };
+  const rules = pageContext.rules;
+  if (isEnableRequired === void 0 || isEnableRequired === null) {
+    isEnableRequired = configureObj.props.verification ? configureObj.props.verification.required : false;
+    if (typeof isEnableRequired === "undefined") {
+      isEnableRequired = false;
+    }
+  }
+  return validateDataModel(isEnableRequired, data, rules, pageContext);
+}
+function validateDataModel(isEnableRequired, dataModel, rules, pageContext) {
+  if (isEnableRequired) {
+    const isWorkflow = pageContext.workflowCode ? true : false;
+    if (isWorkflow) {
+      return validateWorkflowFormDataModel(dataModel, pageContext);
+    } else {
+      return validateCommonFormDataModel(dataModel, pageContext, rules);
+    }
+  } else {
+    return new Promise((resolve, reject) => {
+      resolve(true);
+    });
+  }
+}
+function validateWorkflowFormDataModel(dataModel, pageContext) {
+  return new Promise((resolve, reject) => {
+    const additionalParamMap = standardEvent.getAdditionalParamMap(pageContext);
+    const contextParameter = pageContext.entity.context;
+    const taskParamMap = pageContext.entity.task;
+    const isSql = true;
+    const subTablePageInfo = pageContext.subTablePageInfo;
+    let result = false;
+    const handleModels = JSON.parse(JSON.stringify(dataModel));
+    const rules = pageContext.rules;
+    if (!rules) {
+      result = true;
+    } else {
+      result = validator(handleModels, rules, null, null, true);
+    }
+    if (result === true) {
+      const workflowFieldPermissionRules = pageContext.workflowRules;
+      if (!workflowFieldPermissionRules) {
+        result = true;
+      } else {
+        result = window["$vueApp"].config.globalProperties.$formValidator(
+          dataModel,
+          workflowFieldPermissionRules,
+          isSql,
+          additionalParamMap,
+          taskParamMap,
+          contextParameter,
+          subTablePageInfo
+        );
+      }
+      if (result !== true) {
+        index.ElMessage({
+          showClose: true,
+          message: result + "",
+          type: "warning"
+        });
+        resolve(false);
+      } else {
+        const validatorResult = [];
+        const customUuids = pageContext.customValidatorUuids;
+        if (customUuids) {
+          customUuids.forEach((componentUuid) => {
+            const customRef = globalRefs.getComponentRef(pageContext, componentUuid);
+            if (customRef) {
+              validatorResult.push(customRef.validator());
+            }
+          });
+        }
+        if (validatorResult && validatorResult.length > 0) {
+          Promise.all(validatorResult).then((values) => {
+            if (values.includes(false)) {
+              resolve(false);
+            } else {
+              if (Object.keys(dataModel).indexOf("validateErrorField") >= 0) {
+                delete dataModel.validateErrorField;
+              }
+              resolve(dataModel);
+            }
+          });
+        } else {
+          if (Object.keys(dataModel).indexOf("validateErrorField") >= 0) {
+            delete dataModel.validateErrorField;
+          }
+          resolve(dataModel);
+        }
+      }
+    } else {
+      reject(new Error(util.getI18n().t("superPageRuntimeMessage.formDataVerificationFailed")).message);
+    }
+  });
+}
+function validateCommonFormDataModel(dataModel, pageContext, rules) {
+  return new Promise((resolve, reject) => {
+    const handleModels = JSON.parse(JSON.stringify(dataModel));
+    if (!rules) {
+      resolve(handleModels);
+    } else {
+      const validateEntityResult = validator(handleModels, rules, null, null, true);
+      if (validateEntityResult === true) {
+        const validateResult = validateSubTables(pageContext);
+        if (validateResult === true) {
+          if (Object.keys(handleModels).indexOf("validateErrorField") >= 0) {
+            delete handleModels.validateErrorField;
+          }
+          resolve(handleModels);
+        } else {
+          reject(
+            new Error(
+              util.getI18n().t("superPageRuntimeMessage.tableListSubTableDataVerificationFailed")
+            ).message
+          );
+        }
+      } else {
+        reject(new Error(util.getI18n().t("superPageRuntimeMessage.formDataVerificationFailed")).message);
+      }
+    }
+  });
+}
+function packageCustomRules(orgCustomRules, orgRules) {
+  if (!orgCustomRules) {
+    return orgRules;
+  }
+  if (!orgRules) {
+    orgRules = {};
+  }
+  const customRulesKeys = Object.keys(orgCustomRules);
+  const customRules = orgCustomRules;
+  customRulesKeys.forEach((key) => {
+    if (key === "__subRules") {
+      const subRules = customRules["__subRules"];
+      const customSubTableKey = Object.keys(subRules);
+      customSubTableKey.forEach((subTableKey) => {
+        if (!orgRules.subRules) {
+          orgRules["subRules"] = {};
+        }
+        if (orgRules.subRules[subTableKey]) {
+          Object.assign(orgRules.subRules[subTableKey], subRules[subTableKey]);
+        } else {
+          orgRules.subRules[subTableKey] = subRules[subTableKey];
+        }
+      });
+    } else {
+      orgRules[key] = customRules[key];
+    }
+  });
+  return sublistVerify(orgRules);
+}
+function validateSubTables(pageContext) {
+  if (!pageContext) {
+    return;
+  }
+  const tableUuidArr = pageContext.tableUuids;
+  if (!tableUuidArr) {
+    return;
+  }
+  for (let i = 0; i < tableUuidArr.length; i++) {
+    const tableUuid = tableUuidArr[i];
+    const refDom = globalRefs.getComponentRef(pageContext, tableUuid);
+    if (refDom) {
+      const flag = refDom.validatorSunTableListData();
+      if (!flag) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function i18nValidateRulesMessage(rules) {
+  if (!rules || Object.keys(rules).length === 0) {
+    return;
+  }
+  const newRules = {};
+  const propNames = Object.keys(rules);
+  for (let i = 0; i < propNames.length; i++) {
+    const propName = propNames[i];
+    const propRules = rules[propName];
+    propRules.forEach((rule) => {
+      const label = rule["label"];
+      const i18nLabel = util.getI18n().t(label);
+      if (rule["required"]) {
+        rule["message"] = util.getI18n().t("superPageRuntimeMessage.required", { label: i18nLabel });
+      }
+      if (rule["myType"]) {
+        rule["message"] = util.getI18n().t("superPageRuntimeMessage.formatMismatch", {
+          label: i18nLabel
+        });
+      }
+      if (rule["patternType"]) {
+        rule["message"] = util.getI18n().t("superPageRuntimeMessage.formatMismatch", {
+          label: i18nLabel
+        });
+      }
+      if (rule["max"] !== void 0 && rule["max"] !== null) {
+        rule["message"] = util.getI18n().t("superPageRuntimeMessage.overMaxLength", {
+          label: i18nLabel,
+          value: rule["max"]
+        });
+      }
+      if (rule["min"] !== void 0 && rule["min"] !== null) {
+        rule["message"] = util.getI18n().t("superPageRuntimeMessage.limitMinLength", {
+          label: i18nLabel,
+          value: rule["min"]
+        });
+      }
+    });
+    if (propName.indexOf(".") > 0) {
+      setObjectPropRule(propName, newRules, propRules);
+    } else {
+      if (propRules && propRules.length > 0) {
+        newRules[propName] = [...propRules];
+      }
+    }
+  }
+  return newRules;
+}
+function getWorkflowRules(pageContext) {
+  const dataModel = pageContext.entity.data;
+  const pageModel = pageContext.entity.page;
+  const data = { ...pageModel, ...dataModel };
+  const additionalParamMap = standardEvent.getAdditionalParamMap(pageContext);
+  const contextParameter = pageContext.entity.context;
+  const taskParamMap = pageContext.entity.task;
+  const isSql = true;
+  let workflowFieldPermissionRules = window["$vueApp"].config.globalProperties.$getValidator(
+    pageContext.completeTaskParam.fieldPermissions,
+    data,
+    isSql,
+    additionalParamMap,
+    taskParamMap,
+    contextParameter
+  );
+  const customRules = pageContext.customRules;
+  workflowFieldPermissionRules = packageCustomRules(customRules, workflowFieldPermissionRules);
+  return workflowFieldPermissionRules;
+}
+exports.getWorkflowRules = getWorkflowRules;
+exports.i18nValidateRulesMessage = i18nValidateRulesMessage;
+exports.packageCustomRules = packageCustomRules;
+exports.setObjectPropRule = setObjectPropRule;
+exports.validateDataModelFunc = validateDataModelFunc;
+exports.validator = validator;

package/dist/lib/components/runtime/utils/form/date-shortcuts.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 快捷选择生成方式
+ * @param dateScopeDetails
+ * @param dateType
+ * @param rangeType
+ */
+export declare function getDateShortCuts(dateScopeDetails: any[], dateType: string, rangeType: string): any;

package/dist/lib/components/runtime/utils/form/date-shortcuts.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function getDateShortCuts(dateScopeDetails, dateType, rangeType) {
+  if (!dateScopeDetails) {
+    return void 0;
+  }
+  const shortcuts = [];
+  if (dateScopeDetails.includes("today") && !["week", "month", "year"].includes(dateType)) {
+    const dateParams = {
+      text: "今天",
+      value: () => {
+        return /* @__PURE__ */ new Date();
+      }
+    };
+    if (rangeType.endsWith("range")) {
+      dateParams.value = () => {
+        return [/* @__PURE__ */ new Date(), /* @__PURE__ */ new Date()];
+      };
+    }
+    shortcuts.push(dateParams);
+  }
+  if (dateScopeDetails.includes("yesterday") && !["week", "month", "year"].includes(dateType)) {
+    const date = /* @__PURE__ */ new Date();
+    date.setTime(date.getTime() - 3600 * 1e3 * 24);
+    const dateParams = {
+      text: "昨天",
+      value: () => {
+        return date;
+      }
+    };
+    if (rangeType.endsWith("range")) {
+      dateParams.value = () => {
+        return [date, /* @__PURE__ */ new Date()];
+      };
+    }
+    shortcuts.push(dateParams);
+  }
+  if (dateScopeDetails.includes("oneWeek") && !["month", "year"].includes(dateType)) {
+    const date = /* @__PURE__ */ new Date();
+    date.setTime(date.getTime() - 3600 * 1e3 * 24 * 7);
+    const dateParams = {
+      text: "一周前",
+      value: () => {
+        return date;
+      }
+    };
+    if (rangeType.endsWith("range")) {
+      dateParams.text = "一周";
+      dateParams.value = () => {
+        return [date, /* @__PURE__ */ new Date()];
+      };
+    }
+    shortcuts.push(dateParams);
+  }
+  if (dateScopeDetails.includes("oneMonth") && !["year"].includes(dateType)) {
+    const date = /* @__PURE__ */ new Date();
+    if (date.getMonth() > 0) {
+      date.setMonth(date.getMonth() - 1);
+    } else {
+      date.setMonth(12);
+      date.setFullYear(date.getFullYear() - 1);
+    }
+    const dateParams = {
+      text: "一月前",
+      value: () => {
+        return date;
+      }
+    };
+    if (rangeType.endsWith("range")) {
+      dateParams.text = "一月";
+      dateParams.value = () => {
+        return [date, /* @__PURE__ */ new Date()];
+      };
+    }
+    shortcuts.push(dateParams);
+  }
+  if (dateScopeDetails.includes("oneYear")) {
+    const date = /* @__PURE__ */ new Date();
+    date.setFullYear(date.getFullYear() - 1);
+    const dateParams = {
+      text: "一年前",
+      value: () => {
+        return date;
+      }
+    };
+    if (rangeType.endsWith("range")) {
+      dateParams.text = "一年";
+      dateParams.value = () => {
+        return [date, /* @__PURE__ */ new Date()];
+      };
+    }
+    shortcuts.push(dateParams);
+  }
+  return shortcuts;
+}
+exports.getDateShortCuts = getDateShortCuts;