ConstructionCost/modules/ration_glj/facade/glj_calculate_facade.js

/**
 * Created by chen on 2017/7/12.
 */


let mongoose = require('mongoose');
let _=require("lodash");
let ration_glj = mongoose.model('ration_glj');
let ration = mongoose.model('ration');
let ration_coe = mongoose.model('ration_coe');
let std_ration_lib_ration_items = mongoose.model('std_ration_lib_ration_items');
let std_glj_lib_gljList_model = mongoose.model('std_glj_lib_gljList');
let glj_type_util = require('../../../public/cache/std_glj_type_util');
const scMathUtil = require('../../../public/scMathUtil').getUtil();
let decimal_facade = require('../../main/facade/decimal_facade');

module.exports={
    calculateQuantity:calculateQuantity,
    getGLJTypeByID:getGLJTypeByID
}
//辅助定额调整、替换工料机、标准附注条件调整、添加工料机、自定义消耗量(包括删除工料机)、自定义乘系数、市场单价调整
let stateSeq ={
    ass:1,
    replace:2,
    coe:3,
    add:4,
    cusQuantity:5,
    cusCoe:6,
    adjMak:7
};


async function calculateQuantity(query,noNeedCal){
    try {
         let  result ={
             glj_result:[],
             rationID:query.rationID
         };
         let impactRation = await ration.findOne({projectID:query.projectID,ID:query.rationID,deleteInfo:null});
         let gljList = await ration_glj.find(query)//{projectID:query.projectID,rationID:query.rationID}
         let coeList = await ration_coe.find({projectID:query.projectID,rationID:query.rationID}).sort('seq').exec();
         let assList=[];
         let assRation = null;
         let adjustState=[];
         if(!impactRation){//如果定额不存在或者已删除，返回空
             return null;
         }
         if(impactRation._doc.hasOwnProperty("rationAssList")&&impactRation.rationAssList.length>0){
             for(let i=0;i<impactRation.rationAssList.length;i++){
                 let times = calculateTimes(impactRation.rationAssList[i]);
                 if(times!=0){
                     assRation = await  std_ration_lib_ration_items.findOne({rationRepId:impactRation.libID,code:impactRation.rationAssList[i].assistCode});
                     assList.push({times:times,assRation:assRation});
                     adjustState.push({index:stateSeq.ass,content:impactRation.rationAssList[i].name+" "+impactRation.rationAssList[i].actualValue+" : +"+impactRation.rationAssList[i].assistCode+"x"+times});
                 }
             }
         }
        gljList = sortRationGLJ(gljList);
         for(let i =0;i<gljList.length;i++ ){
             let r = await calculateQuantityPerGLJ(gljList[i],i,coeList,assList,adjustState,noNeedCal);
             result.glj_result.push(r);
         }

        if(noNeedCal==null){
            await ration_glj.bulkWrite(generateUpdateTasks(result.glj_result));
        }
         adjustState= _.sortByOrder(adjustState, ['index'], ['asc']);
         adjustState=_.map(adjustState, _.property('content'));
         let adjustStateString = adjustState.join(';');
         await ration.update({projectID:query.projectID,ID:query.rationID,deleteInfo: null},{adjustState:adjustStateString});
         result.adjustState=adjustStateString;
         return result;
    }catch (err){
        console.log(err);
        throw err;
    }
}

function generateUpdateTasks(result) {
    let tasks = [];
    for(let i =0;i<result.length;i++){
        let task= {
            updateOne: {
                filter: result[i].query,
                update: result[i].doc
            }
        }
        tasks.push(task);
    }
    return tasks;
}

function sortRationGLJ(list) {
    list = _.sortByAll(list, [function (item) {
        return item.type + "";
    }, "code"])
    return list;
}

