cloud-web-corejs 1.0.54-dev.80 → 1.0.54-dev.800

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

@@ -0,0 +1,84 @@
+/**
+ * 宿主注入查询表格的查询参数（dataTableOption.queryParam）合并规则。
+ *
+ * 查询表格发给后台的请求体形如：
+ *   { condition: [{ field, value, filter }, ...], current, size, searchCount, ...其它平铺参数 }
+ * 其中 `condition` 由查询区字段按类型自动组装（见 data-table-mixin.js 的 getSearchFormData），
+ * 平铺参数则是给后台脚本（formScriptParam 那套约定）读的。
+ *
+ * 宿主（选择弹框 / 表单弹框 / 表单抽屉）传进来的 queryParam 此前是整体 Object.assign，
+ * 于是带 `condition` 的写法会把查询区当场输入的条件**整个覆盖掉**。这里把 `condition`
+ * 单独拿出来做追加合并，其余键保持原来的平铺覆盖语义。
+ *
+ * 使用方：data-table-mixin.js（PC）、list-h5-item.vue（H5）两条查询链路。
+ */
+
+/** 未显式给 filter 时的默认比较符：数组按 in，其余按 eq（宿主条件是精确过滤，不该默认 like） */
+function defaultFilter(value) {
+  return Array.isArray(value) ? "in" : "eq";
+}
+
+/**
+ * 把 condition 归一成 [{ field, value, filter }]。接受三种写法：
+ *   1. 数组：[{ field: "status", value: 1, filter: "eq" }]（原生格式，filter 可省）
+ *   2. 对象简写：{ status: 1, type: ["A", "B"] } → filter 自动取 eq / in
+ *   3. 对象 + 比较符：{ createTime: { value: ["2026-01-01", "2026-12-31"], filter: "between" } }
+ * @param {Array|Object} condition
+ * @returns {Array} 归一后的条件项数组；无效输入返回空数组
+ */
+export function normalizeCondition(condition) {
+  if (!condition) return [];
+  if (Array.isArray(condition)) {
+    return condition
+      .filter((item) => item && item.field)
+      .map((item) => ({
+        ...item,
+        filter: item.filter || defaultFilter(item.value),
+      }));
+  }
+  if (typeof condition !== "object") return [];
+  return Object.keys(condition).map((field) => {
+    let raw = condition[field];
+    // 只有「纯对象且带 value 键」才当成 {value, filter} 写法，避免把业务对象拆错
+    let isDetail
+      = raw
+      && typeof raw === "object"
+      && !Array.isArray(raw)
+      && Object.prototype.hasOwnProperty.call(raw, "value");
+    let value = isDetail ? raw.value : raw;
+    return {
+      field: field,
+      value: value,
+      filter: (isDetail && raw.filter) || defaultFilter(value),
+    };
+  });
+}
+
+/**
+ * 合并宿主 queryParam 到请求参数上（原地修改 queryParams 并返回它）。
+ * - `condition`：追加到查询区已组装的条件之后；**同 field 以宿主的为准**（先剔旧再追加），
+ *   这样宿主条件既不会被用户输入顶掉，也不会和用户输入同字段撞成两条。
+ * - 其余键：平铺覆盖（与改造前一致）。
+ * @param {Object} queryParams 查询表格已组装好的请求参数
+ * @param {Object} queryParam  宿主注入的查询参数
+ * @returns {Object} queryParams
+ */
+export function mergeQueryParam(queryParams, queryParam) {
+  if (!queryParams || !queryParam) return queryParams;
+
+  let hostCondition = normalizeCondition(queryParam.condition);
+  Object.keys(queryParam).forEach((key) => {
+    if (key !== "condition") queryParams[key] = queryParam[key];
+  });
+
+  if (!hostCondition.length) return queryParams;
+
+  let hostFields = hostCondition.map((item) => item.field);
+  let baseCondition = Array.isArray(queryParams.condition)
+    ? queryParams.condition.filter(
+        (item) => !item || hostFields.indexOf(item.field) < 0
+      )
+    : [];
+  queryParams.condition = baseCondition.concat(hostCondition);
+  return queryParams;
+}

package/src/components/xform/utils/sfc-generator.js

