ConstructionCost/web/building_saas/main/js/models/project_glj.js

/**
 * 工料机汇总相关数据
 *
 * @author CaiAoLin
 * @date 2017/9/14
 * @version
 */
function ProjectGLJ() {
    this.datas = null;
    this.isLoading = false;
}

/**
 * 加载数据
 *
 * @param {function} callback
 * @return {boolean}
 */
ProjectGLJ.prototype.loadData = function (callback = null) {
    let self = this;
    if (self.isLoading) {
        return false;
    }
    // 加载工料机数据
    $.ajax({
        url: '/glj/getData',
        type: 'post',
        dataType: 'json',
        data: {project_id: scUrlUtil.GetQueryString('project')},
        error: function () {
            // alert('数据传输错误');
        },
        beforeSend: function () {
            self.isLoading = true;
        },
        success: function (response) {
            self.isLoading = false;
            if (response.err === 1) {
                let msg = response.msg !== undefined && response.msg !== '' ? response.msg : '读取工料机数据失败!';
                alert(msg);
                return false;
            }
            self.datas = response.data;
            self.calcQuantity();
            // 回调函数
            if (callback !== null) {
                callback(response.data);
            }
            // 存入缓存
            projectObj.project.projectGLJ = self;
        }
    });
};

ProjectGLJ.prototype.loadToCache = function (data) {
    this.datas = data;
    projectObj.project.projectGLJ = this;
}


/**
 * 获取对应工料机数据
 *
 * @param {String} code
 * @return {Object}
 */
ProjectGLJ.prototype.getDataByCode = function (code) {
    let result = {};
    if (this.datas === null) {
        return result;
    }

    let gljList = this.datas.gljList;
    if (gljList === undefined) {
        return result;
    }

    for (let tmp of gljList) {
        if (tmp.code === code) {
            result = tmp;
            break;
        }
    }

    return result;
};

/**
 * 修改工料机数据
 *
 * @param {Number} id
 * @param {Object} data
 * @return {boolean}
 */
ProjectGLJ.prototype.updateData = function (id, data) {
    let result = false;
    if (this.datas === null) {
        return result;
    }

    let gljList = this.datas.gljList;
    if (gljList === undefined) {
        return result;
    }

    // 查找对应的index
    let index = -1;
    for (let tmp in gljList) {
        if (gljList[tmp].id === id) {
            index = tmp;
            break;
        }
    }

    if (index < 0) {
        return result;
    }

    // 修改数据
    for (let tmpIndex in data) {
        if (tmpIndex.indexOf('_price') >= 0) {
            // 修改unit_price中的对象
            this.datas.gljList[index]['unit_price'][tmpIndex] = data[tmpIndex];
        } else {
            this.datas.gljList[index][tmpIndex] = data[tmpIndex];
        }
    }

};

/**
 * 加载缓存数据到spread
 *
 * @return {void}
 */
ProjectGLJ.prototype.loadCacheData = function (resort) {
    // 加载工料机数据
    let data = this.datas === null ? null : this.datas;
    if (data === null) {
        return;
    }
    jsonData = data.gljList !== undefined && data.gljList.length > 0 ? data.gljList : [];
    console.log("filter start");
    jsonData = filterProjectGLJ(jsonData);
    console.log("filter end");
    jsonData = sortProjectGLJ(jsonData);
    console.log("sort end");
    if(projectGLJSheet&&projectGLJSpread){
        setTimeout(spreadInit, 1);
         /*projectGLJSheet.setData(jsonData);
         projectGLJSpread.specialColumn(jsonData);*/
    }
};

ProjectGLJ.prototype.updatePriceFromRG = function (recode, updateField, newval) {
    if (updateField == 'marketPrice') {
        this.updatePrice(recode, "market_price", newval,"rg");
    }
    if (updateField == 'basePrice') {
        this.updatePrice(recode, "base_price", newval,"rg");
    }
};

ProjectGLJ.prototype.updatePropertyFromMainSpread = function (node, updateField, newval) {
    if (updateField == "contain") {//更新含量和工程量时，要走定额更新的逻辑
        projectObj.project.Ration.updateContain(newval,node);
    }if(updateField == "quantity"){
        projectObj.project.quantity_detail.editMainTreeNodeQuantity(newval,node,updateField);
    } else {
        this.updateGLJProperty(node, updateField, newval);
    }
};