async function calculateQuantityPerGLJ(glj,index,coeList,assList,adjustState,noNeedCal) {
    let decimalObject =await decimal_facade.getProjectDecimal(glj.projectID);
    let decimal = (decimalObject&&decimalObject.glj&&decimalObject.glj.quantity)?decimalObject.glj.quantity:3;
    let quantity =  scMathUtil.roundTo(parseFloat(glj.quantity),-decimal);
    let result={
        query:{
            ID:glj.ID,
            projectID:glj.projectID
        },
        doc:{
            quantity: quantity
        }
    };
    try {
        if(noNeedCal==null){
            if(!glj._doc.hasOwnProperty('customQuantity')||glj.customQuantity==null||glj.customQuantity==""){
                quantity =scMathUtil.roundTo(parseFloat(glj.rationItemQuantity),-decimal);
                quantity =scMathUtil.roundTo(await calculateAss(quantity,assList,glj),-decimal);
                quantity = calculateQuantityByCoes(quantity,coeList,glj);
            }else {
                quantity = glj.customQuantity;
                result.doc.customQuantity = glj.customQuantity;
            }
            let customerCoe = _.last(coeList);
            if(customerCoe&&customerCoe.isAdjust==1){
                quantity = scMathUtil.roundToString(quantity,decimal);
                quantity = calculateQuantityByCustomerCoes(quantity,customerCoe,glj);
            }
            result.doc.quantity =scMathUtil.roundToString(quantity,decimal);
        }
        generateAdjustState(glj,coeList,adjustState,index,result.doc.quantity);
        return result;
    }catch (err){
        throw err;
    }
}

async function calculateAss(quantity,assList,glj) {
    for(let i=0;i<assList.length;i++){
        if(assList[i].assRation){
            let assglj = null;
            for(let aglj of assList[i].assRation.rationGljList){
                if(glj.createType == 'replace'){//如果工料机是替换过的，要用原始的编码来匹配
                    let std_glj = await std_glj_lib_gljList_model.findOne({'ID':aglj.gljId});
                    if(glj.rcode == std_glj.code){
                        assglj = aglj;
                        break;
                    }
                }else if(aglj.gljId == glj.GLJID){
                    assglj = aglj;
                    break;
                }
            }
            if(assglj){
                let calQuantity = assglj.consumeAmt*assList[i].times;
                quantity += calQuantity
            }
        }
    }
    return scMathUtil.roundTo(quantity,-6);
}

function generateAdjustState(glj,coeList,adjustState,index,quantity) {
   //替换工料机 and 添加工料机
    if(glj._doc.createType=='replace'&&glj.rcode!=glj.code){
        adjustState.push({index:stateSeq.replace,content:glj.rcode+'换'+glj.code});
    }else if(glj._doc.createType=='add'){
        let displayQuantity = quantity;
        if(glj._doc.hasOwnProperty('customQuantity')&&(glj.customQuantity != null||glj.customQuantity != '')){
            displayQuantity = glj.customQuantity;
        }
        displayQuantity = displayQuantity&&displayQuantity!=""?parseFloat(displayQuantity):0;
        adjustState.push({index:stateSeq.add,content:'添'+glj.code+'量'+ displayQuantity});
    }
    // to do

  //标准附注条件调整 + 自定义乘系数
    if(0==index){
        for(let i=0;i<coeList.length;i++){
            if(coeList[i].isAdjust==1){
                if(i==coeList.length-1){
                    adjustState.push({index:stateSeq.cusCoe,content:getContent(coeList[i].coes)});//自定义乘系数要去掉倍数为1的
                }else {
                    adjustState.push({index:stateSeq.coe,content:"调 : "+coeList[i].content});//coeList[i].content
                }
            }
        }
    }

    //自定义消耗量
    if(glj._doc.createType!='add'&&glj._doc.hasOwnProperty('customQuantity')){
        if(glj.customQuantity!==null&&glj.customQuantity!=""){
            adjustState.push({index:stateSeq.cusQuantity,content:glj.code+'量'+parseFloat(glj.customQuantity)});
        }
    }
    //市场单价调整
    if(glj._doc.hasOwnProperty('marketPriceAdjust')&&glj.marketPriceAdjust&&glj.marketPriceAdjust!=0){
        //0101005价66.00
        adjustState.push({index:stateSeq.adjMak,content:glj.code+'价'+glj.marketPriceAdjust});
    }

    return adjustState;
}

