Calculation/app/public/js/schedule_ledger.js

/**
 * 进度台账相关js
 *
 * @author Ellisran
 * @date 2020/11/6
 * @version
 */
function getTenderId() {
    return window.location.pathname.split('/')[2];
}
const selects = [];
let slh = [];
$(function () {
    autoFlashHeight();
    // 初始化台账
    const ledgerSpread = SpreadJsObj.createNewSpread($('#ledger-spread')[0]);
    const treeSetting = {
        id: 'ledger_id',
        pid: 'ledger_pid',
        order: 'order',
        level: 'level',
        rootId: -1,
        fullPath: 'full_path',
        calcFields: ['can_select'],
        //treeCacheKey: 'ledger_bills_fold' + '_' + getTenderId(),
        // markFoldKey: 'bills-fold',
        // markFoldSubKey: window.location.pathname.split('/')[2],
    };
    const ledgerTree = createNewPathTree('filter', treeSetting);

    const ledgerSpreadSetting = {
        cols: [
            {title: '', colSpan: '1', rowSpan: '2', field: 'is_select', hAlign: 1, width: 40, formatter: '@', cellType: 'checkbox', readOnly: 'readOnly.can_select'},
            {title: '编号', colSpan: '1', rowSpan: '2', field: 'code', hAlign: 0, width: 185, formatter: '@', readOnly: true, cellType: 'tree'},
            {title: '名称', colSpan: '1', rowSpan: '2', field: 'name', hAlign: 0, width: 205, formatter: '@', readOnly: true},
            {title: '单位', colSpan: '1', rowSpan: '2', field: 'unit', hAlign: 1, width: 100, formatter: '@', readOnly: true},
            {title: '经济指标', colSpan: '1', rowSpan: '2', field: 'dgn_price', hAlign: 2, width: 100, type: 'Number', readOnly: true},
            {title: '工程量', colSpan: '1', rowSpan: '2', field: 'dgn_qty1', hAlign: 2, width: 100, type: 'Number', readOnly: true},
            {title: '金额', colSpan: '1', rowSpan: '2', field: 'total_price', hAlign: 2, width: 100, type: 'Number', readOnly: true},
        ],
        emptyRows: 0,
        headRows: 1,
        headRowHeight: [25, 25],
        defaultRowHeight: 21,
        headerFont: '12px 微软雅黑',
        font: '12px 微软雅黑',
        // readOnly: true,
        localCache: {
            key: 'ledger-bills',
            colWidth: true,
        }
    };

    const ledgerCol = {
        readOnly: {
            can_select: function (data) {
                return !(data.can_select && !revising);
            },
        },
    };

    sjsSettingObj.setFxTreeStyle(ledgerSpreadSetting, sjsSettingObj.FxTreeStyle.jz);
    if (thousandth) sjsSettingObj.setTpThousandthFormat(ledgerSpreadSetting);
    SpreadJsObj.initSpreadSettingEvents(ledgerSpreadSetting, ledgerCol);
    SpreadJsObj.initSheet(ledgerSpread.getActiveSheet(), ledgerSpreadSetting);
    SpreadJsObj.selChangedRefreshBackColor(ledgerSpread.getActiveSheet());

    postData(window.location.pathname + '/load', {}, function (data) {
        const baseLedgerTree = createNewPathTree('base', {
            id: 'ledger_id',
            pid: 'ledger_pid',
            order: 'order',
            level: 'level',
            rootId: -1,
            fullPath: 'full_path',
            calcFields: ['total_price'],
            calcFun: function (node) {
                node.dgn_price = ZhCalc.round(ZhCalc.div(node.total_price, node.dgn_qty1), 2);
            }
        });
        // slh = _.map(data.slh, 'ledger_id');
        slh = data.slh;
        const datas = addIsSelect(data.bills);
        baseLedgerTree.loadDatas(datas);
        treeCalc.calculateAll(baseLedgerTree);
        for (const d of baseLedgerTree.nodes) {
            if (!d.b_code)
                ledgerTree.addData(d, ['is_select', 'can_select', 'ledger_id', 'ledger_pid', 'order', 'level', 'tender_id', 'full_path',
                    'code', 'name', 'unit', 'dgn_qty1', 'dgn_qty2', 'dgn_price', 'quantity', 'total_price']);
        }
        ledgerTree.sortTreeNode(true);
        console.log(ledgerTree);

        SpreadJsObj.loadSheetData(ledgerSpread.getActiveSheet(), SpreadJsObj.DataType.Tree, ledgerTree);
    }, null, true);

    const ledgerSpreadObj = {
        getselectButton: function() {
            return {
                select_siblings: $('#select_siblings').is(':checked'),
                select_other_siblings: $('#select_other_siblings').is(':checked'),
                select_children: $('#select_children').is(':checked'),
            }
        },
        refreshTree: function (sheet, data) {
            SpreadJsObj.massOperationSheet(sheet, function () {
                const tree = sheet.zh_tree;
                // 处理删除
                if (data.delete) {
                    data.delete.sort(function (x, y) {
                        return y.deleteIndex - x.deleteIndex;
                    });
                    for (const d of data.delete) {
                        sheet.deleteRows(d.deleteIndex, 1);
                    }
                }
                // 处理新增
                if (data.create) {
                    const newNodes = data.create;
                    if (newNodes) {
                        newNodes.sort(function (a, b) {
                            return a.index - b.index;
                        });

                        for (const node of newNodes) {
                            sheet.addRows(node.index, 1);
                            SpreadJsObj.reLoadRowData(sheet, tree.nodes.indexOf(node), 1);
                        }
                    }
                }
                // 处理更新
                if (data.update) {
                    const rows = [];
                    for (const u of data.update) {
                        rows.push(tree.nodes.indexOf(u));
                    }
                    SpreadJsObj.reLoadRowsData(sheet, rows);
                }
                // 处理展开
                if (data.expand) {
                    const expanded = [];
                    for (const e of data.expand) {
                        if (expanded.indexOf(e) === -1) {
                            const posterity = tree.getPosterity(e);
                            for (const p of posterity) {
                                sheet.setRowVisible(tree.nodes.indexOf(p), p.visible);
                                expanded.push(p);
                            }
                        }
                    }
                }
            });
        },
        buttonClicked: function (e, info) {
            if(revising) {
                return;
            }
            if (info.sheet.zh_setting) {
                const select = SpreadJsObj.getSelectObject(info.sheet);
                const col = info.sheet.zh_setting.cols[info.col];
                // if (materialCol.readOnly.isEdit(select)) {
                //     return;
                // }
                if (col.field === 'is_select' && select.can_select) {
                    if (info.sheet.isEditing()) {
                        info.sheet.endEdit(true);
                    }
                    // 选中和去除关联
                    select.is_select = info.sheet.getValue(info.row, info.col) ? 1 : 0;
                    selects.splice(0, selects.length);
                    selects.push(select);
                    const select_msg = ledgerSpreadObj.getselectButton();
                    if (select_msg.select_children || select.is_select === 0) {
                        updateChildrenSelect(select.children, select.is_select);
                    }
                    if (!select_msg.select_other_siblings && select_msg.select_siblings) {
                        updateSiblingsSelect(info.sheet.zh_tree, select.ledger_pid, select.is_select, select_msg);
                    }
                    if (select_msg.select_other_siblings) {
                        updateSiblingsSelect(info.sheet.zh_tree, select.ledger_pid, select.is_select, select_msg);
                        updateOtherSiblingsSelect(info.sheet.zh_tree, select.ledger_pid, select.is_select, select_msg);
                    }
                    if(select.is_select === 1) {
                        updateParentSelect(info.sheet.zh_tree, select.ledger_pid, select.is_select);
                    }
                    // console.log(selects);
                    const refreshNode = ledgerTree.loadPostData({update: selects});
                    ledgerSpreadObj.refreshTree(info.sheet, refreshNode);
                }
            }
        },
    };

    ledgerSpread.bind(spreadNS.Events.ButtonClicked, ledgerSpreadObj.buttonClicked);

    $('#ledger_submit').click(function () {
        const select_ledger = _.filter(ledgerTree.nodes, { 'is_select': 1 });
        if (select_ledger.length === 0) {
            toastr.error('请至少勾选一个节点');
            return;
        }
        $(this).attr('disabled', true);
        const [under_ledger, parent_ledger] = getPAndULedger(select_ledger);
        postData(window.location.pathname + '/save',  { select_ledger: _.map(select_ledger, 'ledger_id'), under_ledger, parent_ledger, type: 'sz' } , function (result) {
            toastr.success('设置成功');
            setTimeout(function () {
                window.location.reload();
            },1500);
        });
    });
    $('#update-ledger').click(function () {
        const addLedgerData = _.map(_.differenceBy(ledgerTree.nodes, slh, 'ledger_id'), 'ledger_id');
        const select_ledger = _.filter(ledgerTree.nodes, { 'is_select': 1 });
        // 找出addLedgerData父节点并一起加入到select_ledger中
        if (addLedgerData.length > 0) {
            for (const a of addLedgerData) {
                const ainfo = _.find(ledgerTree.nodes, { 'ledger_id': a });
                select_ledger.push(ainfo);
                findandpush(ainfo.ledger_pid);
            }
        }
        function findandpush(ledger) {
            const parent = _.find(ledgerTree.nodes, { ledger_id: ledger });
            if (parent) {
                const hadinfo = _.find(select_ledger, { ledger_id: parent.ledger_id });
                if (!hadinfo) {
                    select_ledger.push(parent);
                    findandpush(parent);
                }
            }
        }
        $(this).attr('disabled', true);
        const [under_ledger, parent_ledger] = getPAndULedger(select_ledger);
        postData(window.location.pathname + '/save',  { select_ledger: _.map(select_ledger, 'ledger_id'), under_ledger, parent_ledger, type: 'xz' } , function (result) {
            toastr.success('进度台账数据修正成功');
            setTimeout(function () {
                window.location.reload();
            },1500);
        });
    });

    function getPAndULedger(select_ledger) {
        // 找出所选的最底层，并统计总设计金额用
        const under_ledger = [];
        for (const sl of select_ledger) {
            const hadChild = _.find(select_ledger, { ledger_pid: sl.ledger_id });
            if (!hadChild) {
                under_ledger.push({ ledger_id: sl.ledger_id, ledger_pid: sl.ledger_pid, gcl: sl.dgn_qty1, tp: sl.total_price });
            }
        }
        // 从最底层找出之前的所有父节点，删除他们可能存在已填的值
        const parent_ledger = [];
        if (under_ledger.length > 0) {
            for (const ul of under_ledger) {
                digui(select_ledger, ul.ledger_pid);
            }
        }
        function digui(select_ledger, ul) {
            const parent = _.find(select_ledger, { ledger_id: ul });
            if (parent && parent_ledger.indexOf(ul) === -1) {
                digui(select_ledger, parent.ledger_pid);
                if (!parent.can_select) {
                    parent_ledger.push(parent.ledger_id);
                }
            }
        }
        return [under_ledger, parent_ledger];
    }

    $.subMenu({
        menu: '#sub-menu', miniMenu: '#sub-mini-menu', miniMenuList: '#mini-menu-list',
        toMenu: '#to-menu', toMiniMenu: '#to-mini-menu',
        key: 'menu.1.0.0',
        miniHint: '#sub-mini-hint', hintKey: 'menu.hint.1.0.1',
        callback: function (info) {
            if (info.mini) {
                $('.panel-title').addClass('fluid');
                $('#sub-menu').removeClass('panel-sidebar');
            } else {
                $('.panel-title').removeClass('fluid');
                $('#sub-menu').addClass('panel-sidebar');
            }
            ledgerSpread.refresh();
            autoFlashHeight();
        }
    });


    // // 显示层次
    // (function (select, sheet) {
    //     $(select).click(function () {
    //         const tag = $(this).attr('tag');
    //         const tree = sheet.zh_tree;
    //         if (!tree) return;
    //         switch (tag) {
    //             case "1":
    //             case "2":
    //             case "3":
    //             case "4":
    //             case "5":
    //                 tree.expandByLevel(parseInt(tag));
    //                 SpreadJsObj.refreshTreeRowVisible(sheet);
    //                 break;
    //             case "last":
    //                 tree.expandByCustom(() => { return true; });
    //                 SpreadJsObj.refreshTreeRowVisible(sheet);
    //                 break;
    //             case "leafXmj":
    //                 tree.expandToLeafXmj();
    //                 SpreadJsObj.refreshTreeRowVisible(sheet);
    //                 break;
    //         }
    //     });
    // })('a[name=showLevel]', ledgerSpread.getActiveSheet());
});
function addIsSelect(datas) {
    // const newDatas = [];
    for (const d of datas) {
        if (!d.b_code) {
            d.is_select = selectedLedgerList.length === 0 ? 1: selectedLedgerList.indexOf(d.ledger_id) !== -1 ? 1 : 0;
            if (!d.is_leaf) {
                d.can_select = hadDataLidList.length === 0 ? true : hadDataLidList.indexOf(d.ledger_id) !== -1 ? false : true;
                // console.log(d.can_select);
            } else if(d.can_select === undefined) {
                d.can_select = true;
            }
        }
    }
    for (const d2 of datas) {
        if (!d2.b_code && !d2.can_select) {
            updateParentCanSelect(datas, d2.ledger_pid);
        }
    }
    return datas;
}

