ConstructionOperation/web/maintain/report/js/rpt_tpl_pre_handle.js

/**
 * Created by Tony on 2017/12/26.
 */

const sort_types = ["normal", "tree", "accord_to_parent", "self_define"];
const pre_handle_data_objects = ["bills", "ration", "ration_glj"];
const pre_handle_data_objects_name = ["清单", "定额", "定额工料机"];
const exposed_bills_properties = [
    {Name: "清单_ID", Title: "", Key: "ID", Order: "ascend"},
    {Name: "清单_所属项目ID", Title: "", Key: "projectID", Order: "ascend"},
    {Name: "清单_项目编码", Title: "", Key: "code", Order: "ascend"},
    {Name: "清单_项目名称", Title: "", Key: "name", Order: "ascend"},
    {Name: "清单_项目特征", Title: "", Key: "itemCharacterText", Order: "ascend"},
    {Name: "清单_计量单位", Title: "", Key: "unit", Order: "ascend"},
    {Name: "清单_工程量", Title: "", Key: "quantity", Order: "ascend"},
    {Name: "清单_综合单价", Title: "", Key: "unitFee", Order: "ascend"},
    {Name: "清单_综合合价", Title: "", Key: "totalFee", Order: "ascend"},
    {Name: "清单_暂估价", Title: "", Key: "tenderUnitFee", Order: "ascend"}
];
const exposed_ration_properties = [
    {Name: "定额_工程内部ID", Title: "", Key: "ID", Order: "ascend"},
    {Name: "定额_所属清单ID", Title: "", Key: "billsItemID", Order: "ascend"},
    {Name: "定额_所属项目ID", Title: "", Key: "projectID", Order: "ascend"},
    {Name: "定额_编号", Title: "", Key: "code", Order: "ascend"},
    {Name: "定额_项目名称", Title: "", Key: "caption", Order: "ascend"},
    {Name: "定额_单位", Title: "", Key: "unit", Order: "ascend"},
    {Name: "定额_数量", Title: "", Key: "quantity", Order: "ascend"},
    {Name: "定额_人工费", Title: "", Key: "labour", Order: "ascend"},
    {Name: "定额_材料费", Title: "", Key: "material", Order: "ascend"},
    {Name: "定额_机械费", Title: "", Key: "machine", Order: "ascend"},
    {Name: "定额_机上人工费", Title: "", Key: "machineLabour", Order: "ascend"},
    {Name: "定额_人工费调整", Title: "", Key: "adjustLabour", Order: "ascend"},
    {Name: "定额_材料费调整", Title: "", Key: "'adjustMaterial'", Order: "ascend"},
    {Name: "定额_机械费调整", Title: "", Key: "adjustMachine", Order: "ascend"},
    {Name: "定额_机上人工费调整", Title: "", Key: "adjustMachineLabour", Order: "ascend"},
    {Name: "定额_人工价差", Title: "", Key: "labourDiff", Order: "ascend"},
    {Name: "定额_材料价差", Title: "", Key: "materialDiff", Order: "ascend"},
    {Name: "定额_机械价差", Title: "", Key: "machineDiff", Order: "ascend"},
    {Name: "定额_风险费用", Title: "", Key: "risk", Order: "ascend"}
    // {Name: "定额_管理费率", Title: "", Key: ""}
];
const exposed_prj_glj_properties = [
    {Name: "工料机_ID", Title: "", Key: "ID"},
    {Name: "工料机_所属定额ID", Title: "", Key: "rationID", Order: "ascend"},
    {Name: "工料机_所属清单ID", Title: "", Key: "billsItemID", Order: "ascend"},
    {Name: "工料机_所属工程ID", Title: "", Key: "projectID", Order: "ascend"},
    {Name: "工料机_代码", Title: "", Key: "code", Order: "ascend"},
    {Name: "工料机_名称", Title: "", Key: "name", Order: "ascend"},
    {Name: "工料机_单位", Title: "", Key: "unit", Order: "ascend"},
    {Name: "工料机_数量", Title: "", Key: "quantity", Order: "ascend"}
];
const exposed_properties_arr = [exposed_bills_properties, exposed_ration_properties, exposed_prj_glj_properties];
const IDMark_Switch = "_switch",
    IDMark_Icon = "_ico",
    IDMark_Span = "_span",
    IDMark_Input = "_input",
    IDMark_Check = "_check",
    IDMark_Edit = "_edit",
    IDMark_Remove = "_remove",
    IDMark_Ul = "_ul",
    IDMark_A = "_a";