ProjectGLJ.prototype.updateGLJProperty = function (node, updateField, newval) {
    let rationTypeGLJ = node.data;
    let postData = {};
    if (rationTypeGLJ[updateField] == newval) {
        return;
    }
    let data = {
        glj_id: rationTypeGLJ.GLJID,
        project_id: rationTypeGLJ.projectID,
        code: rationTypeGLJ.code,
        original_code: rationTypeGLJ.original_code,
        name: rationTypeGLJ.name,
        shortName: rationTypeGLJ.shortName,
        specs: rationTypeGLJ.specs,
        unit: rationTypeGLJ.unit,
        type: rationTypeGLJ.subType,
        type_of_work: rationTypeGLJ.subType,
        base_price: rationTypeGLJ.basePrice,
        market_price: rationTypeGLJ.basePrice,
        repositoryId: rationTypeGLJ.repositoryId,
        adjCoe: rationTypeGLJ.adjCoe,
        from: rationTypeGLJ.from ? rationTypeGLJ.from : 'std'//std:标准工料机库, cpt:补充工料机库
    };
    if (updateField == 'subType') {
        data.type = newval;
        data.type_of_work = newval;
        data.shortName = this.getShortNameByID(newval);
    } else {
        data[updateField] = newval;
    }
    postData.ration = {
        ID: rationTypeGLJ.ID,
        projectID: rationTypeGLJ.projectID
    };
    postData.updateData = data;
    $.bootstrapLoading.start();
    CommonAjax.post("/glj/modifyKeyValue", postData, function (result) {
        console.log(result);  //更新节点信息
        rationTypeGLJ[updateField] = newval;
        rationTypeGLJ.projectGLJID = result.id;
        rationTypeGLJ.code = result.code;
        rationTypeGLJ.basePrice = result.unit_price.base_price;
        rationTypeGLJ.marketUnitFee = result.unit_price.market_price;
        rationTypeGLJ.isAdd = result.unit_price.is_add;
        rationTypeGLJ.isEstimate = result.is_evaluate;
        rationTypeGLJ.shortName = result.unit_price.short_name;
        //触发计算并更新节点信息
        node.changed = true;
        projectObj.project.projectGLJ.loadData(function () {
            projectObj.project.calcProgram.calcAndSave(node);
            $.bootstrapLoading.end();
        });//重新加载项目工料机数据
        //上面两步都是异步操作，这句应该是要等上面两步做完了再执行的
    }, function (err) {
        $.bootstrapLoading.end();
    });

}

ProjectGLJ.prototype.updatePrice = function (recode, updateField, newval,from) {
    let me = this;
    let projectGljs = this.datas.gljList;
    let pgljID = from=="rg"?recode.projectGLJID:recode.id;//和定额工料机统一接口，项目工料机ID取值不一样
    let glj = _.find(projectGljs, {'id': pgljID});
    if (glj) {
        let data = {id: glj.unit_price.id, field: updateField, newval: newval};
        let callback = function (data) {
            if (updateField == 'base_price') {
                glj.unit_price.base_price = newval;
                me.setAdjustPrice(glj);
            } else {
                glj.unit_price.market_price = newval;
            }
            //更新回传的父节点项目工料机价格
           let gljs = me.getProjectGLJs(data);
            me.refreshRationGLJPrice(glj);//刷新定额工料机列表的记录
            projectObj.project.projectGLJ.loadCacheData();//更新工料机汇总缓存和显示
            gljOprObj.showRationGLJSheetData();
            me.refreshTreeNodePriceIfNeed(glj);//刷新造价书中主树上的定额工料机;
            gljs.push(glj);
            let nodes = me.getImpactRationNodes(gljs);//取到因为改变工料机价格而受影响的定额
            projectObj.project.calcProgram.calcRationsAndSave(nodes);//触发计算程序
            $.bootstrapLoading.end();
        }
        $.bootstrapLoading.start();
        CommonAjax.post("/glj/updatePrice", data, callback, function (err) {
            $.bootstrapLoading.end();
        });
    } else {
        gljOprObj.showRationGLJSheetData();
    }
}


ProjectGLJ.prototype.refreshTreeNodePriceIfNeed = function (data) {
    if ((data.unit_price.type == gljType.MAIN_MATERIAL || data.unit_price.type == gljType.EQUIPMENT) && projectInfoObj.projectInfo.property.displaySetting.disPlayMainMaterial == true) {
        var nodes = _.filter(projectObj.project.mainTree.items, function (tem) {
            if (tem.sourceType == ModuleNames.ration_glj && tem.data.projectGLJID == data.id) {
                tem.data.marketUnitFee = data.unit_price.market_price;
                return true;
            }
        })
        projectObj.mainController.refreshTreeNode(nodes);

    }
}