@@ -389,12 +389,12 @@ export function buildFieldWidget(widget, formConfig) {
   let customLabelDom =
 `<template #label><span class="custom-label">${wop.labelIconPosition === 'front' ?
   (!!wop.labelTooltip ?
-      `<el-tooltip content="${wop.labelTooltip}" effect="light"><i class="${wop.labelIconClass}"></i></el-tooltip>${wop.label}` :
+      `<el-tooltip content="${wop.labelTooltip}" effect="light" popper-class="label-tooltip-pre-line"><i class="${wop.labelIconClass}"></i></el-tooltip>${wop.label}` :
       `<i class="${wop.labelIconClass}"></i>${wop.label}`
   )
   :
   (!!wop.labelTooltip ?
-      `${wop.label}<el-tooltip content="${wop.labelTooltip}" effect="light"><i class="${wop.labelIconClass}"></i></el-tooltip>` :
+      `${wop.label}<el-tooltip content="${wop.labelTooltip}" effect="light" popper-class="label-tooltip-pre-line"><i class="${wop.labelIconClass}"></i></el-tooltip>` :
       `${wop.label}<i class="${wop.labelIconClass}"></i>`
   )
 }

package/src/components/xform/utils/smart-vue-i18n/index.js

@@ -1,5 +1,6 @@
 import {deepAssign, get} from './utils'
-import {extendDeeply} from "../../../../utils/index.js";
+import xeUtils from "xe-utils";
+import {extendDeeply} from "@base/utils/index.js";
 
 
 const install = (Vue, options) => {

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

@@ -0,0 +1,148 @@
+import {
+  isEmptyStr,
+  isEmptyArrayFieldValue,
+  isArrayValueWidgetType,
+  isVabsearchWidgetType,
+  isVabsearchMultiWidget,
+} from "./util";
+import { resolveColumnRequiredFlag } from "./tableColumnHelper";
+
+/** 数据表格行内字段候选 key（column.prop 为权威存储字段） */
+export function getCellFieldKeys(fieldWidget, columnConfig) {
+  const keys = [];
+  const addKey = (key) => {
+    if (key && !keys.includes(key)) {
+      keys.push(key);
+    }
+  };
+
+  addKey(columnConfig?.prop);
+
+  if (!fieldWidget) {
+    return keys;
+  }
+
+  const options = fieldWidget.options || {};
+  if (
+    isVabsearchWidgetType(fieldWidget.type) &&
+    !isVabsearchMultiWidget(fieldWidget)
+  ) {
+    addKey(options.vabSearchName);
+    addKey(getWidgetFieldKey(fieldWidget));
+  } else {
+    addKey(getWidgetFieldKey(fieldWidget));
+  }
+
+  return keys;
+}
+
+export function getCellFieldKey(fieldWidget, columnConfig) {
+  const keys = getCellFieldKeys(fieldWidget, columnConfig);
+  return keys.length ? keys[0] : null;
+}
+
+export function getWidgetFieldKey(widget) {
+  if (!widget?.options) {
+    return null;
+  }
+  const o = widget.options.name;
+  return (widget.options.keyNameEnabled && widget.options.keyName) || o;
+}
+
+export function isCellFieldRequired(columnConfig, fieldWidget) {
+  if (!fieldWidget || fieldWidget.options?.hidden) {
+    return false;
+  }
+  if (fieldWidget.options?.required) {
+    return true;
+  }
+  return resolveColumnRequiredFlag(columnConfig);
+}
+
+export function shouldSkipCellValidation(fieldWidget) {
+  if (!fieldWidget) {
+    return true;
+  }
+  if (fieldWidget.options?.hidden) {
+    return true;
+  }
+  if (fieldWidget.options?.disabled) {
+    return true;
+  }
+  return false;
+}
+
+export function isEmptyCellValue(fieldWidget, value) {
+  if (!fieldWidget) {
+    return false;
+  }
+  const type = fieldWidget.type;
+  const options = fieldWidget.options || {};
+
+  if (type === "number") {
+    return value === null || value === undefined || value === "";
+  }
+
+  if (isArrayValueWidgetType(type, options)) {
+    return isEmptyArrayFieldValue(value, type, options);
+  }
+
+  if (type === "select" || type === "radio" || type === "status") {
+    if (value === null || value === undefined || value === "") {
+      return true;
+    }
+    if (typeof value === "string" && !/[^\s]/.test(value)) {
+      return true;
+    }
+    return false;
+  }
+
+  return isEmptyStr(value);
+}
+
+/** 从行数据中读取单元格值（兼容 column.prop 与 widget 字段名不一致） */
+export function getCellValueFromRow(row, fieldWidget, columnConfig) {
+  if (!row) {
+    return undefined;
+  }
+  const keys = getCellFieldKeys(fieldWidget, columnConfig);
+  if (!keys.length) {
+    return undefined;
+  }
+  let fallbackValue;
+  for (const key of keys) {
+    const value = row[key];
+    if (fallbackValue === undefined) {
+      fallbackValue = value;
+    }
+    if (!isEmptyCellValue(fieldWidget, value)) {
+      return value;
+    }
+  }
+  return fallbackValue;
+}
+
+export function isEmptyCellValueInRow(row, fieldWidget, columnConfig) {
+  return isEmptyCellValue(
+    fieldWidget,
+    getCellValueFromRow(row, fieldWidget, columnConfig)
+  );
+}
+
+export function buildCellRequiredHint(fieldWidget, columnConfig, t1Fn) {
+  const options = fieldWidget?.options || {};
+  if (options.requiredHint) {
+    return t1Fn(options.requiredHint);
+  }
+  const label = t1Fn(
+    options.label || columnConfig?.label || columnConfig?.prop || ""
+  );
+  return t1Fn("[{label}]不能为空", { label });
+}
+
+export function buildTableCellFormProp(tableFieldKeyName, rowIndex, fieldKey) {
+  if (!tableFieldKeyName || !fieldKey || rowIndex < 0) {
+    return null;
+  }
+  return `${tableFieldKeyName}.${rowIndex}.${fieldKey}`;
+}

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

@@ -0,0 +1,155 @@
+function buildColumnConfigMap(tableColumns, map = {}) {
+  if (!tableColumns || !tableColumns.length) {
+    return map;
+  }
+  tableColumns.forEach((col) => {
+    if (col.prop) {
+      map[col.prop] = col;
+    }
+    if (col.columnId) {
+      map[`__id__${col.columnId}`] = col;
+    }
+    if (col.children && col.children.length) {
+      buildColumnConfigMap(col.children, map);
+    }
+  });
+  return map;
+}
+
+function enrichColumnList(columns, configMap) {
+  if (!columns || !columns.length) {
+    return columns;
+  }
+  return columns.map((col) => {
+    const newCol = Object.assign({}, col);
+    if (col.slots) {
+      newCol.slots = Object.assign({}, col.slots);
+    }
+    const field = col.field;
+    const columnId = col.params && col.params.columnId;
+    const config =
+      (field && configMap[field]) ||
+      (columnId && configMap[`__id__${columnId}`]);
+    if (config) {
+      applyColumnLabelIcon(newCol, config);
+    }
+    if (col.children && col.children.length) {
+      newCol.children = enrichColumnList(col.children, configMap);
+    }
+    return newCol;
+  });
+}
+
+/**
+ * Apply data-table column header icon config to vxe-table column definition.
+ */
+export function resolveColumnRequiredFlag(columnConfig) {
+  if (!columnConfig) {
+    return false;
+  }
+  if (columnConfig.required) {
+    return true;
+  }
+  if (columnConfig.editWidget?.options?.required) {
+    return true;
+  }
+  if (columnConfig.widget?.options?.required) {
+    return true;
+  }
+  const widgetOptions =
+    columnConfig.widgetOptions ?? columnConfig.columnOption;
+  const editWidgetOptions =
+    columnConfig.editWidgetOptions ?? columnConfig.editColumnOption;
+  return !!(widgetOptions?.required || editWidgetOptions?.required);
+}
+
+function buildVxeTitlePrefixTooltip(tooltip) {
+  if (!tooltip) {
+    return {};
+  }
+  if (/\r?\n/.test(tooltip)) {
+    return {
+      content: tooltip
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/\r\n/g, "\n")
+        .replace(/\n/g, "<br/>"),
+      useHTML: true,
+    };
+  }
+  return { content: tooltip };
+}
+
+export function applyColumnLabelIcon(col, columnConfig) {
+  if (!col || !columnConfig) {
+    return col;
+  }
+
+  const iconClass = columnConfig.labelIconClass;
+  const position = columnConfig.labelIconPosition || "rear";
+  const tooltip = columnConfig.labelTooltip;
+  const required = resolveColumnRequiredFlag(columnConfig);
+  const title = col.title;
+
+  if (!iconClass && !required) {
+    return col;
+  }
+
+  const buildIcon = (h) => {
+    const icon = h("i", { class: ["vxe-cell-help-icon", iconClass] });
+    if (!tooltip) {
+      return icon;
+    }
+    return h(
+      "el-tooltip",
+      {
+        props: {
+          content: tooltip,
+          effect: "dark",
+          placement: "top",
+          popperClass: "label-tooltip-pre-line",
+        },
+      },
+      [icon]
+    );
+  };
+
+  if (iconClass && position === "front" && !required) {
+    col.titlePrefix = {
+      icon: iconClass,
+      ...buildVxeTitlePrefixTooltip(tooltip),
+    };
+    return col;
+  }
+
+  if (required && !iconClass) {
+    col.titlePrefix = { icon: "vxe-cell--required-icon" };
+    return col;
+  }
+
+  col.slots = col.slots || {};
+  delete col.titlePrefix;
+
+  col.slots.header = (params, h) => {
+    const nodes = [];
+    if (required) {
+      nodes.push(h("i", { class: "vxe-cell--required-icon" }));
+    }
+    if (iconClass && position === "front") {
+      nodes.push(buildIcon(h));
+    }
+    nodes.push(h("span", { class: "vxe-cell--title" }, title));
+    if (iconClass && position === "rear") {
+      nodes.push(buildIcon(h));
+    }
+    return nodes;
+  };
+
+  return col;
+}
+
+export function enrichTableColumnsWithLabelIcon(columns, tableColumns) {
+  const configMap = buildColumnConfigMap(tableColumns || []);
+  return enrichColumnList(columns, configMap);
+}

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

@@ -0,0 +1,179 @@
+/**
+ * 字段脱敏（"密文文本"）判定。
+ *
+ * 规则在组件属性面板 textFlag-editor 维护：
+ * - options.userTextRuleEnabled 总开关
+ * - options.userTextRuleConfig 规则列表，单条为
+ *   { serveName, companyCodes, roleCodes, type, encryptFormula }
+ *   - serveName / companyCodes 为空表示不限；companyCodes、roleCodes 为逗号分隔串
+ *   - type=1：角色不匹配时脱敏；type=2：角色匹配时脱敏
+ *   - encryptFormula 形如 "3*3" / "3*" / "*3" / "*" / "-"
+ * - 规则列表是全遍历而非命中即止，后置规则会覆盖前置规则的结论
+ * - 规则里的 loginAccounts / saleOrgCodes 两个维度目前不参与匹配（历史遗留字段）
+ *
+ * 本文件是该判定的唯一实现：渲染侧（form-item-wrapper 的只读文本）与导出侧
+ * （数据表格按列剔除）必须共用，否则会出现界面打码、导出放行的漂移。
+ */
+
+/** 列 params 上的私有标记：记录 exportDisabled 是脱敏判定打的，撤销时才敢删 */
+const MASK_MARK_KEY = "exportDisabledByTextMask";
+
+/**
+ * @param {Array} list1 规则侧编码列表。为空表示不限。
+ * @param {Array} list2 当前用户编码列表。
+ * @returns {Boolean} 是否匹配。
+ */
+export function compareToList(list1, list2) {
+  if (!list1.length) {
+    return true;
+  }
+  if (!list2.length) {
+    return false;
+  }
+  return list1.some((item) => {
+    return list2.some((item2) => item == item2);
+  });
+}
+
+/**
+ * @param {Object} widgetOptions 组件 options。
+ * @returns {Boolean} 是否配置了脱敏规则（不代表当前用户命中）。
+ */
+export function hasTextMaskRule(widgetOptions) {
+  if (!widgetOptions || !widgetOptions.userTextRuleEnabled) return false;
+  let ruleList = widgetOptions.userTextRuleConfig || [];
+  return ruleList.some((item) => {
+    let type = item.type ?? null;
+    return type !== null && type !== "";
+  });
+}
+
+/**
+ * @param {Object} formRef 表单实例（form-render）。
+ * @param {String} companyCode 当前公司编码（store.getters.companyCode）。
+ * @returns {Object} 判定上下文 { bdService, companyCode, roleCodeList }。
+ */
+export function buildTextMaskContext(formRef, companyCode) {
+  let roleCodeList = (formRef?.userRoleDTOs || []).map((item) => item.roleCode);
+  return {
+    bdService: formRef?.bdService,
+    companyCode,
+    roleCodeList,
+  };
+}
+
+/**
+ * @param {Object} widgetOptions 组件 options。
+ * @param {Object} ctx 用户上下文 { bdService, companyCode, roleCodeList }。
+ * @returns {{masked: Boolean, encryptFormula: String}} 是否脱敏及命中的加密规则。
+ */
+export function resolveTextMaskFlag(widgetOptions, ctx) {
+  let result = { masked: false, encryptFormula: null };
+  if (!widgetOptions || !widgetOptions.userTextRuleEnabled) return result;
+
+  let bdService = ctx?.bdService;
+  let companyCode = ctx?.companyCode;
+  let roleCodeList = ctx?.roleCodeList || [];
+
+  let userTextRuleConfig = widgetOptions.userTextRuleConfig || [];
+  userTextRuleConfig.forEach((item) => {
+    let type = item.type ?? null;
+    if (type === null || type === "") return;
+
+    let companyCodeStr = item.companyCodes;
+    let companyCodes = companyCodeStr
+      ? companyCodeStr.split(",").filter((code) => !!code)
+      : [];
+    let roleCodeStr = item.roleCodes;
+    let roleCodes = roleCodeStr
+      ? roleCodeStr.split(",").filter((code) => !!code)
+      : [];
+
+    let flag1 = !item.serveName || item.serveName == bdService;
+    let flag2 = !companyCodes.length || companyCodes.includes(companyCode);
+    if (!flag1 || !flag2) return;
+
+    result.encryptFormula = item.encryptFormula;
+    let flag5 = compareToList(roleCodes, roleCodeList);
+    if (flag5) {
+      //匹配角色
+      if (type == 2) result.masked = true; //type=2时加密
+    } else {
+      //角色不匹配
+      if (type == 1) result.masked = true;
+    }
+  });
+
+  return result;
+}
+
+/**
+ * 导出前按脱敏规则给命中列打 params.exportDisabled，由 excelExport 的三处过滤
+ * （字段选择树、表头 JSON、取数）统一剔除整列。
+ *
+ * 之所以要按列剔除：命中脱敏规则的字段在界面上只渲染掩码文本，但导出取值走
+ * filterVal / 原始字段快路径，不经过渲染层，会把明文写进文件。
+ *
+ * 判定结论与渲染层严格一致：同一个 resolveTextMaskFlag、同一份用户上下文，且导出
+ * 必然发生在单元格渲染之后（用户已看到明文或密文），所以不做"上下文未就绪"的收紧。
+ * 曾用 bdService 非空当就绪判据并 fail-closed，但该字段来自 getBdService 接口、
+ * 大量环境本就返回空，导致所有用户的脱敏列被一律剔除——不要再加这类启发式。
+ *
+ * 本函数幂等且可自愈：结论变化时会撤销自己此前打的标记（靠私有键区分，不碰
+ * isNonDataExportColumn 打的标记）。
+ *
+ * @param {Object} $grid vxe-grid 实例。
+ * @param {Object} ctx 判定上下文，由 buildTextMaskContext 生成。
+ */
+export function markMaskedExportColumns($grid, ctx) {
+  if (!$grid || typeof $grid.getTableColumn !== "function") return;
+
+  /** 打标记。列本就被其它规则（isNonDataExportColumn）剔除时不接管，避免撤销时误删。 */
+  let disable = (params) => {
+    if (params.exportDisabled && !params[MASK_MARK_KEY]) return;
+    params.exportDisabled = true;
+    params[MASK_MARK_KEY] = true;
+  };
+  /** 撤销本函数此前打的标记（判定结论变化时）。 */
+  let restore = (params) => {
+    if (!params[MASK_MARK_KEY]) return;
+    delete params[MASK_MARK_KEY];
+    delete params.exportDisabled;
+  };
+
+  let maskedFields = new Set();
+  let markColumn = (column) => {
+    if (column.children && column.children.length) {
+      column.children.forEach(markColumn);
+      return;
+    }
+    let widgetOptions = column.params?.widget?.options;
+    if (!hasTextMaskRule(widgetOptions)) return;
+    if (!resolveTextMaskFlag(widgetOptions, ctx).masked) {
+      restore(column.params);
+      return;
+    }
+    disable(column.params);
+    if (column.field) maskedFields.add(column.field);
+  };
+  let { collectColumn } = $grid.getTableColumn();
+  (collectColumn || []).forEach(markColumn);
+
+  // 明细导出列是独立配置（只有 field/title，没有组件），按字段名对齐主表脱敏列
+  let markItemColumn = (column) => {
+    if (column.children && column.children.length) {
+      column.children.forEach(markItemColumn);
+      return;
+    }
+    if (!column.field) return;
+    column.params = column.params || {};
+    if (maskedFields.has(column.field)) {
+      disable(column.params);
+    } else {
+      restore(column.params);
+    }
+  };
+  let originOption = $grid.params?.originOption;
+  let exportItemColumns = originOption?.exportItemConfig?.columns || [];
+  exportItemColumns.forEach(markItemColumn);
+}