let preHandleObj = {
    treeObj: null,
    typeTreeObj: null,
    currentNode: null,
    iniTree: function(rptTpl) {
        let me = this;
        me.buildData(rptTpl);
    },
    buildData: function(rptTpl) {
        let me = this, handles = [];
        if (rptTpl[JV.NODE_MAP_DATA_HANDLE_INFO]) {
            for (let item of rptTpl[JV.NODE_MAP_DATA_HANDLE_INFO]) {
                let hd = {Name: "预处理环节"};
                me.private_copy_node(item, hd);
                me.private_set_title(hd);
                hd.Operations = []; //考虑到用户可能会换来换去，这样会有冗余的属性出现
                handles.push(hd);
            }
        }
        me.treeObj = $.fn.zTree.init($("#pre_handle_data_info_reversed"), preHandleSetting, handles);
    },
    build_handle_data_selection: function() {
        let sel = $("#select_mapping_data"), sel2 = $("#select_mapping_data_for_sort_type");
        for (let i = 0; i < pre_handle_data_objects.length; i++) {
            sel2.append("<option value='" + pre_handle_data_objects[i] + "'>" + pre_handle_data_objects_name[i] + "</option>");
            sel.append("<option value='" + pre_handle_data_objects[i] + "'>" + pre_handle_data_objects_name[i] + "</option>");
        }
    },
    buildTypeData: function () {
        let me = this, types = [];
        types.push({Name: JV.PROP_HANDLE_TYPE_SORT, Title: ""});
        types.push({Name: JV.PROP_HANDLE_TYPE_FILTER, Title: ""});
        types.push({Name: JV.PROP_HANDLE_TYPE_SUM, Title: ""});
        types.push({Name: JV.PROP_HANDLE_TYPE_ADJUST, Title: ""});
        types.push({Name: JV.PROP_HANDLE_TYPE_ADD_DUMMY, Title: ""});
        // types.push({Name: "纯手工填写", Title: ""});
        me.typeTreeObj = $.fn.zTree.init($("#pre_handle_type_reversed"), preHandleTypeSetting, types);
        me.setDisabledBandSelect(true);
        me.build_handle_data_selection();
    },
    setDisabledBandSelect: function(disabled) {
        let me = this;
        if (me.typeTreeObj) {
            let nodes = me.typeTreeObj.getNodes();
            for (let node of nodes) {
                me.typeTreeObj.setChkDisabled(node, disabled, true, true);
            }
        }
    },
    addNewNode: function() {
        let me = this, item = {Name: "预处理环节", Title: "", "映射数据对象": "bills", "预处理类型": "排序", "排序方式": "normal", "排序键值集":[], Operations: []};
        me.private_set_title(item);
        me.treeObj.addNodes(null, -1, [item], true);
    },
    private_copy_node: function(src, dest) {
        let me = this;
        dest[JV.PROP_DATA_KEY] = src[JV.PROP_DATA_KEY];
        dest[JV.PROP_HANDLE_TYPE] = src[JV.PROP_HANDLE_TYPE];

        if (src[JV.PROP_HANDLE_TYPE] === JV.PROP_HANDLE_TYPE_SORT) {
            preHandleSortObj.copyNode(src, dest);
        } else if (src[JV.PROP_HANDLE_TYPE] === JV.PROP_HANDLE_TYPE_FILTER) {
            preHandleFilterObj.copyNode(src, dest);
        } else if (src[JV.PROP_HANDLE_TYPE] === JV.PROP_HANDLE_TYPE_SUM) {
            preHandleSummaryObj.copyNode(src, dest);
        } else if (src[JV.PROP_HANDLE_TYPE] === JV.PROP_HANDLE_TYPE_ADJUST) {
            preHandleAdjustObj.copyNode(src, dest);
        } else if (src[JV.PROP_HANDLE_TYPE] === JV.PROP_HANDLE_TYPE_ADD_DUMMY) {
            preHandleAddDummyObj.copyNode(src, dest);
        }
    },
    private_set_title: function(node) {
        let nameStr = node[JV.PROP_NAME], idx = nameStr.indexOf("(");
        if (idx >= 0) {
            nameStr = nameStr.slice(0, idx);
        }
        node[JV.PROP_NAME] = nameStr + "(" + node[JV.PROP_HANDLE_TYPE] + ")";
        node.Title = "映射数据对象:" + node[JV.PROP_DATA_KEY] + " | " + node[JV.PROP_HANDLE_TYPE];
    },
    refreshByNode: function(treeNode) {
        let me = preHandleObj;
        if (me.typeTreeObj) {
            let nodes = me.typeTreeObj.getNodes();
            let typeNode = null;
            for (let node of nodes) {
                if (treeNode[JV.PROP_NAME].indexOf(node[JV.PROP_NAME]) > 0) {
                    me.typeTreeObj.checkNode(node, true, false, false);
                    typeNode = node;
                    break;
                }
            }
            let md = $("#select_mapping_data")[0];
            for (let i = 0; i < md.children.length; i++) {
                if (treeNode[JV.PROP_DATA_KEY] === md.children[i].value) {
                    md.selectedIndex = i;
                    break;
                }
            }
            if (typeNode) {
                me.hide_all_dom();
                $("#div_pre_handle_data")[0].style.display = "";
                if (typeNode[JV.PROP_NAME] === "排序") {
                    preHandleSortObj.refresh_node();
                } else if (typeNode[JV.PROP_NAME] === "过滤") {
                    preHandleFilterObj.refresh_node();
                } else if (typeNode[JV.PROP_NAME] === "合计") {
                    preHandleSummaryObj.refresh_node();
                } else if (typeNode[JV.PROP_NAME] === "数据调整") {
                    preHandleAdjustObj.refresh_node();
                } else if (typeNode[JV.PROP_NAME] === "增加Dummy数据") {
                    preHandleAddDummyObj.refresh_node();
                }
            }
        }
    },
    hide_all_dom: function() {
        $("#div_pre_handle_data")[0].style.display = "none";
        $("#div_sort_type")[0].style.display = "none";
        $("#div_sort_type_normal")[0].style.display = "none";
        $("#div_filter_type")[0].style.display = "none";
        $("#div_summary_type")[0].style.display = "none";
        $("#div_adjust_type")[0].style.display = "none";
        $("#div_add_dummy_type")[0].style.display = "none";
        $("#div_sort_type_according_to_parent")[0].style.display = "none";
        $("#div_sort_type_parent_data")[0].style.display = "none";
    },
    onPreHandleClick: function(event,treeId,treeNode) {
        //点击预处理环节 节点
        let me = preHandleObj;
        me.currentNode = treeNode;
        me.setDisabledBandSelect(false);
        me.refreshByNode(treeNode);
    },
    onTypeClick: function(event,treeId,treeNode) {
        //选择预处理类型（排序、过滤。。。）
        let me = preHandleObj;
        if (me.currentNode) {
            me.currentNode[JV.PROP_HANDLE_TYPE] = treeNode[JV.PROP_NAME];
            me.private_set_title(me.currentNode);
            me.treeObj.updateNode(me.currentNode, false);
            me.refreshByNode(me.currentNode);
        }
    },
    onChangeDataMappingObj: function(dom, oprType) {
        //更改(或选择)预处理环节中的 数据依据(就是说报表想预处理什么数据)
        let me = preHandleObj;
        if (oprType === "top") {
            me.childTreeObj = $.fn.zTree.init($("#child_sorting_keys"), sortingKeysSetting, exposed_properties_arr[dom.selectedIndex]);
            me.treeObj = $.fn.zTree.init($("#pre_handle_sort_keys_reversed"), sortingKeysSetting, exposed_properties_arr[dom.selectedIndex]);
        } else if (oprType === "accord_to_parent") {
            me.parentTreeObj = $.fn.zTree.init($("#parent_sorting_keys"), sortingKeysSetting, exposed_properties_arr[dom.selectedIndex]);
        }
    },
    onSortTypeChange: function(dom) {
        //排序类型的选择/更改
        let me = preHandleObj;
        me.hide_all_dom();
        $("#div_pre_handle_data")[0].style.display = "";
        $("#div_sort_type")[0].style.display = "";
        if (dom.selectedIndex === 2) {
            $("#div_sort_type_according_to_parent")[0].style.display = "";
            $("#div_sort_type_parent_data")[0].style.display = "";
            me.parentTreeObj = $.fn.zTree.init($("#parent_sorting_keys"), sortingKeysSetting, exposed_properties_arr[dom.selectedIndex]);
            me.childTreeObj = $.fn.zTree.init($("#child_sorting_keys"), sortingKeysSetting, exposed_properties_arr[dom.selectedIndex]);
        } else if (dom.selectedIndex === 0) {
            $("#div_sort_type_normal")[0].style.display = "";
        }

    },
    onBeforeDrop: function(treeId, treeNodes, targetNode, moveType){
        //
    },
    onBeforeRemove: function(treeId, treeNode){
        let rst = true;
        if (treeNode.isParent) {
            rst = false;
        } else {
            //
        }
        return rst;
    },
    extractTabFields: function (rptTpl) {
        if (rptTpl[JV.NODE_MAP_DATA_HANDLE_INFO]) {
            for (let handleObj of rptTpl[JV.NODE_MAP_DATA_HANDLE_INFO]) {
                switch (handleObj[JV.PROP_HANDLE_TYPE]) {
                    case JV.PROP_HANDLE_TYPE_SORT:
                        preHandleSortObj.extractTabFields(handleObj);
                        break;
                    case JV.PROP_HANDLE_TYPE_FILTER:
                        preHandleFilterObj.extractTabFields(handleObj);
                        break;
                    case JV.PROP_HANDLE_TYPE_SUM:
                        preHandleSummaryObj.extractTabFields(handleObj);
                        break;
                    case JV.PROP_HANDLE_TYPE_ADJUST:
                        preHandleAdjustObj.extractTabFields(handleObj);
                        break;
                    case JV.PROP_HANDLE_TYPE_ADD_DUMMY:
                        preHandleAddDummyObj.extractTabFields(handleObj);
                        break;
                    default:
                        break;
                }
            }
        }
    }
};