function updateParentCanSelect(datas, ledger_pid) {
    if (ledger_pid !== 0) {
        const info = _.find(datas, { ledger_id: ledger_pid});
        if (info) {
            info.can_select = false;
            updateParentCanSelect(datas, info.ledger_pid);
        }
    }
}

function updateChildrenSelect(datas, is_select) {
    for (const data of datas) {
        if (data.can_select) {
            data.is_select = is_select;
        }
        if(data.children && data.children.length > 0) {
            updateChildrenSelect(data.children, is_select);
        }
        selects.push(data);
    }
}

function updateSiblingsSelect(tree, pid, is_select, select_msg) {
    const parent = pid !== -1 ? _.find(tree.nodes, { 'ledger_id': pid }) : tree;
    if (parent) {
        for(const d of parent.children) {
            if (d.can_select) {
                d.is_select = is_select;
            }
            // d.is_select = is_select;
            if (select_msg.select_children || is_select === 0) {
                updateChildrenSelect(d.children, is_select);
            }
            selects.push(d);
        }
    }
}

function updateOtherSiblingsSelect(tree, pid, is_select, select_msg) {
    if(pid === -1) {
        return;
    }
    const parent = _.find(tree.nodes, { 'ledger_id': pid });
    if (parent) {
        const grandparent = parent.ledger_pid === -1 ? tree : _.find(tree.nodes, { 'ledger_id': parent.ledger_pid });
        if (grandparent) {
            for (const d of grandparent.children) {
                if (d.ledger_id !== pid) {
                    let p = false;
                    if(d.children && d.children.length > 0) {
                        for (const dd of d.children) {
                            if (dd.can_select) {
                                dd.is_select = is_select;
                            }
                            p = true;
                            if (select_msg.select_children || is_select === 0) {
                                updateChildrenSelect(dd.children, is_select);
                            }
                            selects.push(dd);
                        }
                    }
                    if(p) {
                        if(d.can_select) {
                            d.is_select = is_select;
                        }
                        selects.push(d);
                    }
                }
            }
        }
    }
}

function updateParentSelect(tree, pid, is_select) {
    if (pid !== -1) {
        const parent = _.find(tree.nodes, { 'ledger_id': pid });
        if (parent) {
            const hadselectInfo = is_select === 0 ? _.findIndex(parent.children, { 'is_select': 1 }) : 1;
            parent.is_select = (hadselectInfo !== -1 && is_select === 0) || is_select === 1 ? 1 : 0;
            selects.push(parent);
            updateParentSelect(tree, parent.ledger_pid, is_select);
        }
    }
}