bri-components 1.4.84 → 1.4.85

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "bri-components",
-    "version": "1.4.84",
+    "version": "1.4.85",
     "author": "dengshanghui",
     "description": "a component lib for vue project",
     "main": "src/index.js",

package/src/components/controls/base/DshDate/DshDaterange.vue

@@ -143,13 +143,20 @@
         methods: {
             /* -------- 方法 ------- */
             getOptions (index) {
+                const compareDate = this[`curVal${index === 0 ? 1 : 0}`];
+                const compareDateStr = this.$transformToDateStr(compareDate, "/", this.subType);
+                const compareOperator = index === 0 ? "ltAet" : "gtAet";
+
                 return {
                     shortcuts: this.getShortCuts(index),
                     disabledDate: (date) => {
                         const curDateStr = this.$transformToDateStr(date, "/", this.subType);
                         const rangeBool = this.$isWithinRange(curDateStr, this.selfPropsObj._minDate, this.selfPropsObj._maxDate);
+                        const compareBool = compareDateStr
+                            ? !this.$isComparedAccord(curDateStr, compareDateStr, compareOperator, "date", this.subType, this.subType)
+                            : false;
 
-                        return !rangeBool;
+                        return !rangeBool || compareBool;
                     }
                 };
             }

package/src/components/controls/senior/cascaderTable.vue

@@ -63,6 +63,7 @@
                         }"
                         :allFormList="allFormList"
                         :parentObj="value"
+                        :treeColumns="treeForm"
                     ></dsh-tree-table>
                 </div>
             </dsh-modal>
@@ -104,6 +105,7 @@
                         :propsObj="defaultPropsObj"
                         :allFormList="allFormList"
                         :parentObj="value"
+                        :treeColumns="treeForm"
                         @change="change"
                     ></dsh-tree-table>
                 </template>
@@ -144,6 +146,7 @@
                     :propsObj="selfPropsObj"
                     :allFormList="allFormList"
                     :parentObj="value"
+                    :treeColumns="treeForm"
                     @change="change"
                 ></dsh-tree-table>
             </template>

package/src/components/list/mixins/DshCascaderTableMixin.js