let preHandleSortObj = {
    normalTreeObj: null,
    parentTreeObj: null,
    childTreeObj: null,
    copyNode: function (src, dest) {
        dest[JV.PROP_SORT_TYPE] = src[JV.PROP_SORT_TYPE];
        switch (sort_types.indexOf(src[JV.PROP_SORT_TYPE])) {
            case -1:
                //unknown!
                break;
            case 0 :
                //normal
                break;
            case 1 :
                //tree
                break;
            case 2 :
                //according to parent
                dest[JV.PROP_PARENT_CHILD_SORT_KEY] = {};
                dest[JV.PROP_OTHER_SUB_SORT] = [];
                dest[JV.PROP_PARENT_CHILD_SORT_KEY][JV.PROP_PARENT_DATA_KEY] = src[JV.PROP_PARENT_CHILD_SORT_KEY][JV.PROP_PARENT_DATA_KEY];
                dest[JV.PROP_PARENT_CHILD_SORT_KEY][JV.PROP_PARENT_SORT_KEYS] = [];
                for (let item of src[JV.PROP_PARENT_CHILD_SORT_KEY][JV.PROP_PARENT_SORT_KEYS]) {
                    dest[JV.PROP_PARENT_CHILD_SORT_KEY][JV.PROP_PARENT_SORT_KEYS].push(item);
                }
                dest[JV.PROP_PARENT_CHILD_SORT_KEY][JV.PROP_CHILD_SORT_KEYS] = [];
                for (let item of src[JV.PROP_PARENT_CHILD_SORT_KEY][JV.PROP_CHILD_SORT_KEYS]) {
                    dest[JV.PROP_PARENT_CHILD_SORT_KEY][JV.PROP_CHILD_SORT_KEYS].push(item);
                }
                for (let subSort of src[JV.PROP_OTHER_SUB_SORT]) {
                    let st = {};
                    st[JV.PROP_SORT_TYPE] = subSort[JV.PROP_SORT_TYPE];
                    if (subSort[JV.PROP_SORT_TYPE] === "normal") {
                        st[JV.PROP_SORT_KEYS] = [];
                        for (let item of subSort[JV.PROP_SORT_KEYS]) {
                            let di = {key: item.key, order: item.order};
                            st[JV.PROP_SORT_KEYS].push(di);
                        }
                    } else {
                        //其他暂时不实现，目前没那么复杂
                    }
                }
                break;
            case 3 :
                //self define
                break;
            default:
                break;
        }
    },
    refresh_node: function () {
        let me = this;
        $("#div_sort_type")[0].style.display = "";
        if (preHandleObj.currentNode) {
            let sel = $("#select_sort_types")[0];
            let idx = -1;
            let sortTypeIdx = sort_types.indexOf(preHandleObj.currentNode[JV.PROP_SORT_TYPE]);
            sel.selectedIndex = sortTypeIdx;
            switch (sortTypeIdx) {
                case -1:
                    //unknown!
                    break;
                case 0 :
                    //normal
                    $("#div_sort_type_normal")[0].style.display = "";
                    idx = pre_handle_data_objects.indexOf(preHandleObj.currentNode[JV.PROP_DATA_KEY]);
                    me.treeObj = $.fn.zTree.init($("#pre_handle_sort_keys_reversed"), sortingKeysSetting, exposed_properties_arr[idx]);
                    let nodes = me.treeObj.getNodes();
                    for (let sortItem of preHandleObj.currentNode[JV.PROP_SORT_KEYS]) {
                        for (let keyNode of nodes) {
                            if (sortItem.key === keyNode.Key) {
                                me.treeObj.checkNode(keyNode, true, false, false);
                                break;
                            }
                        }
                    }
                    break;
                case 1 :
                    //tree
                    //tree排序是我们特有的数据结构方式，与数据结构有关，非common用
                    break;
                case 2 :
                    //according to parent
                    $("#div_sort_type_according_to_parent")[0].style.display = "";
                    $("#div_sort_type_parent_data")[0].style.display = "";
                    sel = $("#select_mapping_data_for_sort_type")[0];
                    idx = pre_handle_data_objects.indexOf(preHandleObj.currentNode[JV.PROP_PARENT_CHILD_SORT_KEY][JV.PROP_PARENT_DATA_KEY]);
                    sel.selectedIndex = idx;
                    me.parentTreeObj = $.fn.zTree.init($("#parent_sorting_keys"), sortingKeysSetting, exposed_properties_arr[idx]);
                    me.checkupNode(preHandleObj.currentNode[JV.PROP_PARENT_CHILD_SORT_KEY][JV.PROP_PARENT_SORT_KEYS], me.parentTreeObj);
                    idx = pre_handle_data_objects.indexOf(preHandleObj.currentNode[JV.PROP_DATA_KEY]);
                    me.childTreeObj = $.fn.zTree.init($("#child_sorting_keys"), sortingKeysSetting, exposed_properties_arr[idx]);
                    me.checkupNode(preHandleObj.currentNode[JV.PROP_PARENT_CHILD_SORT_KEY][JV.PROP_CHILD_SORT_KEYS], me.childTreeObj);
                    break;
                case 3 :
                    //self define
                    break;
                default:
                    break;
            }
        }
    },
    checkupNode: function(keysArr, treeObj) {
        let nodes = treeObj.getNodes();
        for (let key of keysArr) {
            for (let node of nodes) {
                if (node.Key === key) {
                    treeObj.checkNode(node, true, false, false);
                    break;
                }
            }
        }
    },
    onCheck: function(event,treeId,treeNode) {
        let me = preHandleSortObj;
        if (treeId.indexOf("parent_sorting_keys") >= 0) {
            //preHandleObj.currentNode
        } else if (treeId.indexOf("child_sorting_keys") >= 0) {
            //
        } else {
            me.resetNormalSort();
        }
    },
    resetNormalSort: function() {
        let nodes = me.treeObj.getNodes();
        let normalSortKeys = [];
        for (let node of nodes) {
            if (node.checked) {
                let keyObj = {key: node.Key, order: node.Order};
                normalSortKeys.push(keyObj);
            }
        }
        preHandleObj.currentNode[JV.PROP_SORT_KEYS] = normalSortKeys;
    },
    addDiyDom: function(treeId,treeNode) {
        let aObj = $("#" + treeNode.tId + IDMark_A);
        let editStr = "<select class='selDemo' id='diySelect_" +treeNode.tId+ "'><option value='ascend'>升序 </option><option value='descend'>降序 </option></select>";
        aObj.after(editStr);
        let sel = $("#diySelect_" + treeNode.tId);
        if (sel) {
            sel.bind("change", function(){
                treeNode.Order = sel[0].value;
            });
        }
    },
    extractTabFields: function (handleObj) {
        //
    }
};

let preHandleFilterObj = {
    copyNode: function (src, dest) {
        //
    },
    refresh_node: function () {
        $("#div_filter_type")[0].style.display = "";
        if (preHandleObj.currentNode) {
        }
    },
    extractTabFields: function (handleObj) {
        //
    }
};

let preHandleSummaryObj = {
    copyNode: function (src, dest) {
        //
    },
    refresh_node: function () {
        $("#div_summary_type")[0].style.display = "";
        if (preHandleObj.currentNode) {
        }
    },
    extractTabFields: function (handleObj) {
        //
    }
};

let preHandleAdjustObj = {
    copyNode: function (src, dest) {
        //
    },
    refresh_node: function () {
        $("#div_adjust_type")[0].style.display = "";
        if (preHandleObj.currentNode) {
        }
    },
    extractTabFields: function (handleObj) {
        //
    }
};

let preHandleAddDummyObj = {
    copyNode: function (src, dest) {
        //
    },
    refresh_node: function () {
        $("#div_add_dummy_type")[0].style.display = "";
        if (preHandleObj.currentNode) {
        }
    },
    extractTabFields: function (handleObj) {
        //
    }
};