cloud-web-corejs 1.0.54-dev.688 → 1.0.54-dev.689

package/src/components/xform/form-render/container-item/data-table-mixin.js

@@ -14,9 +14,28 @@ import {
   loopHandleWidget,
   columnFormatMap,
   getColumnWidgetOptions,
+  applyColumnMetaToFieldWidget,
+  applyColumnMetaToColumnRow,
   traverseAllWidgetsNew,
+  isAttachmentWidgetType,
+  isVabsearchMultiWidget,
 } from "../../../../components/xform/utils/util";
-import { applyColumnLabelIcon } from "../../../../components/xform/utils/tableColumnHelper";
+import { applyColumnLabelIcon, resolveColumnRequiredFlag } from "../../../../components/xform/utils/tableColumnHelper";
+import {
+  buildCellRequiredHint,
+  buildTableCellFormProp,
+  getCellFieldKey,
+  isCellFieldRequired,
+  isEmptyCellValueInRow,
+  shouldSkipCellValidation,
+} from "../../../../components/xform/utils/tableCellValidateUtil";
+import {
+  buildDynamicSchemaRequestData,
+  getDynamicSchemaOption,
+  isActionColumnFormat,
+  normalizeDynamicColumns as normalizeDynamicColumnList,
+  resolveDynamicSchemaResponse,
+} from "../../utils/dynamicSchemaUtil";
 import { tableTreeMixins } from "../../../../mixins/tableTree/index.js";
 
 let modules = {};
@@ -211,9 +230,15 @@ modules = {
       return widget ? this.getOptionItemLabelKey(widget) : null;
     },
     getOptionItemValueKey(widget) {
+      if (widget?.options?.commonAttributeEnabled) {
+        return widget.options.valueKey || "sn";
+      }
       return widget.options.valueKey || "value";
     },
     getOptionItemLabelKey(widget) {
+      if (widget?.options?.commonAttributeEnabled) {
+        return widget.options.labelKey || "value";
+      }
       return widget.options.labelKey || "label";
     },
     getTableColumnWidget(obj) {
@@ -222,7 +247,7 @@ modules = {
     },
     isShowColumnStatusWidget(obj, item) {
       let widget = this.getTableColumnWidget(obj);
-      let valueKey = widget.options.valueKey || "value";
+      let valueKey = this.getOptionItemValueKey(widget);
       return (
         obj.row[this.getTableColumnWidgetFieldKeyName(obj)] === item[valueKey]
       );
@@ -272,6 +297,7 @@ modules = {
     },
     syncEffectiveColumnWidgetFieldKeys(tableColumns) {
       this.loodHandleColumns(tableColumns, (row) => {
+        applyColumnMetaToColumnRow(row);
         this.syncColumnWidgetFieldKey(row, row.widget);
         this.syncColumnWidgetFieldKey(row, row.editWidget);
       });
@@ -398,6 +424,7 @@ modules = {
             formRef.getFieldWidgetByType(type)
           );
           fieldWidget.options = widgetOptions;
+          applyColumnMetaToFieldWidget(fieldWidget, row, false);
           row.widget = fieldWidget;
         }
         let type2 = columnFormatMap[row.editFormatS];
@@ -407,6 +434,7 @@ modules = {
             formRef.getFieldWidgetByType(type2)
           );
           fieldWidget.options = editWidgetOptions;
+          applyColumnMetaToFieldWidget(fieldWidget, row, true);
           row.editWidget = fieldWidget;
         }
       });
