cloud-web-corejs 1.0.54-dev.81 → 1.0.54-dev.810

package/src/components/xform/utils/dynamicSchemaUtil.js

@@ -0,0 +1,361 @@
+/**
+ * 后台动态定义（表头后台字段 / 数据表格动态列）共用协议。
+ *
+ * 单条定义顶层字段：
+ * - 通用：keyName、type、label、optionItems、required 等字段级属性、options
+ * - 表头：colspan
+ * - 数据表格：width、formatS（展示列）、children（多级表头）、dropdownItems（dropdown 操作列）
+ *
+ * 请求体：{ formData, ...extra }
+ * 响应体：objx 数组，或 { fields: [] } / { columns: [] }
+ */
+
+/** 顶层字段白名单 */
+export const DYNAMIC_SCHEMA_CORE_KEYS = [
+  "keyName",
+  "type",
+  "label",
+  "optionItems",
+  "options",
+];
+
+/** 字段级属性：写顶层，不写 options（与表头 dynamicFieldMixin 一致） */
+export const DYNAMIC_SCHEMA_WIDGET_FLAG_KEYS = [
+  "required",
+  "readonly",
+  "disabled",
+  "hidden",
+  "defaultValue",
+  "placeholder",
+];
+
+export const DYNAMIC_SCHEMA_TABLE_HEADER_KEYS = ["colspan"];
+
+export const DYNAMIC_SCHEMA_COLUMN_EXTRA_KEYS = [
+  "width",
+  "align",
+  "sortable",
+  "filterable",
+  "show",
+  "fixed",
+  "formatS",
+  "render",
+  "utcTransformEnabled",
+  "children",
+  "dropdownItems",
+];
+
+export const DYNAMIC_SCHEMA_OPTION_KEYS = {
+  scriptCode: ["dynamicSchemaScriptCode", "dynamicColumnScriptCode"],
+  scriptParam: ["dynamicSchemaScriptParam", "dynamicColumnScriptParam"],
+  convert: ["dynamicSchemaConvert"],
+  mode: ["dynamicSchemaMode", "dynamicColumnMode"],
+  sourceType: ["dynamicSchemaSourceType", "dynamicColumnSourceType"],
+  loadScript: ["dynamicSchemaLoadScript", "dynamicColumnLoadScript"],
+  frontendScript: ["dynamicSchemaScript", "dynamicColumnsScript"],
+};
+
+export const widgetTypeToEditFormatMap = {
+  input: "editInput",
+  number: "editNumber",
+  date: "editDate",
+  select: "editSelect",
+  vabsearch: "editSearch",
+  baseAttachment: "editAttachment",
+  status: "editStatus",
+  text: "text",
+  checkbox: "checkbox",
+  radio: "radio",
+  textarea: "textarea",
+  "script-input": "editScriptInput",
+  "a-text": "aText",
+  "a-link": "aLink",
+  button: "button",
+  dropdown: "dropdown",
+};
+
+const ACTION_COLUMN_FORMATS = new Set(["aLink", "button", "dropdown"]);
+
+const NON_DATA_EXPORT_COLUMN_FORMATS = new Set([
+  "dropdown",
+  "button",
+  "editDelete",
+  "editButton",
+  "editTreeButtonGroup",
+  "addSiblingEditRow",
+  "addChildTreeRow",
+  "moveUpRow",
+  "moveDownRow",
+  "removeTreeRow",
+]);
+
+const NON_DATA_EXPORT_WIDGET_TYPES = new Set([
+  "button",
+  "dropdown",
+  "dropdown-item",
+  "divider",
+  "search_button",
+  "save_button",
+  "reset_button",
+  "table-export-button",
+  "select-export-button",
+  "select-export-item-button",
+  "add_button",
+  "import-button",
+  "import2-button",
+  "print-button",
+  "print-detail-button",
+  "download-button",
+  "save_submit_wf_button",
+  "copy_button",
+  "compare-change-button",
+  "compare-button",
+  "compare-close-button",
+  "compare-del-button",
+]);
+
+export function buildDropdownWidgetFromDef(def, index = 0) {
+  const options = def?.options;
+  const dropdownItems = def?.dropdownItems;
+  if (!Array.isArray(dropdownItems) || !dropdownItems.length) return null;
+
+  const ts = `${Date.now()}_${index}`;
+  const widgetList = dropdownItems.map((entry, i) => ({
+    type: "dropdown-item",
+    id: `dropdownitem_${ts}_${i}`,
+    options: {
+      label: entry.label || "",
+      onClick: entry.onClick || "",
+      disabled: !!entry.disabled,
+      hidden: !!entry.hidden,
+    },
+  }));
+
+  return {
+    type: "dropdown",
+    id: `dropdown_${ts}`,
+    options: {
+      label: def.label || "操作",
+      dropdownType: options?.dropdownType || "link",
+      dropdownTrigger: options?.dropdownTrigger || "hover",
+      dropdownFlag: 1,
+    },
+    widgetList,
+  };
+}
+
+function isActionColumn(item, formatS) {
+  return isActionColumnFormat(formatS, item?.type);
+}
+
+export function isActionColumnFormat(formatS, type) {
+  if (ACTION_COLUMN_FORMATS.has(formatS)) return true;
+  return ["a-link", "button", "dropdown"].includes(type);
+}
+
+export function isNonDataExportColumn(formatS, type, options) {
+  if (NON_DATA_EXPORT_COLUMN_FORMATS.has(formatS)) return true;
+  if (NON_DATA_EXPORT_WIDGET_TYPES.has(type)) return true;
+  // a-link can either display a bound field or act as a row operation button.
+  return (formatS === "aLink" || type === "a-link")
+    && options?.isFormLabel !== true;
+}
+
+function isActionOrGroupColumn(item, formatS) {
+  if (Array.isArray(item.children) && item.children.length) return true;
+  return isActionColumn(item, formatS);
+}
+
+function buildWidgetOptions(item, formatS, label) {
+  let widgetOptions =
+    item.options && typeof item.options === "object"
+      ? { ...item.options }
+      : null;
+
+  if (widgetOptions) {
+    delete widgetOptions.dropdownItems;
+  }
+
+  DYNAMIC_SCHEMA_WIDGET_FLAG_KEYS.forEach((key) => {
+    if (item[key] !== undefined) {
+      widgetOptions = widgetOptions || {};
+      widgetOptions[key] = item[key];
+    }
+  });
+
+  if (label) {
+    widgetOptions = widgetOptions || {};
+    if (!widgetOptions.label) {
+      widgetOptions.label = label;
+    }
+  }
+
+  if (!isActionColumn(item, formatS)) {
+    widgetOptions = widgetOptions || {};
+    widgetOptions.labelHidden = true;
+  }
+
+  return widgetOptions;
+}
+
+export function getDynamicSchemaOption(options, key) {
+  if (!options) return null;
+  const keys = DYNAMIC_SCHEMA_OPTION_KEYS[key] || [];
+  for (let i = 0; i < keys.length; i++) {
+    const val = options[keys[i]];
+    if (val !== undefined && val !== null && val !== "") {
+      return val;
+    }
+  }
+  return null;
+}
+
+export function resolveDynamicSchemaExtra(paramScript, handleCustomEvent) {
+  if (!paramScript || !handleCustomEvent) return {};
+  const result = handleCustomEvent(paramScript);
+  return result && typeof result === "object" && !Array.isArray(result)
+    ? result
+    : {};
+}
+
+export function buildDynamicSchemaRequestData(
+  formModel,
+  paramScript,
+  handleCustomEvent,
+  wrapContext
+) {
+  const extra = resolveDynamicSchemaExtra(paramScript, handleCustomEvent);
+  const payload = {
+    formData: formModel || {},
+    ...extra,
+  };
+  if (!wrapContext) {
+    return payload;
+  }
+  const { formCode, formVersion, taBm, dataId } = wrapContext;
+  return {
+    formCode,
+    formVersion,
+    taBm,
+    formData: payload.formData,
+    dataId,
+    data: {
+      dataId,
+      ...payload,
+    },
+  };
+}
+
+/** 从 objx 或转换脚本结果中提取定义数组 */
+export function extractDynamicSchemaItems(source) {
+  if (!source) return [];
+  if (Array.isArray(source)) return source;
+  if (typeof source !== "object") return [];
+  if (Array.isArray(source.fields)) return source.fields;
+  if (Array.isArray(source.columns)) return source.columns;
+  return [];
+}
+
+export function resolveDynamicSchemaResponse(res, convertScript, handleCustomEvent) {
+  if (convertScript && handleCustomEvent) {
+    const result = handleCustomEvent(convertScript, ["res"], [res]);
+    return extractDynamicSchemaItems(result);
+  }
+  return extractDynamicSchemaItems(res && res.objx);
+}
+
+export function normalizeDynamicFieldKey(item) {
+  if (!item || typeof item !== "object") return undefined;
+  return item.keyName;
+}
+
+export function normalizeDynamicColumnItem(item, index) {
+  if (!item || typeof item !== "object") {
+    return null;
+  }
+
+  const keyName = normalizeDynamicFieldKey(item);
+  const label = item.label;
+  let formatS = item.formatS || null;
+  if (!formatS && item.type) {
+    formatS = widgetTypeToEditFormatMap[item.type] || item.type;
+  }
+
+  let editFormatS = null;
+  if (formatS && String(formatS).startsWith("edit")) {
+    editFormatS = formatS;
+  }
+
+  const widgetOptions = buildWidgetOptions(item, formatS, label);
+
+  let widget = null;
+  let widgetList = null;
+  if (
+    (item.type === "dropdown" || formatS === "dropdown") &&
+    Array.isArray(item.dropdownItems) &&
+    item.dropdownItems.length
+  ) {
+    widget = buildDropdownWidgetFromDef(item, index);
+    if (widget && label) {
+      widget.options.label = label;
+    }
+    if (widget?.widgetList?.length) {
+      widgetList = widget.widgetList;
+    }
+  }
+
+  if (!keyName && !isActionOrGroupColumn(item, formatS)) {
+    return null;
+  }
+
+  const isAction = isActionColumn(item, formatS);
+
+  const widgetFlags = {};
+  DYNAMIC_SCHEMA_WIDGET_FLAG_KEYS.forEach((key) => {
+    if (item[key] !== undefined) {
+      widgetFlags[key] = item[key];
+    } else if (widgetOptions?.[key] !== undefined) {
+      widgetFlags[key] = widgetOptions[key];
+    }
+  });
+
+  const children = Array.isArray(item.children)
+    ? item.children
+        .map((child, childIndex) =>
+          normalizeDynamicColumnItem(child, index * 1000 + childIndex)
+        )
+        .filter(Boolean)
+    : item.children;
+
+  return {
+    columnId: item.columnId || `${Date.now()}_${index}`,
+    type: item.type,
+    prop: keyName || undefined,
+    label,
+    width: item.width ?? 150,
+    show: item.show !== false,
+    sortable: isAction ? item.sortable === true : item.sortable !== false,
+    filterable: isAction ? item.filterable === true : item.filterable !== false,
+    ...(item.align ? { align: item.align } : {}),
+    fixed: item.fixed,
+    formatS,
+    editFormatS: editFormatS || undefined,
+    optionItems: item.optionItems,
+    widget,
+    widgetList,
+    widgetOptions,
+    children: children,
+    render: item.render,
+    utcTransformEnabled: item.utcTransformEnabled,
+    ...widgetFlags,
+  };
+}
+
+export function normalizeDynamicColumns(columns) {
+  if (!Array.isArray(columns)) {
+    return [];
+  }
+  return columns
+    .map((item, index) => normalizeDynamicColumnItem(item, index))
+    .filter(Boolean);
+}