//根据工料机，取得所有受影响的定额节点
ProjectGLJ.prototype.getImpactRationNodes = function (gljs) {
    let nodes = [];
    let rationMap = {};
    let idArray = _.map(gljs,'id');
    let priceArray = _.map(gljs,'unit_price');
    //先根据项目工料机ID，找到受影响定额的ID
    let ration_glj_list = projectObj.project.ration_glj.datas; //取定额工料机数据
    for (let rg of ration_glj_list) {
        if (_.indexOf(idArray,rg.projectGLJID)!=-1) {
            rationMap[rg.rationID] = true;  //取所有定额ID，用MAP方式去重
        }
    }
    for (let item of projectObj.project.mainTree.items) {
        if (item.sourceType == ModuleNames.ration) {
            if (item.data.type == rationType.gljRation) {//取定额类型的工料机
                let idx = _.indexOf(idArray,item.data.projectGLJID);
                if (idx != -1) {
                    item.data.marketUnitFee = priceArray[idx].market_price; //更新市场单价
                    nodes.push(item);
                }
            } else if (rationMap[item.data.ID] == true) {  //受影响的定额
                nodes.push(item)
            }
        }
    }
    return nodes;
};
ProjectGLJ.prototype.refreshRationGLJPrice = function (glj) {
    for (let ration_glj of gljOprObj.sheetData) {
        if (ration_glj.projectGLJID == glj.id) {
            ration_glj.basePrice = glj.unit_price.base_price;
            ration_glj.marketPrice = glj.unit_price.market_price;
            ration_glj.adjustPrice = this.getAdjustPrice(glj);
        }
    }
}

ProjectGLJ.prototype.refreshRationTypeGLJ = function (glj) {

}

ProjectGLJ.prototype.getProjectGLJs = function (data,refreshPrice=true) {
    let parentGlj = [];
    //
    let projectGljs = this.datas.gljList;
    let indexList = gljKeyArray;
    for (let d of data) {
        if (d) {
            let condition = {};
            for (let index of indexList) {
                if (d[index] != null && d[index] != undefined && d[index] != '') {
                    condition[index] = d[index]
                }
            }
            let glj = _.find(projectGljs, condition);
            if (glj) {
                if(refreshPrice==true){
                    glj.unit_price.base_price = d.base_price;
                    glj.unit_price.market_price = d.market_price;
                    this.setAdjustPrice(glj);
                    this.refreshRationGLJPrice(glj);
                    this.refreshTreeNodePriceIfNeed(glj);
                }
                parentGlj.push(glj);
            }
        }
    }
    return parentGlj;
}

ProjectGLJ.prototype.setAdjustPrice = function (glj) {
    switch (glj.unit_price.type + '') {
        // 人工: 调整基价=基价单价*调整系数
        case GLJTypeConst.LABOUR:
        case GLJTypeConst.MACHINE_LABOUR:
            glj.adjust_price = this.getAdjustPrice(glj);
            break;
        // 机械类型的算法
        case GLJTypeConst.MACHINE:
            console.log('机械');
            break;
        // 材料、主材、设备
        default:
            glj.adjust_price = glj.unit_price.base_price;
    }
}

ProjectGLJ.prototype.getAdjustPrice = function (glj) {
    GLJTypeConst = this.datas.constData.GLJTypeConst !== undefined ? JSON.parse(this.datas.constData.GLJTypeConst) : GLJTypeConst;
    let decimal = getDecimal("glj.unitPrice");
    let quantity_decimal = getDecimal("glj.quantity")
    if (glj.unit_price.type == GLJTypeConst.LABOUR || glj.unit_price.type == GLJTypeConst.MACHINE_LABOUR) {//人工、机上人工，调整价根据定额价*调整系数计算得出。
        let labour = projectObj.project.calcProgram.compiledLabourCoes[glj.adjCoe];
        //let labour=1;
        let coe = labour && labour.coe ? labour.coe : 1;
        return scMathUtil.roundTo(parseFloat(coe * scMathUtil.roundForObj(glj.unit_price.base_price,decimal)), -decimal);
    } else if (notEditType.indexOf(glj.unit_price.type)>0&&glj.ratio_data.length>0) {//对于混凝土、配合比、砂浆、机械台班，调整价根据组成物计算得出。
        let p =0;
        for(let ratio of glj.ratio_data){
           let tem =  _.find( projectObj.project.projectGLJ.datas.gljList,{
               'code': ratio.code,
               'name': ratio.name,
               'specs':ratio.specs,
               'type': ratio.type,
               'unit': ratio.unit
           })
            if(tem){
                p+=scMathUtil.roundForObj(this.getAdjustPrice(tem)*scMathUtil.roundForObj(ratio.consumption,quantity_decimal),decimal);
            }
        }
        return scMathUtil.roundForObj(p,decimal);
    } else {//对于其他普通材料等，无调整系数，调整价=定额价。
        return glj.unit_price.base_price
    }
}