@@ -1,14 +1,7 @@
 export default {
     mixins: [],
     components: {},
-    props: {
-        treeColumns: {
-            type: Array,
-            default () {
-                return [];
-            }
-        }
-    },
+    props: {},
     data () {
         return {};
     },
@@ -26,215 +19,225 @@ export default {
         oldReadonlyTreeColKeys () {
             return this.isDftSet ? [] : this.selfPropsObj._oldReadonlyTreeColKeys || []; // 配置端有问题，高级依赖时值成undefined了
         },
-
         // 替换tableBaseMixin里的
         noborderColKeys () {
             return [
-                ...this.treeColumns.map(colItem => colItem._key),
+                ...this.treeColKeys,
                 ...this.selfPropsObj._noborderColKeys
             ];
         },
+        // 替换tableBaseMixin里的
         showCreateBtnColKeys () {
             return [
-                ...this.treeFormKeys,
+                ...this.treeColKeys,
                 ...(this.selfPropsObj._showCreateBtnColKeys || [])
             ];
         },
+        // 替换tableBaseMixin里的
         searchTitle () {
             return `${this.isSearching ? "筛选" : "全部"}数据，共 ${this.selfTotal} 条；`;
         },
 
+        /* --- 列字段 --- */
+        showColumns () {
+            return [
+                ...this.$transformToColumns(this.showContentColumns),
+                ...(!this.isSearching && this.rowOperationList.length ? [this.selfOperationColumn] : [])
+            ];
+        },
+        //  替换tableBaseMixin里的
+        contentColumns () {
+            return [
+                ...this.treeColumns.reduce((arr, colItem) => ([
+                    ...arr,
+                    {
+                        ...colItem,
+                        colType: "tree"
+                    },
+                    ...colItem._treeSubForm.map(subColItem => ({
+                        ...subColItem,
+                        colType: "summary",
+                        nodeKey: colItem._key
+                    }))
+                ]), []),
+                ...this.usedColumns.map(colItem => ({
+                    ...colItem,
+                    colType: "data",
+                    nodeKey: this.treeColKeys[this.treeColKeys.length - 1]
+                }))
+            ].map(colItem => ({
+                renderHeaderCell: ({ column }, h) => {
+                    return this.contentThCellRender(h, { column });
+                },
+                renderBodyCell: ({ row, rowIndex, column }, h) => {
+                    row = row[column.nodeKey || column._key];
+
+                    return column.colType === "summary"
+                        ? this.getSummaryTdVal({ row, rowIndex, column })
+                        : this.contentTdCellRender(h, { row, rowIndex, column });
+                },
+                ...colItem
+            }));
+        },
+        selfOperationColumn () {
+            return {
+                ...this.operationColumn,
+                nodeKey: this.treeColKeys[this.treeColKeys.length - 1],
+                renderBodyCell: ({ row, rowIndex, column }, h) => {
+                    row = row[column.nodeKey || column._key];
+
+                    return this.operationTdCellRender(h, { row, rowIndex, column });
+                }
+            };
+        },
+
+        /* --- 数据 --- */
         allTreeData () {
-            return this.getCalcuedTree(this.data, this.treeColumns, this.selfColumns);
+            // console.log("allTreeData");
+            return this.getCalcuedTree(this.data, this.selfColumns, this.treeColumns);
         },
         allListData () {
-            return this.$getTreeFlatArr(this.data, node => !(node.children && node.children.length));
+            // console.log("allListData");
+            return this.$getTreeFlatArr(this.allTreeData, node => !(node.children && node.children.length));
         },
         showListData () {
-            return this.transformRows(this.allTreeData, this.treeColumns);
-        },
+            // console.log("showListData");
+            const loop = (nodes = [], finalRows = []) => {
+                // 先层层过滤
+                const subLoop = (nodes = []) =>
+                    nodes.filter(row =>
+                        row.children && row.children.length
+                            ? !!subLoop(row.children).length
+                            : this.isSearching
+                                ? this.$isAdvRelyAccord(this.finalTableAdvSearch, row)
+                                : true
+                    );
+                nodes = subLoop(nodes);
 
-        showColumns () {
-            return this.mergeColumns(this.treeColumns);
+                return nodes.reduce((rows, node, nodeIndex) => {
+                    // 创建行，并把节点数据（对象类型）注入到行对象内
+                    if (nodeIndex !== 0 || rows.length === 0) {
+                        rows.push({
+                            _id: this.$ObjectID().str
+                        });
+                    }
+                    const curCol = this.treeColumns[node.level - 1];
+                    const curRow = rows[rows.length - 1];
+                    Object.assign(curRow, { [curCol._key]: node });
+
+                    // 判断是否叶子节点，做对应操作
+                    if (node.children && node.children.length) {
+                        const oldLength = rows.length - 1;
+                        const newRows = loop(node.children, rows);
+                        node.total = newRows.length - oldLength;
+                        return newRows;
+                    } else {
+                        return rows;
+                    }
+                }, finalRows);
+            };
+
+            return loop(this.allTreeData);
         }
     },
-    created () {
-        this.init();
-    },
+    created () { },
     mounted () { },
     methods: {
-        // 初始化
-        init () {
-            this.treeColumns.forEach((treeFormItem, treeFormIndex) => {
-                this.$set(treeFormItem, "level", treeFormIndex + 1);
-                // this.$set(treeFormItem, "canDelete", true);
-            });
-        },
-
         // 转化树数据
-        getCalcuedTree (nodes = [], treeForm = [], subForm = []) {
-            treeForm.forEach((treeFormItem, treeFormIndex) => {
-                // treeFormItem.canDelete = true; // 每次计算，重置一下
-                treeFormItem.level = treeFormIndex + 1; // treeColumns更新,缺少level
-            });
-
-            // 循环遍树节点
+        getCalcuedTree (nodes = [], subCols = [], treeCols = []) {
             const loop = (nodes = [], parentNodes = []) => {
-                nodes.forEach(rowItem => {
+                nodes.forEach(row => {
                     // 初始化树节点的数据，给节点加上一些属性并监测，注入到节点对象中
-                    let curCol = treeForm[rowItem.level - 1];
-                    this.$setObj(rowItem, {
+                    let curCol = treeCols[row.level - 1];
+                    this.$setObj(row, {
                         _key: curCol._key,
-                        level: curCol.level,
                         isLeaf: false,
                         total: 1
                     });
 
-                    // 最后一列（根节点）
-                    if (rowItem.level === treeForm.length) {
-                        rowItem.children = [];
-                        rowItem.isLeaf = true;
+                    // 根节点
+                    if (row.level === treeCols.length) {
+                        row.children = [];
+                        row.isLeaf = true;
 
                         // // TODO：特殊处理-叶子节点上注入对应表头列们的name值
-                        // const treeNodes = [...parentNodes, rowItem];
-                        // treeForm.forEach((treeFormItem, treeFormIndex) => {
-                        //     rowItem[treeFormItem._key] = treeNodes[treeFormIndex].name;
-                        //     // this.$set(rowItem, treeFormItem._key, treeNodes[treeFormIndex].name)
+                        // const treeNodes = [...parentNodes, row];
+                        // treeCols.forEach((colItem, colIndex) => {
+                        //     row[colItem._key] = treeNodes[colIndex].name;
                         // });
                     }
-                    // 非最后一列（最后一列前的列，非根节点），需继续向下循环
+                    // 非根节点，需继续向下循环
                     else {
-                        // 非最后一列的 正常的非根节点
-                        if (rowItem.children && rowItem.children.length) {
-                            loop(rowItem.children, [...parentNodes, rowItem]);
+                        // 正常的非根节点
+                        if (row.children && row.children.length) {
+                            loop(row.children, [...parentNodes, row]);
                         }
-                        // 非最后一列的 新增的非根节点(此时是新增一列或新增非根节点行) -添加一个子节点，并把该节点上的subForm属性值全部给下级节点
-                        // 特别提示：新增的是根节点行，不会走此处代码
+                        // 特殊的非根节点(此时是新增一列 或 新增了非根节点行) -添加一个子节点，并把该节点上的subForm属性值全部给下级节点（新增的是根节点行，不会走此处代码）
                         else {
-                            const newNode = this.getNewRowData(rowItem.level + 1, rowItem.children);
-
-                            subForm.forEach(subFormItem => {
-                                // 用$set也可以
-                                newNode[subFormItem._key] = rowItem[subFormItem._key];
-                                delete rowItem[subFormItem._key];
+                            const newNode = this.getNewRowData(row.level + 1, row.children);
+                            subCols.forEach(subCol => {
+                                newNode[subCol._key] = row[subCol._key]; // 用$set也可以
+                                delete row[subCol._key];
                             });
-                            rowItem.children.push(newNode);
+                            row.children.push(newNode);
 
-                            loop(rowItem.children, [...parentNodes, rowItem]);
+                            loop(row.children, [...parentNodes, row]);
                         }
                     }
 
-                    this.fixRowItem(rowItem);
+                    this.fixRowData(row);
                 });
             };
-            loop(nodes);
 
-            this.isDeleteColStatus = false;
+            loop(nodes);
             this.initFlag = false;
             return nodes;
         },
-        // 转化表格数据
-        transformRows (nodes = [], treeForm = []) {
-            const loop = (nodes = [], rows = []) => {
-                nodes = this.getFilteredNodes(nodes);
-
-                return nodes.reduce((rows, node, nodeIndex) => {
-                    // 创建行，并把节点数据（对象类型）注入到行对象内
-                    if (nodeIndex !== 0 || rows.length === 0) {
-                        rows.push({
-                            _id: this.$ObjectID().str,
-                            __isRendered__: true,
-                            __isShow__: true,
-                            __isTmpShow__: true
-                            // __isSearchShow__: false,
-                            // __isExpand__: false,
-                        });
-                    }
-                    const curCol = treeForm[node.level - 1];
-                    const curRow = rows[rows.length - 1];
-                    Object.assign(curRow, { [curCol._key]: node });
-
-                    // 判断是否叶子节点，做对应操作
-                    if (node.children && node.children.length) {
-                        const oldLength = rows.length - 1;
-                        const newRows = loop(node.children, rows);
-                        node.total = newRows.length - oldLength;
-                        return newRows;
-                    } else {
-                        return rows;
-                    }
-                }, rows);
-            };
-            return loop(nodes);
+        fixSelfRowData (row) {
+            if (this.initFlag) {
+                // 根节点
+                if (!(row.children && row.children.length)) {
+                    // 每条数据都补充全所有字段值（赋一个默认的空值）
+                    this.selfColumns.forEach((colItem) => {
+                        // 不用row[colItem._key] === undefined判断，是因为后端给的空值不可靠，多选的有时候都能给null
+                        if (!Object.prototype.hasOwnProperty.call(row, colItem._key) && this.$isEmptyData(row[colItem._key])) {
+                            this.$set(row, colItem._key, this.$deepCopy(this.dftInitValMap[colItem._type]));
+                        }
+                    });
+                }
+            }
         },
-        // 合并表头
-        mergeColumns (treeForm = [], subForm = this.showContentColumns) {
-            return this.$transformToColumns(
-                [
-                    ...treeForm.reduce((arr, treeFormItem) => ([
-                        ...arr,
-                        {
-                            ...treeFormItem,
-                            colType: "tree"
-                        },
-                        ...treeFormItem._treeSubForm.map(treeSubFormItem => ({
-                            ...treeSubFormItem,
-                            nodeKey: treeFormItem._key,
-                            colType: "summary"
-                        }))
-                    ]), []),
-                    ...subForm.map(subFormItem => ({
-                        ...subFormItem,
-                        nodeKey: treeForm[treeForm.length - 1]._key,
-                        colType: "data"
-                    })),
-                    ...(
-                        !this.isSearching && this.rowOperationList.length
-                            ? [{
-                                ...this.operationColumn,
-                                nodeKey: treeForm[treeForm.length - 1]._key,
-                                colType: "operation"
-                            }]
-                            : []
-                    )
-                ].map(colItem => ({
-                    ...colItem,
-                    renderHeaderCell: ({ column }, h) => {
-                        return this.contentThCellRender(h, { column });
-                    },
-                    renderBodyCell: ({ row, rowIndex, column }, h) => {
-                        row = row[column.nodeKey || column._key];
 
-                        return column.colType === "summary"
-                            ? this.getSummaryTdVal({ row, rowIndex, column })
-                            : column.colType === "operation"
-                                ? this.operationTdCellRender(h, { row, rowIndex, column })
-                                : this.contentTdCellRender(h, { row, rowIndex, column });
-                    }
-                }))
-            );
-        },
-        getFilteredNodes (nodes = []) {
-            const loop = (nodes = []) => {
-                return nodes.filter(rowItem => {
-                    if (rowItem.children && rowItem.children.length) {
-                        if (this.isSearching) {
-                            rowItem.__isSearchShow__ = true;
-                        }
+        // 单元格 -汇总节点单元格-获取值
+        getSummaryTdVal ({ row, rowIndex, column }) {
+            const calFieldFormItem = this.selfColumns.find(item => item._key === column._calField);
 
-                        const children = loop(rowItem.children);
-                        return !!children.length;
-                    } else {
-                        return this.dealSearchShow(rowItem);
-                    }
-                });
-            };
+            if (column._calField && calFieldFormItem && column._operator) {
+                const loop = (nodes, arr = []) =>
+                    nodes.reduce((arr, node) => {
+                        return node.children.length
+                            ? loop(node.children, arr)
+                            : [
+                                ...arr,
+                                node[column._calField] || 0
+                        ];
+                    }, arr);
+                const list = loop(row.children);
 
-            return loop(nodes);
+                return this.$calNumList(list, column._operator, calFieldFormItem);
+            } else {
+                return !column._calField && !column._operator
+                    ? "未选择来源列和算法"
+                    : !column._calField
+                        ? "未选择来源列"
+                        : !calFieldFormItem
+                            ? `来源列${column._calField}被删除`
+                            : "未选择算法";
+            }
         },
-
         bodyCellSpan ({ row, rowIndex, column }) {
             row = row[column.nodeKey || column._key];
+
             return {
                 rowspan: row
                     ? row.total || 1
@@ -242,36 +245,7 @@ export default {
                 colspan: 1
             };
         },
-        // 单元格 -汇总节点单元格-获取值
-        getSummaryTdVal ({ row, rowIndex, column }) {
-            if (column._calField && column._operator) {
-                const calFieldFormItem = this.selfColumns.find(item => item._key === column._calField);
 
-                if (calFieldFormItem) {
-                    let loop = (nodes, arr) => {
-                        return nodes.reduce((arr, node) => {
-                            if (node.children.length) {
-                                return loop(node.children, arr);
-                            } else {
-                                arr.push(node[column._calField] || 0);
-                                return arr;
-                            }
-                        }, arr);
-                    };
-                    let list = loop(row.children, []);
-
-                    return this.$calNumList(list, column._operator, calFieldFormItem);
-                } else {
-                    return `来源列${column._calField}被删除`;
-                }
-            } else {
-                return !column._calField && !column._operator
-                    ? "未选择来源列和算法"
-                    : !column._calField
-                        ? "未选择来源列"
-                        : "未选择算法";
-            }
-        },
         // 加工单元格对应的配置
         getSelfResetCol ({ row, rowIndex, column }) {
             return column.colType === "tree"
@@ -286,16 +260,16 @@ export default {
             return (this.getIsDftRow(row) ? !this.dftReadonlyTreeColKeys.includes(column._key) : true) && // 默认行的某列是否可编辑
             (row.__old__ === true ? !this.oldReadonlyTreeColKeys.includes(column._key) : true); // 老数据行里某些列不可编辑
         },
-        // getNewRowData时，额外补充的行相关的数据（针对层级属性的列）
-        getSelfNewRowData (level, list = []) {
-            const column = this.treeForm[level - 1];
-            const dftVal = column._default;
-            const initDftVal = this.initDftValMap[column._type];
+        // getNewRowData时，额外补充的行相关的数据（针对层级列）
+        getSelfNewRowData (level) {
+            const column = this.treeColumns[level - 1];
 
             return {
-                name: this.$isEmptyData(dftVal)
-                    ? initDftVal
-                    : dftVal
+                name: this.$deepCopy(
+                    this.$isEmptyData(dftVal)
+                        ? this.dftInitValMap[column._type]
+                        : column._default
+                )
             };
         }
     }