package/src/components/xform/utils/emitter.js

@@ -13,7 +13,7 @@ function broadcast(componentName, eventName, params) {
 
 export default {
   methods: {
-    dispatch(componentName, eventName, params, isFormSetting) {
+    dispatch(componentName, eventName, params, option) {
 
       var parent = this.$parent || this.$root;
       var name = parent.$options.componentName;
@@ -25,15 +25,15 @@ export default {
           name = parent.$options.componentName;
         }
       }
-      if (isFormSetting) {
+      /*if (isFormSetting) {
         if (window.formSettingPanelRef) {
           parent = window.formSettingPanelRef;
         }
-      }
+      }*/
 
       if (parent) {
         let data = [eventName].concat(params);
-        data.push(isFormSetting)
+        data.push(option)
         parent.$emit.apply(parent, data);
       }
     },

package/src/components/xform/utils/fixedQueryUtil.js

@@ -0,0 +1,93 @@
+/**
+ * 「固定查询条件」判定工具。
+ *
+ * 数据表格查询区的字段值存在整张表单的 formModel 上，三条通道会把它清掉：
+ *   1. 刷新按钮 → resetForm 逐个 setValue(null)
+ *   2. 「查询条件设置」的「确定」→ tableFormMixin.dialogPrimary 按列写默认值
+ *   3. 「查询条件设置」的「还原」→ 走的就是 dialogPrimary
+ * 字段勾上 options.fixedQuery 之后，这三条通道一律跳过它，值保持原样
+ * (值本身仍由树点选/脚本 setValue 等业务通道注入，本开关只管「不被清掉」)。
+ *
+ * 组装 searchColumns 时(见 container-item/data-table-mixin.js)由 fixedQuery
+ * 派生出两个列级标记：
+ *   - lockValue：公共表格层(components/table)据此跳过写值，语义是「值锁定」
+ *   - fixed：复用公共层已有语义，让个性化 json 回灌时不挪位置、不改常用
+ * 两者必须分开：手写页面的固定列(如 branchSearchPage 的分支)只打 fixed，
+ * 它**依赖** dialogPrimary 按 defaultValue 回填，不能被 lockValue 一起跳过。
+ */
+
+/* 能承载子组件的字段名，覆盖各类容器(含 vf-dialog/vf-drawer，loopHandleWidget 不进这两个) */
+const CHILD_KEYS = [
+  "widgetList",
+  "cols",
+  "rows",
+  "tabs",
+  "panes",
+  "buttons",
+  "buttonWidgetList",
+  "leftWidgetList",
+];
+
+/**
+ * 深度遍历组件树节点（含 rows 这类只有 cols 的中间层对象）。
+ * @param {Object} node 起始节点
+ * @param {Function} callback 每个节点回调
+ */
+function walkWidget(node, callback) {
+  if (!node || typeof node !== "object") return;
+  callback(node);
+  CHILD_KEYS.forEach((key) => {
+    let children = node[key];
+    if (Array.isArray(children)) {
+      children.forEach((child) => walkWidget(child, callback));
+    }
+  });
+}
+
+/**
+ * 该字段是否勾选了「固定查询条件」。
+ * @param {Object} widget 字段组件 schema
+ * @returns {Boolean}
+ */
+export function isFixedQueryWidget(widget) {
+  return !!(widget && widget.options && widget.options.fixedQuery);
+}
+
+/**
+ * 该列是否为「值锁定」列（公共表格层的口径，见文件头注释）。
+ * @param {Object} column searchColumns 的列配置
+ * @returns {Boolean}
+ */
+export function isLockedSearchColumn(column) {
+  return !!(column && column.lockValue);
+}
+
+/**
+ * 组件是否位于某个数据表格的查询区（data-table 的 widgetList 分支，不含 buttons、
+ * 不含表格列组件）。属性面板据此决定要不要显示「固定查询条件」开关。
+ * @param {Array} widgetList 表单顶层组件列表（designer.widgetList）
+ * @param {Object} widget 待判定的字段组件
+ * @returns {Boolean}
+ */
+export function isQueryAreaWidget(widgetList, widget) {
+  if (!widget || !widget.id || !Array.isArray(widgetList)) return false;
+  let inQueryArea = false;
+  widgetList.forEach((item) => {
+    walkWidget(item, (node) => {
+      if (inQueryArea) return;
+      if (
+        node.category !== "container"
+        || node.type !== "data-table"
+        || !Array.isArray(node.widgetList)
+      ) {
+        return;
+      }
+      node.widgetList.forEach((child) => {
+        walkWidget(child, (sub) => {
+          if (sub.id === widget.id) inQueryArea = true;
+        });
+      });
+    });
+  });
+  return inQueryArea;
+}

package/src/components/xform/utils/formHttp.js

@@ -0,0 +1,162 @@
+// import {initWf} from '../../../components/wf/wfUtil'
+// import {getReportGlobalMap} from "../../../components/xform/utils/util";
+import {decrypt} from "@base/utils/aes";
+
+
+let modules = {};
+modules = {
+  methods: {
+    /*formScriptHttp(opts){
+      return this.formHttp({
+        ...opts
+      });
+    },*/
+    handleDecryptData(data) {
+      if (data) {
+        if (Array.isArray(data)) {
+          data.forEach(item => {
+            this.handleDecryptData(item)
+          })
+        } else if (Object.prototype.toString.call(data) === "[object Object]") {
+          Object.keys(data).forEach(key => {
+
+            let value = data[key];
+            if (value !== null && value !== undefined) {
+              if (Object.prototype.toString.call(data[key]) === "[object String]") {
+                let str = "ATEN*-";
+                if (value.startsWith(str)) {
+                  data[key] = decrypt(value.slice(str.length));
+                }
+              } else {
+                this.handleDecryptData(data[key])
+              }
+            }
+          })
+        } else if (Object.prototype.toString.call(data) === "[object String]") {
+          let str = "ATEN*-";
+          if (data.startsWith(str)) {
+            data = decrypt(data.slice(str.length));
+          }
+        }
+      }
+      return data;
+    },
+    getHttpTarget() {
+      return this.getFormRef ? this.getFormRef() : this;
+    },
+    formHttp(opts) {
+      let data = opts.data;
+      let scriptCode = opts.scriptCode ? opts.scriptCode.trim() : null;
+      let formCode = opts.formCode ? opts.formCode.trim() : null;
+      let isLoading = opts.isLoading ?? true;
+      let success = opts.success;
+      let fail = opts.fail;
+      let error = opts.error;
+
+      let that = this;
+      // let reportTemplate = that.getFormRef ? that.getFormRef().reportTemplate : that.reportTemplate;
+      if (scriptCode && !formCode) {
+        let arr = scriptCode.split("/").filter(item => item)
+        if (arr.length > 1) {
+          formCode = arr[0];
+          scriptCode = arr[1];
+        }
+      }
+
+
+      delete opts.data
+      delete opts.scriptCode
+      delete opts.formCode
+      delete opts.isLoading
+      delete opts.success
+      delete opts.fail
+      delete opts.error
+
+
+      let getReqUrl = (callback) => {
+
+        if (!opts.url) {
+          this.getHttpTarget().$http({
+            aes: true,
+            url: USER_PREFIX + `/formScript/getServiceName`,
+            method: `post`,
+            data: {
+              formCode,
+              scriptCode
+            },
+            isLoading,
+            // loadingTarget: this.getLoadingTarget(),
+            // modalStrictly: true,
+            success: res => {
+              let serviceName = res.objx;
+              if (serviceName) {
+                let url = `/${searviceName}/bd_api/${formCode}/${scriptCode}`;
+                callback(url)
+              } else {
+                this.$baseAlert("服务名不存在")
+              }
+            }
+          });
+        } else {
+          callback(opts.url)
+        }
+
+      }
+      let toDo = () => {
+        return new Promise((resolve, reject) => {
+          getReqUrl(url => {
+            let reqData;
+            reqData = data;
+
+            let reportGlobalMap = {};
+            // let url = `/${searviceName}/bd_api/${formCode}/${scriptCode}`;
+            // let opts.vue
+            return opts.vue.$http({
+              // aes: true,
+              url: url,
+              method: `post`,
+              // loadingTarget: this.getLoadingTarget(),
+              isLoading,
+              ...opts,
+              data: {
+                // scriptCode: scriptCode,
+                fixeData: reportGlobalMap,
+                ...reqData
+              },
+              success: res => {
+                if (res.objx) {
+                  res.objx = this.handleDecryptData(res.objx);
+                }
+                if (opts.successMsg) {
+                  this.$message({
+                    message: res.content,
+                    type: 'success',
+                    duration: 1000
+                  });
+                }
+                success && success(res);
+                resolve(res);
+              },
+              fail: res => {
+                fail && fail(res);
+                resolve(res);
+              },
+              error: e => {
+                error && error(e);
+                reject(e);
+              }
+            });
+          })
+        })
+      }
+      if (opts.isConfirm) {
+        this.$baseConfirm(opts.confirmText).then(() => {
+          return toDo();
+        });
+      } else {
+        return toDo();
+      }
+    }
+  }
+}
+export default modules;