aldehyde 0.2.229 → 0.2.231

package/src/aldehyde/table/column/summary-builder.tsx

@@ -0,0 +1,713 @@
+import {BigNumber} from "bignumber.js";
+import Table from "../control-table-x-axis-wrapper";
+import React from "react";
+import "../index.css";
+interface SummaryColProps {
+    columns: any[];
+    translate: (...strs: string[]) => string;
+    summaryConfigs:{
+        title?:string,
+    id: string;
+    aggFunc: "sum" | "avg" | "groupIsum" | "groupIavg";
+}[];
+    pageData:any,
+     rowSelection,groupIColumns
+}
+
+export default {
+    summary(summaryColProps:SummaryColProps) {
+        const {translate,summaryConfigs,pageData,columns,
+            rowSelection,groupIColumns}=summaryColProps;
+        if (
+            !summaryConfigs ||
+            summaryConfigs?.length === 0 ||
+            pageData.length === 0
+        )
+            return <></>;
+       // const isProSumarryTable = Boolean(subtotalXColumn);
+        // const columns = isProSumarryTable
+        //     ? proSummaryTableColumns
+        //     : columns_;
+        //const columns= columns_;
+        const sumConfigs: {
+            sum: { value: string; id: string; columnConfig?: any }[];
+            avg: { value: string; id: string; columnConfig?: any }[];
+        } = { sum: [], avg: [] };
+
+        if (rowSelection) {
+            sumConfigs["avg"].push({
+                value: "",
+                id: "",
+                columnConfig: { align: "center" },
+            });
+            sumConfigs["sum"].push({
+                value: "",
+                id: "",
+                columnConfig: { align: "center" },
+            });
+        }
+
+        sumConfigs["sum"].push({
+            value: translate("${合计}"),
+            id: "title",
+            columnConfig: { align: "center" },
+        });
+        sumConfigs["avg"].push({
+            value: translate("${均值}"),
+            id: "title",
+            columnConfig: { align: "center" },
+        });
+
+        let sumLen = 0,
+            avgLen = 0;
+
+        for (let i = 0; i < columns.length; i++) {
+            const idx = i,
+                dataIndex = columns[i].dataIndex;
+            if (idx === 0) continue;
+            const sum = { value: "", id: "", columnConfig: columns[i] };
+            const sumConfigIdx = summaryConfigs.findIndex(
+                ({ id ,title}) => id === dataIndex || title===dataIndex
+            );
+
+            if (sumConfigIdx === -1) {
+                sumConfigs["sum"].push(sum);
+                sumConfigs["avg"].push(sum);
+                continue;
+            }
+            const argFun = summaryConfigs[sumConfigIdx].aggFunc;
+            if (argFun === "sum")
+                sum.value = pageData
+                    .reduce(
+                        (lastNum, item) =>
+
+                            lastNum.plus(
+                                new BigNumber(
+                                    this.getTableSummaryNumberValue(item[dataIndex])
+                                )
+                            ),
+                        new BigNumber(0)
+                    )
+                    ?.toString();
+            if (argFun === "avg")
+                sum.value = pageData
+                    .reduce(
+                        (lastNum, item) =>
+                            lastNum.plus(
+                                new BigNumber(
+                                    this.getTableSummaryNumberValue(item[dataIndex])
+                                ).div(pageData.length)
+                            ),
+                        new BigNumber(0)
+                    )
+                    ?.toString();
+
+            const hash = (...args) => args.join("-");
+            const hashKey = (data, keys) =>
+                hash(...keys.map((key) => data[key]));
+
+            if (argFun === "groupIsum") {
+                const allKeys = groupIColumns?.map(({ id }) => id);
+                const set = new Set();
+
+                sum.value = pageData
+                    .reduce((lastNum, item) => {
+                        if (set.has(hashKey(item, allKeys))) return lastNum;
+                        set.add(hashKey(item, allKeys));
+                        return lastNum.plus(
+                            new BigNumber(
+                                this.getTableSummaryNumberValue(item[dataIndex])
+                            )
+                        );
+                    }, new BigNumber(0))
+                    ?.toString();
+            }
+
+            if (argFun === "groupIavg") {
+                const set = new Set();
+                let nums = 0;
+                const allKeys = groupIColumns?.map(({ id }) => id);
+
+                pageData.forEach((item) => {
+                    if (set.has(hashKey(item, allKeys))) return;
+                    set.add(hashKey(item, allKeys));
+
+                    nums++;
+                });
+
+                set.clear();
+
+                sum.value = pageData
+                    .reduce((lastNum, item) => {
+                        if (set.has(hashKey(item, allKeys))) return lastNum;
+                        set.add(hashKey(item, allKeys));
+                        return lastNum.plus(
+                            new BigNumber(
+                                this.getTableSummaryNumberValue(item[dataIndex])
+                            ).div(nums)
+                        );
+                    }, new BigNumber(0))
+                    ?.toString();
+            }
+
+            sum.id = dataIndex;
+            if (argFun === "avg" || argFun === "groupIavg") {
+                sumConfigs["avg"].push(sum);
+                avgLen++;
+            } else sumConfigs["avg"].push({ value: "", id: "" });
+
+            if (argFun === "sum" || argFun === "groupIsum") {
+                sumConfigs["sum"].push(sum);
+                sumLen++;
+            } else sumConfigs["sum"].push({ value: "", id: "" });
+        }
+
+        console.log("sumConfigs", sumConfigs, sumLen, avgLen);
+
+        return (
+            <>
+                {sumLen === 0 ? (
+                    <></>
+                ) : (
+                    <Table.Summary.Row>
+                        {sumConfigs["sum"].map(
+                            ({ id, value, columnConfig }, idx) => (
+                                <Table.Summary.Cell
+                                    align={columnConfig?.align}
+                                    index={idx}
+                                    className="heji"
+                                >
+                                    {value}
+                                </Table.Summary.Cell>
+                            )
+                        )}
+                    </Table.Summary.Row>
+                )}
+                {avgLen === 0 ? (
+                    <></>
+                ) : (
+                    <Table.Summary.Row>
+                        {sumConfigs["avg"].map(
+                            ({ id, value, columnConfig }, idx) => (
+                                <Table.Summary.Cell
+                                    align={columnConfig?.align}
+                                    index={idx}
+                                    className="heji"
+                                >
+                                    {value}
+                                </Table.Summary.Cell>
+                            )
+                        )}
+                    </Table.Summary.Row>
+                )}
+            </>
+        );
+    },
+
+    handleProSummaryTable(props: any) {
+        const {subtotalXColumn,columns: _columns,data,translate,groupIColumns}=props
+        const isProSumarryTable = Boolean(
+           subtotalXColumn
+        );
+        if (!isProSumarryTable)
+            return { proSummaryTableColumns: [], proSummaryTableData: [] };
+        const columns = _columns;
+
+        for (const column of columns) {
+            delete column["sorter"];
+        }
+
+        for (const d of data) {
+            for (const [k, v] of Object.entries(d)) {
+                if (v == null || v == "null") {
+                    d[k] = "";
+                } else if (typeof v === "string" && (v as string)?.includes("@R@")) {
+                    d[k] = (v as string).split("@R@")[1];
+                }
+            }
+        }
+
+        console.log("data", data);
+        console.log("columns", columns);
+
+        const colMp = {
+            dimension: [],
+            fact: [],
+            others: [
+                {
+                    dataIndex: "orderInGroup",
+                    title: "orderInGroup",
+                },
+            ],
+        };
+        const colIdToNameMp = {};
+        const colNameToIdMp = {};
+        for (const col of columns) {
+            colIdToNameMp[col["dataIndex"]] = col["title"];
+            colNameToIdMp[col["title"]] = col["dataIndex"];
+            if (col.statColType !== undefined) {
+                colMp[col.statColType].push(this.deepClone(col));
+            } else {
+                if (col.title !== "序号") colMp["others"].push(this.deepClone(col));
+            }
+        }
+        console.log("colIdToNameMp", colIdToNameMp);
+        console.log("colNameToIdMp", colNameToIdMp);
+        console.log("colMp", colMp);
+
+        // canReadData
+        const canReadData = [];
+        let order = 0;
+        for (const d of data) {
+            const item = {};
+            for (const [k, v] of Object.entries(d)) {
+                let _v = v;
+                if (
+                    colMp.fact.findIndex(({ dataIndex }) => dataIndex === k) > -1 &&
+                    v === null
+                )
+                    _v = 0;
+                item[colIdToNameMp[k]] = _v;
+            }
+            canReadData.push({ ...item, orderInGroup: order++ });
+        }
+        console.log("canReadData", canReadData);
+
+        let proSummaryTableColumns = [
+                ...this.deepClone(colMp.dimension),
+                ...this.deepClone(colMp.others),
+            ],
+            proSummaryTableData = [],
+            excludeGroupSumData = [];
+        const cal = colMp.fact[0]?.cal;
+        const calTxt = cal === "sum" ? translate("${小计}") : translate("${均值}");
+        const calMp = {};
+        colMp.fact.forEach(({ title, cal }) => (calMp[title] = cal));
+
+        // 计算列
+        proSummaryTableColumns.push(...colMp.fact);
+
+        // buildData
+        this.buildColTag(proSummaryTableColumns);
+
+        // 处理行
+        const rowMp = {};
+        const rowKey = [];
+        for (const col of proSummaryTableColumns) {
+            if (Array.isArray(col.keys) && col.keys.length === 1) rowKey.push(col);
+        }
+        console.log("rowKey", rowKey);
+
+        for (const d of canReadData) {
+            let t: any = rowMp;
+            for (let i = 0; i < rowKey.length; i++) {
+                const key = rowKey[i].title;
+                if (t[d[key]] === undefined) {
+                    if (i !== rowKey.length - 1) t[d[key]] = {};
+                    else t[d[key]] = [];
+                }
+                t = t[d[key]];
+            }
+            if (Array.isArray(t)) t.push(d);
+        }
+
+        // 行数据处理完毕
+        console.log("rowMp", rowMp);
+
+        // 处理列
+        const colKey = [];
+        const colKeyTitle = this.flatSummaryCol(proSummaryTableColumns);
+        for (const col of proSummaryTableColumns) {
+            if (
+                (col.statColType === "fact" || Array.isArray(col.children)) &&
+                col.TYPE === undefined
+            ) {
+                colKey.push(col);
+            }
+        }
+        const flatSummaryColTitle = this.flatSummaryCol(colKey);
+        const flatSummaryRowTitle = this.flatSummaryCol(rowKey);
+        const flatSummaryCalTitle = this.flatSummaryCol(
+            proSummaryTableColumns.filter(({ TYPE }) => TYPE !== undefined)
+        );
+        console.log("colKey", colKey);
+        console.log("colKeyTitle", colKeyTitle);
+        console.log("flatSummaryColTitle", flatSummaryColTitle);
+        console.log("flatSummaryRowTitle", flatSummaryRowTitle);
+        console.log("flatSummaryCalTitle", flatSummaryCalTitle);
+
+        proSummaryTableData = this.handleColData(
+            rowMp,
+            flatSummaryRowTitle,
+            flatSummaryColTitle,
+            flatSummaryCalTitle,
+            cal
+        );
+
+        excludeGroupSumData = this.deepClone(proSummaryTableData);
+        console.log("excludeGroupSumData", excludeGroupSumData);
+
+        if (
+            subtotalXColumn &&
+            Array.isArray(subtotalXColumn) &&
+            subtotalXColumn.length
+        ) {
+            const sortKeys = subtotalXColumn.map(({ id }) => colIdToNameMp[id]);
+
+            const rowSumMp = this.buildRowMp(proSummaryTableData, sortKeys);
+            console.log("rowSumMp", rowSumMp);
+
+            const calRowKeys = [
+                ...flatSummaryCalTitle,
+                ...flatSummaryColTitle,
+            ].map((i) => this.buildKeys(i));
+            console.log("calRowKeys", calRowKeys);
+
+            proSummaryTableData = this.handleRowData(
+                rowSumMp,
+                calRowKeys,
+                calMp,
+                calTxt,
+                sortKeys[0],[],groupIColumns
+            );
+        }
+
+        // 序号
+        if (columns[0].title === "序号") {
+            const col: any = {
+                dataIndex: "序号",
+                title: "序号",
+                width: 60,
+                order: -1,
+            };
+            if (columns[0].colWidth) {
+                col.width = columns[0].colWidth;
+            }
+            proSummaryTableColumns.unshift(col);
+            proSummaryTableData.forEach((_, idx) => {
+                _["序号"] = idx + 1;
+            });
+        }
+
+
+        // 给小计和总计染色
+        this.stain(proSummaryTableColumns);
+
+        // 删除默认数据在组内顺序字段
+        proSummaryTableColumns.splice(
+            proSummaryTableColumns.findIndex(
+                ({ dataIndex }) => dataIndex === "orderInGroup"
+            ),
+            1
+        );
+
+        proSummaryTableData.forEach((item) => delete item.orderInGroup);
+
+        // 排序
+        proSummaryTableColumns = proSummaryTableColumns.sort((a, b) => {
+            if (a.order === undefined && b.order === undefined) return 0;
+            if (a.order === undefined) return 1;
+            if (b.order === undefined) return -1;
+            return a.order < b.order ? -1 : 1;
+        });
+
+        console.log("proSummaryTableColumns", proSummaryTableColumns);
+        console.log("proSummaryTableData", proSummaryTableData);
+
+        return { proSummaryTableColumns, proSummaryTableData };
+    },
+    deepClone(source, hash = new WeakSet()) {
+        try {
+            if (
+                typeof source !== "object" ||
+                source === null ||
+                React.isValidElement(source)
+            ) {
+                return source;
+            }
+            if (hash.has(source)) {
+                return source;
+            }
+
+            hash.add(source);
+            const target = Array.isArray(source) ? [] : {};
+            Reflect.ownKeys(source).forEach((key) => {
+                const val = source[key];
+                if (typeof val === "object" && val != null) {
+                    target[key] = this.deepClone(val, hash);
+                } else {
+                    target[key] = val;
+                }
+            });
+            return target;
+        } catch (err) {
+            console.log("deepclone err", err, source);
+        }
+    },
+    flatSummaryCol(arr, res = []) {
+        for (const i of arr) {
+            if (!i.children) res.push(i.keys);
+            else this.flatSummaryCol(i.children, res);
+        }
+        return res;
+    },
+    buildColTag(cols, keys = []) {
+        for (const col of cols) {
+            if (!col.children) {
+                col.dataIndex = this.buildKeys([
+                    ...keys,
+                    { dataKey: col._type ? col._type : col.title, title: col.title },
+                ]);
+                if (col.keys === undefined)
+                    col.keys = [
+                        ...keys,
+                        { dataKey: col._type ? col._type : col.title, title: col.title },
+                    ];
+            } else {
+                this.buildColTag(col.children, [
+                    ...keys,
+                    { dataKey: col._type ? col._type : col.title, title: col.title },
+                ]);
+            }
+        }
+    },
+
+    getCurCalKeys(cols, keys = []) {
+        for (const col of cols) {
+            if (Array.isArray(col.children)) {
+                this.getCurCalKeys(col.children, keys);
+            } else {
+                keys.push({
+                    factIndex: col.keys[col.keys.length - 1],
+                    dataIndex: col.dataIndex,
+                });
+            }
+        }
+
+        return keys;
+    },
+
+    setSumColKeys(sumCol, sumKeys) {
+        if (sumKeys.length === 0) return;
+        if (Array.isArray(sumCol.children)) {
+            this.setSumColKeys(sumCol.children, sumKeys);
+        } else {
+            for (const col of sumCol) {
+                const factKey = col.keys[col.keys.length - 1].dataKey;
+                col.sumDataIndex = sumKeys.filter(
+                    ({ factIndex: { dataKey } }) => dataKey === factKey
+                );
+                col.keys[col.keys.length - 1].sumDataIndex = col.sumDataIndex.map(
+                    ({ dataIndex }) => dataIndex
+                );
+            }
+        }
+    },
+    handleColData(
+        rowMp,
+        flatSummaryRowTitle,
+        flatSummaryColTitle,
+        flatSummaryCalTitle,
+        cal,
+        idx = 0,
+        data = {},
+        list = []
+    ) {
+        if (Array.isArray(rowMp)) {
+            for (const col of flatSummaryColTitle) {
+                const key = this.buildKeys(col);
+                const colTarget = [];
+                const preConditions = col.slice(0, col.length - 1);
+                const targetKey = col.slice(col.length - 1)[0].title;
+                for (const d of rowMp) {
+                    if (
+                        preConditions.every(({ dataKey, title }) => d[dataKey] === title)
+                    ) {
+                        colTarget.push(d);
+                    }
+                }
+
+                if (data[key] === undefined || data[key] == "") {
+                    data[key] = BigNumber(0);
+                }
+                if (cal === "sum")
+                    data[key] = colTarget.reduce(
+                        (last, d) => last.plus(BigNumber(d[targetKey])),
+                        BigNumber(0)
+                    );
+                if (cal === "avg")
+                    data[key] = colTarget.reduce(
+                        (last, d) =>
+                            last.plus(BigNumber(d[targetKey]).div(colTarget.length)),
+                        BigNumber(0)
+                    );
+                data[key] =
+                    data[key]?.toString() == "NaN" ? "0" : data[key]?.toString();
+            }
+
+            for (const calCol of flatSummaryCalTitle) {
+                const key = this.buildKeys(calCol);
+                const sumDataIndex = calCol[calCol.length - 1].sumDataIndex;
+
+                if (data[key] === undefined || data[key] == "")
+                    data[key] = BigNumber(0);
+                if (cal === "sum")
+                    data[key] = sumDataIndex.reduce(
+                        (last, dataKey) => last.plus(BigNumber(data[dataKey])),
+                        BigNumber(0)
+                    );
+                if (cal === "avg")
+                    data[key] = sumDataIndex.reduce(
+                        (last, dataKey) =>
+                            last.plus(BigNumber(data[dataKey]).div(sumDataIndex.length)),
+                        BigNumber(0)
+                    );
+                data[key] = data[key]?.toString();
+            }
+            list.push(data);
+        } else {
+            for (const [k, v] of Object.entries(rowMp)) {
+                const dataKey = flatSummaryRowTitle[idx][0].dataKey;
+                data[dataKey] = k;
+                this.handleColData(
+                    v,
+                    flatSummaryRowTitle,
+                    flatSummaryColTitle,
+                    flatSummaryCalTitle,
+                    cal,
+                    idx + 1,
+                    this.deepClone(data),
+                    list
+                );
+            }
+        }
+
+        return list;
+    },
+
+    buildRowMp(data, sortKeys, idx = 0, mp = {}) {
+        if (idx >= sortKeys.length) return data;
+
+        const dataKey = sortKeys[idx];
+
+        for (const d of data) {
+            if (mp[d[dataKey]] === undefined) mp[d[dataKey]] = [];
+            mp[d[dataKey]].push(d);
+        }
+
+        for (const [k, v] of Object.entries(mp)) {
+            mp[k] = this.buildRowMp(v, sortKeys, idx + 1);
+        }
+
+        return mp;
+    },
+
+    handleRowData(
+        data,
+        calKeys,
+        calMp: { [key: string]: string },
+        calTxt,
+        calTxtKey,
+        res = [],groupIColumns
+    ) {
+        for (const [k, v] of Object.entries(data)) {
+            if (Array.isArray(v)) {
+                const sumData = {
+                    [calTxtKey]: calTxt,
+                    _type: calMp,
+                    _calRange: "small",
+                };
+
+                for (const calKey of calKeys) {
+                    if (calMp[calKey] === "sum")
+                        sumData[calKey] = v.reduce(
+                            (last, d) => last.plus(BigNumber(d[calKey])),
+                            BigNumber(0)
+                        );
+                    if (calMp[calKey] === "avg")
+                        sumData[calKey] = v.reduce(
+                            (last, d) => last.plus(BigNumber(d[calKey]).div(v.length)),
+                            BigNumber(0)
+                        );
+
+                    const hash = (...args) => args.join("-");
+                    const hashKey = (data, keys) => hash(...keys.map((key) => data[key]));
+                    if (calMp[calKey] === "groupIsum") {
+                        const allKeys = groupIColumns?.map(({ title }) => title);
+                        const set = new Set();
+
+                        sumData[calKey] = v.reduce((lastNum, item) => {
+                            if (set.has(hashKey(item, allKeys))) return lastNum;
+                            set.add(hashKey(item, allKeys));
+                            return lastNum.plus(
+                                new BigNumber(this.getTableSummaryNumberValue(item[calKey]))
+                            );
+                        }, new BigNumber(0));
+                    }
+
+                    if (calMp[calKey] === "groupIavg") {
+                        const set = new Set();
+                        let nums = 0;
+                        const allKeys = groupIColumns?.map(({ title }) => title);
+
+                        data.forEach((item) => {
+                            if (set.has(hashKey(item, allKeys))) return;
+                            set.add(hashKey(item, allKeys));
+
+                            nums++;
+                        });
+
+                        set.clear();
+
+                        sumData[calKey] = v.reduce((lastNum, item) => {
+                            if (set.has(hashKey(item, allKeys))) return lastNum;
+                            set.add(hashKey(item, allKeys));
+                            return lastNum.plus(
+                                new BigNumber(
+                                    this.getTableSummaryNumberValue(item[calKey])
+                                ).div(nums)
+                            );
+                        }, new BigNumber(0));
+                    }
+
+                    sumData[calKey] = sumData[calKey]?.toString();
+                }
+
+                v.sort((a, b) =>
+                    Number(a.orderInGroup) < Number(b.orderInGroup) ? -1 : 1
+                );
+                res.push(...v, sumData);
+            } else {
+                this.handleRowData(v, calKeys, calMp, calTxt, calTxtKey, res,groupIColumns);
+            }
+        }
+
+        return res;
+    },
+
+    stain(cols) {
+        for (const col of cols) {
+            if (Array.isArray(col.children)) {
+                this.stain(col.children);
+            } else {
+                col.render = function(text, record, index) {
+                    let className = "";
+                    if (record._type !== undefined) {
+                        if (record._calRange === "small") className = "xiaoji";
+                        else className = "heji";
+                    }
+                    return <div className={className}>{text}</div>;
+                };
+            }
+        }
+    },
+    getTableSummaryNumberValue(value: "" | string[]) {
+        if (value === undefined || value === null) return 0;
+        if (typeof value === "string") return Number(value);
+        return Number(value[0].split("@R@")[1]);
+    },
+    buildKeys(keys: { title: string; dataKey: string }[]) {
+        return keys.map((i) => i.title).join("-");
+    }
+
+}