function getContent(coes) {
    let stringList=[];
    let  temAmount = null;
    let theSame = true;
    for(let t of coes){
        if(temAmount == null){
            temAmount = t.amount;
        }else if(temAmount != t.amount){
            theSame = false;
            break;
        }
    }
    for(let c of coes){
        if( c.amount&&c.amount!=1){
            let operator = c.operator;
            if(c.operator =="*"){
                operator = "X";
            }
            if(theSame == true && c.coeType == "定额"){
                stringList.push(c.coeType+operator+c.amount);
                break;
            }else
            if(theSame == false && c.coeType != "定额"){
                stringList.push(c.coeType+operator+c.amount);
            }

        }
    }
    return stringList.join(",");

}

function calculateTimes(ass){
    let times =(ass.actualValue-ass.stdValue)/ass.stepValue;
    let r = false;
    if(times<0){
        r=true;
        times=times*-1;
    }
    if(ass.carryBit=='四舍五入'){
        times = _.round(times,ass.decimal);
    }else if (ass.carryBit=='进一'){
        times =_.ceil(times,ass.decimal);
    }
    if(r){
        times=times*-1;
    }
    return scMathUtil.roundTo(times,-6);
}

function calculateQuantityByCoes(quantity,coeList,glj){
    let coeQuantity = quantity;
    if(coeList.length>1){
        for(let i=0;i<coeList.length-1;i++){
            coeQuantity = everyCoe(coeQuantity,coeList[i],glj);
        }
    }
    return scMathUtil.roundTo(coeQuantity,-6);
}

function everyCoe(quantity,coe,glj) {
    let coeQuantity = quantity;
    if(coe.isAdjust==1){
        for(let i=0;i<coe.coes.length;i++){
            if(coe.coes[i].gljCode==glj.code){//if(coe.coes[i].coeType=='单个工料机'&&coe.coes[i].gljCode==glj.code)
                coeQuantity = getCalculateResult(coeQuantity,coe.coes[i]);
            } else if(coe.coes[i].coeType=='定额'){
                coeQuantity = getCalculateResult(coeQuantity,coe.coes[i]);
            }else if(coe.coes[i].coeType==getGLJTypeByID(glj.type)){
                coeQuantity = getCalculateResult(coeQuantity,coe.coes[i]);
            }
        }
    }
    return scMathUtil.roundTo(coeQuantity,-6);
}


function calculateQuantityByCustomerCoes(quantify,coe,glj) {
    let rationAmount = coe.coes[0].amount;
    if(_.every(coe.coes,'amount',rationAmount)){
        return getCalculateResult(quantify, coe.coes[0])
    }else {
        for(let i=1;i<coe.coes.length;i++){
            if(coe.coes[i].coeType.search(getGLJTypeByID(glj.type))!=-1){
                return getCalculateResult(quantify,coe.coes[i])
            }
        }
    }
    return quantify
}

function getCalculateResult(quantify,c) {
    let q = quantify;
    switch (c.operator){
        case '+' :
            q = q + c.amount;
            break;
        case '-' :
            q = q - c.amount;
            break;
        case '*' :
            q = q * c.amount;
            break;
        case '/' :
            q = q / c.amount;
            break;
        case '=' :
             q = c.amount;
            break;
    }
    return q;
}

function getGLJTypeByID(id) {
    let glj_type_object = glj_type_util.getStdGljTypeCacheObj();
    let topTypeId = glj_type_object.getTopParentIdByItemId(id);
    let type = glj_type_object.getItemById(topTypeId);
    if(type!=undefined){
        return type.fullName;
    }else {
        return '';
    }
}