@@ -506,7 +534,7 @@ modules = {
     },
     initValue(val) {
       // this.clearRowWidgets()
-      let rows = val || [];
+      let rows = this.normalizeTableRows(val || [], false);
       // this.handleNullValue(rows);
       rows.forEach((row, index) => {
         row._X_ROW_KEY = "row_" + generateId();
@@ -580,15 +608,28 @@ modules = {
         }
       }
     },
+    normalizeTableRows(rows, defaultValueEnabled = false) {
+      if (!Array.isArray(rows) || !rows.length) {
+        return rows || [];
+      }
+      const emptyRow = this.createNewTableData(false, defaultValueEnabled);
+      return rows.map((row) => {
+        const nextRow = row && typeof row === "object" ? { ...row } : {};
+        Object.keys(emptyRow).forEach((key) => {
+          if (!Object.prototype.hasOwnProperty.call(nextRow, key)) {
+            nextRow[key] = emptyRow[key];
+          }
+        });
+        if (!nextRow._X_ROW_KEY) {
+          nextRow._X_ROW_KEY = "row_" + generateId();
+        }
+        return nextRow;
+      });
+    },
     setValue(val) {
       // console.log("rows:",val);
       this.clearRowWidgets();
-      let rows = val || [];
-      rows.forEach((row, index) => {
-        if (!row._X_ROW_KEY) {
-          row._X_ROW_KEY = "row_" + generateId();
-        }
-      });
+      let rows = this.normalizeTableRows(val || [], false);
       this.formModel[this.fieldKeyName] = rows;
       let $grid = this.getGridTable();
       this.fieldModel = rows;
@@ -604,6 +645,169 @@ modules = {
       let o = widget.options.name;
       return (widget.options.keyNameEnabled && widget.options.keyName) || o;
     },
+    getDatasetRequiredHint() {
+      if (this.widget.options.requiredHint) {
+        return this.$t1(this.widget.options.requiredHint);
+      }
+      const label = this.$t1(this.widget.options.label || this.fieldKeyName);
+      return this.$t1("[{label}]不能为空", { label });
+    },
+    validateDatasetRequired() {
+      if (!this.widget.options.required || this.widget.options.hidden) {
+        return null;
+      }
+      const rows = this.formModel[this.fieldKeyName];
+      if (Array.isArray(rows) && rows.length > 0) {
+        return null;
+      }
+      return this.getDatasetRequiredHint();
+    },
+    getValidationRows() {
+      const formRows = this.formModel[this.fieldKeyName];
+      if (Array.isArray(formRows) && formRows.length) {
+        return formRows;
+      }
+      const $grid = this.getGridTable?.();
+      if ($grid) {
+        return $grid.getTableData()?.fullData || [];
+      }
+      return [];
+    },
+    getValidationRowIndex(row, rows, fallbackIndex = 0) {
+      if (!row || !Array.isArray(rows)) {
+        return fallbackIndex;
+      }
+      const isTreeTable = this.widget.options.isTreeTable || false;
+      if (isTreeTable && row._X_ROW_KEY) {
+        const treeIndex = rows.findIndex(
+          (item) => item._X_ROW_KEY === row._X_ROW_KEY
+        );
+        if (treeIndex >= 0) {
+          return treeIndex;
+        }
+      }
+      const index = rows.indexOf(row);
+      return index >= 0 ? index : fallbackIndex;
+    },
+    collectColumnValidateEntries(column, isEditTable, entries) {
+      if (column.widget) {
+        entries.push({
+          column,
+          templateWidget: column.widget,
+        });
+      }
+      if (isEditTable && column.editWidget) {
+        entries.push({
+          column,
+          templateWidget: column.editWidget,
+        });
+      }
+      if (column.widgetList?.length) {
+        loopHandleWidget(column.widgetList, (w) => {
+          entries.push({
+            column,
+            templateWidget: w,
+          });
+        });
+      }
+    },
+    resolveRowFieldWidget(row, templateWidget) {
+      if (!row || !templateWidget) {
+        return templateWidget;
+      }
+      const schema = this.fieldSchemaMap[row._X_ROW_KEY];
+      if (schema && schema[templateWidget.id]) {
+        return schema[templateWidget.id];
+      }
+      return templateWidget;
+    },
+    locateValidationError(row, propName) {
+      const $grid = this.getGridTable?.();
+      if ($grid && row) {
+        if (typeof $grid.scrollToRow === "function") {
+          $grid.scrollToRow(row);
+        }
+      }
+      const formRef = this.getFormRef?.();
+      const renderForm = formRef?.$refs?.renderForm;
+      if (propName && renderForm) {
+        renderForm.validateField(propName, () => {});
+      }
+    },
+    validateCellsRequired() {
+      if (this.widget.options.hidden || this.designState) {
+        return null;
+      }
+
+      const rows = this.getValidationRows();
+      if (!rows.length) {
+        return null;
+      }
+
+      const isEditTable = this.widget.options.isEditTable || false;
+      const tableColumns = this.widget.options.tableColumns || [];
+      const tableFieldKeyName = this.getFieldKeyName(this.widget);
+      const columnEntries = [];
+
+      this.loodHandleColumns(tableColumns, (column) => {
+        this.collectColumnValidateEntries(column, isEditTable, columnEntries);
+      });
+
+      for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+        const row = rows[rowIndex];
+        if (!row) {
+          continue;
+        }
+        const seenFieldKeys = new Set();
+
+        for (const entry of columnEntries) {
+          const { column, templateWidget } = entry;
+          const fieldWidget = this.resolveRowFieldWidget(row, templateWidget);
+
+          if (!isCellFieldRequired(column, fieldWidget)) {
+            continue;
+          }
+          if (shouldSkipCellValidation(fieldWidget)) {
+            continue;
+          }
+
+          const property = getCellFieldKey(fieldWidget, column);
+          const dedupeKey = column.prop || property;
+          if (!dedupeKey || seenFieldKeys.has(dedupeKey)) {
+            continue;
+          }
+          seenFieldKeys.add(dedupeKey);
+
+          if (!isEmptyCellValueInRow(row, fieldWidget, column)) {
+            continue;
+          }
+
+          const validationRowIndex = this.getValidationRowIndex(
+            row,
+            rows,
+            rowIndex
+          );
+          const propName = buildTableCellFormProp(
+            tableFieldKeyName,
+            validationRowIndex,
+            property
+          );
+          const message = buildCellRequiredHint(
+            fieldWidget,
+            column,
+            this.$t1.bind(this)
+          );
+
+          this.locateValidationError(row, propName);
+          return message;
+        }
+      }
+
+      return null;
+    },
+    setRequired(required) {
+      this.$set(this.widget.options, "required", !!required);
+    },
     selectWidget: function (e) {
       this.designer.setSelected(e);
     },
@@ -719,19 +923,14 @@ modules = {
         return result;
       }
       if (Array.isArray(result)) {
-        return this.normalizeDynamicColumns(result);
+        return normalizeDynamicColumnList(result);
       }
       if (typeof result !== "object") {
         return result;
       }
       const normalized = { ...result };
       if (Array.isArray(result.columns)) {
-        normalized.columns = this.normalizeDynamicColumns(result.columns);
-      }
-      if (Array.isArray(result.tableColumns)) {
-        normalized.tableColumns = this.normalizeDynamicColumns(
-          result.tableColumns
-        );
+        normalized.columns = normalizeDynamicColumnList(result.columns);
       }
       return normalized;
     },