ProjectGLJ.prototype.getShortNameByID = function (ID) {
    let gljTypeMap = this.datas.constData.gljTypeMap;
    return gljTypeMap["typeId" + ID].shortName;
}

ProjectGLJ.prototype.calcQuantity  = function (){
    let project_gljs = this.datas.gljList;
    let mixRatioConnectData = this.datas.mixRatioConnectData;
    let mixRatioSubdivisionMap = {};
    let mixRatioTechMap={};
    for(let pglj of project_gljs ){
        if(pglj.quantity !== 0 && pglj.quantity !== '0'){
            let result = this.getQuantityPerGLJ(pglj,mixRatioSubdivisionMap,mixRatioTechMap);
            pglj.subdivisionQuantity = result.subdivisionQuantity;
            pglj.techQuantity = result.techQuantity;
        }
    }
    //计算做为组成物的消耗量
    for(let pg of project_gljs ){
        if(pg.quantity !== 0 && pg.quantity !== '0'){
            let pg_index = gljOprObj.getIndex(pg,gljKeyArray);
            if(mixRatioConnectData[pg_index]){
                if(mixRatioSubdivisionMap[pg_index]){
                    pg.subdivisionQuantity = scMathUtil.roundForObj(mixRatioSubdivisionMap[pg_index]+pg.subdivisionQuantity,getDecimal("glj.quantity"));
                }
                if(mixRatioTechMap[pg_index]){
                    pg.techQuantity = scMathUtil.roundForObj(mixRatioTechMap[pg_index]+pg.techQuantity,getDecimal("glj.quantity"));
                }
            }
        }
    }

}

ProjectGLJ.prototype.getQuantityPerGLJ =function (pglj,mixRatioSubdivisionMap,mixRatioTechMap) {
    let billIDs =   projectObj.project.Bills.getSubdivisionProjectLeavesID();//取分部分项上的所有叶子清单ID
    let tech_billIDS =  projectObj.project.Bills.getTechLeavesID();//取所有技术措施项目叶子清单ID
    let ration_glj_list = projectObj.project.ration_glj.datas;
    let mixRatioMap = this.datas.mixRatioMap;
    let rations = projectObj.project.Ration.datas;
    let q_decimal = getDecimal("glj.quantity");
    let result={};
    let sum = 0;
    let tech_sum = 0;
    for(let rg of ration_glj_list){
        if(rg.projectGLJID==pglj.id){
            if(_.includes(billIDs,rg.billsItemID)){//计算分部分项
               let total = calcQuantity(rg,mixRatioSubdivisionMap);
               sum = scMathUtil.roundForObj(sum+total,q_decimal);
            }
            if(_.includes(tech_billIDS,rg.billsItemID)){//计算技术措施项目消耗量
                let tech_total = calcQuantity(rg,mixRatioTechMap);
                tech_sum = scMathUtil.roundForObj(tech_sum+tech_total,q_decimal);
            }
        }

    }
    for(let ra of rations){//计算定额类型工料机的消耗量
        if(ra.type == rationType.gljRation&&ra.projectGLJID===pglj.id){
            let r_quantity = scMathUtil.roundForObj(ra.quantity,q_decimal);
            r_quantity = r_quantity?r_quantity:0;
            if(_.includes(billIDs,ra.billsItemID)){//计算分部分项
                sum = scMathUtil.roundForObj(sum+r_quantity,q_decimal);
            }
            if(_.includes(tech_billIDS,ra.billsItemID)){//计算技术措施项目消耗量
                tech_sum = scMathUtil.roundForObj(tech_sum+r_quantity,q_decimal);
            }
        }

    }
    result.subdivisionQuantity = sum;
    result.techQuantity = tech_sum;
    return result;

    function calcQuantity(rg,quantityMap) { //计算工料机在所属定额下的总消耗量
        let tem_ration = _.find(rations,{"ID":rg.rationID});
        let total = parseFloat(gljOprObj.getTotalQuantity(rg,tem_ration));
        let r_index = gljOprObj.getIndex(rg,gljKeyArray);
        if(mixRatioMap.hasOwnProperty(r_index)){
            let mixRatioList = mixRatioMap[r_index];
            for(let m of mixRatioList){
                let m_index = gljOprObj.getIndex(m,gljKeyArray);
                let m_quantity = scMathUtil.roundForObj(total*m.consumption,q_decimal);
                if(quantityMap[m_index]){
                    quantityMap[m_index] = scMathUtil.roundForObj(quantityMap[m_index]+m_quantity,q_decimal);
                }else {
                    quantityMap[m_index] = m_quantity;
                }
            }
        }
        return total;
    }

}