@@ -796,6 +995,17 @@ modules = {
       const effectiveColumns = this.getEffectiveTableColumns(forceDynamic);
       this.attachTableColumnWidgets(effectiveColumns);
       this.syncEffectiveColumnWidgetFieldKeys(effectiveColumns);
+      this.afterDynamicColumnsCommonWidget(effectiveColumns);
+    },
+    afterDynamicColumnsCommonWidget(tableColumns) {
+      if (this.getDynamicColumnSourceType() === "none") return;
+      const formRef = this.getFormRef();
+      if (!formRef || formRef.designState) return;
+      this.$nextTick(() => {
+        if (formRef.hanldeCommonWidgetForTableColumns) {
+          formRef.hanldeCommonWidgetForTableColumns(tableColumns);
+        }
+      });
     },
     shouldSkipDynamicColumnsOnInit() {
       return (
@@ -836,6 +1046,7 @@ modules = {
             const reloadResult = $grid.reloadColumn(columns);
             const finish = () => {
               this.initFieldSchemaData(true);
+              this.afterDynamicColumnsCommonWidget(effectiveColumns);
               resolve(columns);
             };
             if (reloadResult?.then) {
@@ -879,95 +1090,51 @@ modules = {
     refreshColumnVisible() {
       return this.applyTableColumnsReload();
     },
-    normalizeDynamicColumnItem(item, index) {
-      if (!item || typeof item !== "object") {
-        return null;
-      }
-      const prop =
-        item.prop ?? item.field ?? item.name ?? item.key ?? undefined;
-      const label = item.label ?? item.title ?? undefined;
-      let formatS = item.formatS || item.format || null;
-      let editFormatS = item.editFormatS || null;
-      const widgetOptions = item.widgetOptions;
-      const editWidgetOptions = item.editWidgetOptions;
-
-      const normalized = {
-        ...item,
-        columnId: item.columnId || `${Date.now()}_${index}`,
-        prop,
-        label,
-        width: item.width ?? 150,
-        show: item.show !== false,
-        sortable: item.sortable !== false,
-        filterable: item.filterable !== false,
-        align: item.align || "left",
-        formatS,
-        editFormatS: editFormatS || undefined,
-        widgetOptions,
-        editWidgetOptions: editWidgetOptions || undefined,
-      };
-      delete normalized.columnOption;
-      delete normalized.editColumnOption;
-      return normalized;
-    },
-    normalizeDynamicColumns(columns) {
-      if (!Array.isArray(columns)) {
-        return [];
-      }
-      return columns
-        .map((item, index) => this.normalizeDynamicColumnItem(item, index))
-        .filter(Boolean);
-    },
     buildDynamicColumnRequestData(options = {}) {
       if (options.data !== undefined) {
         return options.data;
       }
-      const paramScript = this.widget.options.dynamicColumnScriptParam;
-      let customParam = {};
-      if (paramScript) {
-        customParam =
-          (this.handleCustomParam &&
-            this.handleCustomParam(paramScript)) ||
-          this.handleCustomEvent(paramScript) ||
-          {};
-      }
       const formRef = this.getFormRef();
       const reportTemplate = formRef.reportTemplate || {};
-      return {
-        formCode: reportTemplate.formCode,
-        formVersion: reportTemplate.formVersion,
-        taBm: this.fieldKeyName,
-        data: {
-          dataId: this.formDataId,
-          formData: this.globalModel?.formModel || {},
-          ...customParam,
-        },
+      const paramScript = getDynamicSchemaOption(
+        this.widget.options,
+        "scriptParam"
+      );
+      const handleParam = (script) => {
+        if (this.handleCustomParam) {
+          const customResult = this.handleCustomParam(script);
+          if (
+            customResult &&
+            typeof customResult === "object" &&
+            !Array.isArray(customResult)
+          ) {
+            return customResult;
+          }
+        }
+        return this.handleCustomEvent(script);
       };
+      return buildDynamicSchemaRequestData(
+        this.globalModel?.formModel || {},
+        paramScript,
+        handleParam,
+        {
+          formCode: reportTemplate.formCode,
+          formVersion: reportTemplate.formVersion,
+          taBm: this.fieldKeyName,
+          dataId: this.formDataId,
+        }
+      );
     },
     convertDynamicColumnResponse(res, options = {}) {
       const convertScript =
-        options.convertScript ?? this.widget.options.onDynamicColumnsConvert;
-      if (convertScript) {
-        const result = this.handleCustomEvent(convertScript, ["res"], [res]);
-        if (Array.isArray(result)) {
-          return this.normalizeDynamicColumns(result);
-        }
-        if (result?.columns) {
-          return this.normalizeDynamicColumns(result.columns);
-        }
-        return [];
-      }
-      const objx = res?.objx;
-      if (Array.isArray(objx)) {
-        return this.normalizeDynamicColumns(objx);
-      }
-      if (objx?.columns && Array.isArray(objx.columns)) {
-        return this.normalizeDynamicColumns(objx.columns);
-      }
-      if (objx?.tableColumns && Array.isArray(objx.tableColumns)) {
-        return this.normalizeDynamicColumns(objx.tableColumns);
-      }
-      return [];
+        options.convertScript ??
+        getDynamicSchemaOption(this.widget.options, "convert");
+      const items = resolveDynamicSchemaResponse(
+        res,
+        convertScript,
+        this.handleCustomEvent.bind(this)
+      );
+      return normalizeDynamicColumnList(items);
     },
     loadDynamicColumns(options = {}) {
       const source = this.getDynamicColumnSourceType();
@@ -1197,13 +1364,16 @@ modules = {
       let tableWidgetName = this.widget.options.name;
       let isEditTable = this.widget.options.isEditTable || false;
       const createColumn = (t, isChild) => {
-        let filterable = t.filterable ?? true;
+        const isActionCol = isActionColumnFormat(t.formatS, t.type);
+        let filterable = isActionCol
+          ? t.filterable === true
+          : t.filterable !== false;
         let filterType = filterable ? null : false;
         let col = {
           fixed: !!t.fixed && t.fixed,
           field: t.prop,
           title: this.getI18nLabel(t.label),
-          sortable: t.sortable,
+          sortable: isActionCol ? t.sortable === true : t.sortable !== false,
           filterType,
           align: t.align ? t.align : "center",
           formatter: this.formatterValue,
@@ -1283,7 +1453,7 @@ modules = {
           ...columnOption,
           widget,
           formatS: t.formatS,
-          required: t.required || false,
+          required: resolveColumnRequiredFlag(t),
           columnConfig: t,
           editWidget,
           utcTransformEnabled:
@@ -1435,8 +1605,8 @@ modules = {
         return null;
       } else {
         let resultList = [];
-        let labelField = fieldWidget.options.labelKey || "label";
-        let valueField = fieldWidget.options.valueKey || "value";
+        let labelField = this.getOptionItemLabelKey(fieldWidget);
+        let valueField = this.getOptionItemValueKey(fieldWidget);
         fieldWidget.options.optionItems.forEach((oItem) => {
           if (
             oItem[valueField] === fieldModel ||
@@ -2366,13 +2536,7 @@ modules = {
           let rows = res.objx ? res.objx.records || res.objx || [] : [];
 
           // that.handleNullValue(rows);
-          let defaultRow = this.createNewTableData();
-          rows = rows.map((row) => {
-            return {
-              ...defaultRow,
-              ...row,
-            };
-          });
+          rows = this.normalizeTableRows(rows, false);
           this.initValue(rows);
           this.$nextTick(() => {
             /*if (this.widget.options.isTreeTable) {
@@ -2575,13 +2739,18 @@ modules = {
         defaultValueEnabled !== false
       ) {
         nullValue = defaultValue;
+      } else if (widgetType === "number") {
+        nullValue = undefined;
       } else if (widgetType === "select" && widget.options.multiple) {
         nullValue = [];
       } else if (widgetType === "date" && widget.options.type === "dates") {
         nullValue = [];
       } else if (widgetType === "vabsearch" && widget.options.multipleChoices) {
         nullValue = [];
-      } else if (multiWidgetTypes.includes(widgetType)) {
+      } else if (
+        multiWidgetTypes.includes(widgetType) ||
+        isAttachmentWidgetType(widgetType)
+      ) {
         nullValue = [];
       }
       return nullValue;
@@ -2594,13 +2763,13 @@ modules = {
       }
       return result;
     },
-    handleWidgetNullValue(widget, newData) {
+    handleWidgetNullValue(widget, newData, defaultValueEnabled = true) {
       if (!widget || !newData) return;
       if (this.getIsFormWidget(widget)) {
         let field = this.getFieldKeyName(widget);
         let nullValue = newData.hasOwnProperty(field)
           ? null
-          : this.getColumnNullValue(widget);
+          : this.getColumnNullValue(widget, defaultValueEnabled);
         newData[field] = nullValue;
         if (this.isSingerlSearch(widget)) {
           let vabSearchName = widget.options.vabSearchName;
@@ -2631,7 +2800,11 @@ modules = {
             }
           } else {
             if (widget) {
-              this.handleWidgetNullValue(widget, newData, defaultValueEnabled);
+              this.handleWidgetNullValue(
+                widget,
+                newData,
+                defaultValueEnabled
+              );
             } else {
               newData[item.prop] = null;
             }
@@ -2682,7 +2855,10 @@ modules = {
 
       let fieldKeyName = this.getFieldKeyName(this.widget);
       let property = this.getFieldKeyName(rowWidget);
-      if (this.isVabsearchFlagWidget(rowWidget)) {
+      if (
+        this.isVabsearchFlagWidget(rowWidget) &&
+        !isVabsearchMultiWidget(rowWidget)
+      ) {
         property = rowWidget.options.vabSearchName || property;
       }
       let rowIndex = Math.max(obj.rowIndex, 0);
@@ -2745,7 +2921,10 @@ modules = {
       let rowIndex = $grid.getRowIndex(row);
       let fieldKeyName = this.getFieldKeyName(this.widget);
       let property = this.getFieldKeyName(widget);
-      if (this.isVabsearchFlagWidget(widget)) {
+      if (
+        this.isVabsearchFlagWidget(widget) &&
+        !isVabsearchMultiWidget(widget)
+      ) {
         property = widget.options.vabSearchName || property;
       }
       let propName = fieldKeyName + "." + rowIndex + "." + property;
@@ -2779,11 +2958,10 @@ modules = {
         }
 
         let property = this.getFieldKeyName(fieldWidget);
-        if (obj.row[property] && Array.isArray(obj.row[property])) {
-          return "false";
-        }
-        // let property = obj.column.property
-        if (this.isVabsearchFlagWidget(fieldWidget)) {
+        if (
+          this.isVabsearchFlagWidget(fieldWidget) &&
+          !isVabsearchMultiWidget(fieldWidget)
+        ) {
           property = fieldWidget.options.vabSearchName || property;
         }
         let propName = fieldKeyName + "." + rowIndex + "." + property;