YangHuCost/modules/ration_glj/facade/glj_calculate_facade.js

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

module.exports = {
  calculateQuantity: calculateQuantity,
  calculateQuantityFromDivide: calculateQuantityFromDivide,
  getGLJTypeByID: getGLJTypeByID,
};

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");
const commonFacade = require("../../main/facade/common_facade");
let mixRatioModel = mongoose.model("mix_ratio");
let std_ration_lib_ration_items = mongoose.model("std_ration_lib_ration_items");
let divideModel = mongoose.model("divide_setting");
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");
let gljUtil = require("../../../public/gljUtil");
const common_util = require("../../../public/common_util");

//辅助定额调整、稳定土配合比、替换工料机、标准附注条件调整、添加工料机、自定义消耗量(包括删除工料机)、自定义乘系数、市场单价调整
let stateSeq = {
  ass: 1,
  proportion: 2,
  replace: 3,
  coe: 4,
  add: 5,
  cusQuantity: 6,
  cusCoe: 7,
  adjMak: 8,
};
//自定义乘系数与定额工料机类型映射表
let coeTypeMap = {
  人工: 1,
  材料: 2,
  机械: 3,
  施工机具: 3,
  主材: 4,
  设备: 5,
};

async function handleAndGetAssList(impactRation, adjustState) {
  let assList = [],
    assRation = null;
  if (impactRation && impactRation.rationAssList.length > 0) {
    prepareAss(impactRation.rationAssList);
    let temTimes = [];
    let thirdRationCodes = [];
    for (let i = 0; i < impactRation.rationAssList.length; i++) {
      let times = calculateTimes(impactRation.rationAssList[i]);
      if (times != 0) {
        let thirdRationCode = impactRation.rationAssList[i].thirdRationCode;
        if (thirdRationCode && thirdRationCode != "") {
          temTimes.push(times);
          thirdRationCodes.push(thirdRationCode);
        }
        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,
        });
      }
    }
    if (temTimes.length == 2 && thirdRationCodes[0] == thirdRationCodes[1]) {
      //说明有第三定额
      let times_t = temTimes[0] * temTimes[1];
      let tration = await std_ration_lib_ration_items.findOne({
        rationRepId: impactRation.libID,
        code: thirdRationCodes[0],
      });
      if (tration) {
        assList.push({ times: times_t, assRation: tration });
        adjustState.push({
          index: stateSeq.ass,
          content: "+" + thirdRationCodes[0] + "x" + times_t,
        });
      }
    }
  }
  return assList;
}

async function calculateQuantityFromDivide(ID, rationID) {
  let tasks = [],
    udatas = [];
  let divide_setting = await divideModel.findOne({ ID: ID }).lean();
  let impactRation = null,
    gljList = [],
    coeList = [],
    assList = [],
    adjustState = [],
    mixRatioMap = {};
  for (let r of divide_setting.divideList) {
    if (r.ID == rationID) {
      impactRation = r;
      break;
    }
  }
  if (impactRation == null) return null;
  for (let rg of divide_setting.ration_gljs) {
    if (rg.rationID == rationID) gljList.push(rg);
  }
  for (let co of divide_setting.ration_coes) {
    if (co.rationID == rationID) coeList.push(co);
  }
  assList = await handleAndGetAssList(impactRation, adjustState);
  for (let glj of gljList) {
    //先把混凝土，砂浆，配合比有自定义消耗的挑出来
    if (gljUtil.isConcreteType(glj.type))
      await getMixRatioMap(glj, gljList, coeList, assList, mixRatioMap);
  }
  for (let i = 0; i < gljList.length; i++) {
    let r = await calculateQuantityPerGLJ(
      gljList[i],
      gljList,
      coeList,
      assList,
      adjustState,
      mixRatioMap,
      null
    );
    if (quantityUpdateCheck(gljList[i], r) == true) {
      let ndoc = {};
      for (let key in r.doc) {
        ndoc["ration_gljs.$." + key] = r.doc[key];
      }
      udatas.push({
        ID: gljList[i].ID,
        model: "ration_gljs",
        type: "update",
        doc: r.doc,
      });
      tasks.push({
        updateOne: {
          filter: { ID: ID, "ration_gljs.ID": gljList[i].ID },
          update: ndoc,
        },
      });
    }
  }
  let newName = generateRationName(impactRation, gljList);
  udatas.push({ ID: impactRation.ID, type: "update", doc: { name: newName } });
  tasks.push({
    updateOne: {
      filter: { ID: ID, "divideList.ID": impactRation.ID },
      update: { "divideList.$.name": newName },
    },
  });
  return [tasks, udatas];
}

async function calculateQuantity(
  query,
  noNeedCal = null,
  refreshRationName = false
) {
  try {
    let result = {
      glj_result: [],
      rationID: query.rationID,
    };
    let impactRation = await ration.findOne({ ID: query.rationID });
    let gljList = await ration_glj.find(query); //{projectID:query.projectID,rationID:query.rationID}
    let coeList = await ration_coe
      .find({ rationID: query.rationID })
      .sort("seq")
      .exec();
    let assList = [],
      adjustState = [],
      mixRatioMap = {};
    if (!impactRation) {
      //如果定额不存在或者已删除，返回空
      return null;
    }
    if (
      impactRation._doc.hasOwnProperty("rationAssList") &&
      impactRation.rationAssList.length > 0
    ) {
      assList = await handleAndGetAssList(impactRation, adjustState);
    }
    // 稳定土调整状态
    const proportionStr = gljList
      .filter((glj) => glj.rationProportion)
      .map((glj) => glj.adjustProportion || 0)
      .join(":");
    if (proportionStr) {
      adjustState.push({ index: stateSeq.proportion, content: proportionStr });
    }
    for (let glj of gljList) {
      //先把混凝土，砂浆，配合比有自定义消耗的挑出来
      if (gljUtil.isConcreteType(glj.type))
        await getMixRatioMap(glj, gljList, coeList, assList, mixRatioMap);
    }
    gljList = gljUtil.sortRationGLJ(gljList);
    for (let i = 0; i < gljList.length; i++) {
      let r = await calculateQuantityPerGLJ(
        gljList[i],
        gljList,
        coeList,
        assList,
        adjustState,
        mixRatioMap,
        noNeedCal
      );
      if (quantityUpdateCheck(gljList[i], r) == true) result.glj_result.push(r);
    }
    if (noNeedCal == null && result.glj_result.length > 0) {
      await ration_glj.bulkWrite(generateUpdateTasks(result.glj_result));
    }
    adjustState = _.sortByOrder(adjustState, ["index"], ["asc"]);
    adjustState = _.map(adjustState, _.property("content"));
    let adjustStateString = adjustState.join(";");
    let setData = { adjustState: adjustStateString };
    if (refreshRationName == true) {
      //需要更新定额名称
      let newName = generateRationName(impactRation, gljList);
      setData.name = newName;
      result.rationName = newName;
    }
    await ration.update({ ID: query.rationID }, setData);
    result.adjustState = adjustStateString;
    return result;
  } catch (err) {
    console.log(err);
    throw err;
  }
}

function quantityUpdateCheck(glj, r) {
  //检查，有改变的才更新
  for (let key in r.doc) {
    if (glj[key] != r.doc[key]) return true;
  }
  return false;
}

function generateRationName(ration, gljList) {
  let caption = ration.caption ? ration.caption : ration.name;
  let replaceList = [];
  if (ration.rationAssList && ration.rationAssList.length > 0) {
    //这里要处理第三定额和多辅助定额的情况
    let isThird =
      ration.rationAssList.length == 2 &&
      ration.rationAssList[0].thirdRationCode &&
      ration.rationAssList[0].thirdRationCode != ""; //说明有第三定额的情况
    let adjustMatch = "",
      notAdjust = "";
    for (let ass of ration.rationAssList) {
      let tem = "";
      if (
        ass.isAdjust == 1 &&
        ass.actualValue != null &&
        ass.actualValue != undefined
      ) {
        tem = ass.actualValue;
        adjustMatch = tem;
      } else {
        tem = ass.stdValue;
        notAdjust = tem;
      }
      if (isThird) replaceList.push(tem);
    }
    if (replaceList.length == 0) {
      adjustMatch != ""
        ? replaceList.push(adjustMatch)
        : replaceList.push(notAdjust);
    }
    for (let r of replaceList) {
      caption = caption.replace(/%s/i, r);
    }
  }
  // 更新定额名称中显示的稳定土配合比
  const proportionStr = gljList
    .filter((glj) => glj.rationProportion)
    .map((glj) => glj.adjustProportion || 0)
    .join(":");
  if (proportionStr) {
    caption = caption.replace(/%p/i, proportionStr);
  }
  let reNameList = [];
  for (let g of gljList) {
    //glj._doc.createType=='replace'&&glj.rcode!=glj.code
    if (g.createType == "replace" && g.rcode != g.code) {
      //是替换工料机
      let reName = g.name;
      if (!_.isEmpty(g.specs)) reName = reName + " " + g.specs;
      reNameList.push(reName);
    }
  }
  if (reNameList.length > 0) {
    let reNameString = reNameList.join(" ");
    caption = caption + " 换为【" + reNameString + "】";
  }
  return caption;
}

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;
}

async function calcWhenNoCustomQuantiyt(
  decimal,
  glj,
  gljList,
  coeList,
  assList
) {
  let quantity = glj.rationItemQuantity
    ? scMathUtil.roundTo(parseFloat(glj.rationItemQuantity), -decimal)
    : 0;
  quantity = scMathUtil.roundTo(
    await calculateAss(quantity, assList, glj),
    -decimal
  );
  if (glj.rationProportion && common_util.isDef(glj.adjustProportion)) {
    const proportionRate = glj.adjustProportion / glj.rationProportion;
    quantity *= proportionRate;
  }
  quantity = calculateQuantityByCoes(quantity, coeList, glj, gljList, decimal);
  return quantity;
}

async function calculateQuantityPerGLJ(
  glj,
  gljList,
  coeList,
  assList,
  adjustState,
  mixRatioMap,
  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,
    },
    doc: {
      quantity: quantity,
    },
  };
  try {
    if (noNeedCal == null) {
      //计算顺序：辅助定额， 稳定土配合比、附注条件，自定义消耗（如果有就不用前计算两项），自定义乘系数
      if (noCustomQuantiyt(glj)) {
        quantity = await calcWhenNoCustomQuantiyt(
          decimal,
          glj,
          gljList,
          coeList,
          assList
        );
        let mIndex = gljUtil.getIndex(glj);
        if (mixRatioMap[mIndex]) {
          //组成物
          quantity = calcQuantityForMix(quantity, mixRatioMap[mIndex], decimal);
        }
        if (quantity < 0) quantity = 0;
      } 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,
          decimal
        );
      }

      result.doc.quantity = scMathUtil.roundToString(quantity, decimal);
      //2019-01-03 需求修改中间过程的价格不参与计算
      //glj.quantity = quantity;//这里保存中间过程计算出来的消耗量，后面处理“+*”操作符时要用到
    }
    generateAdjustState(
      glj,
      coeList,
      adjustState,
      gljList,
      result.doc.quantity
    );
    return result;
  } catch (err) {
    throw err;
  }
}

function calcQuantityForMix(quantity, plist, decimal) {
  for (let pglj of plist) {
    let consumption = scMathUtil.roundForObj(pglj.consumption, decimal);
    let customQuantity = scMathUtil.roundForObj(pglj.customQuantity, decimal);
    let temQuantity = scMathUtil.roundForObj(
      consumption * pglj.assCoeQuantity,
      6
    );
    let pcustomQuantity = scMathUtil.roundForObj(
      consumption * customQuantity,
      6
    );
    quantity = scMathUtil.roundForObj(quantity - temQuantity, 6);
    quantity = scMathUtil.roundForObj(quantity + pcustomQuantity, decimal);
  }
  return quantity;
}

async function getMixRatioMap(glj, gljList, coeList, assList, mixRatioMap) {
  //生成组成物对应的父工料机的映射表
  let decimalObject = await decimal_facade.getProjectDecimal(glj.projectID);
  let decimal =
    decimalObject && decimalObject.glj && decimalObject.glj.quantity
      ? decimalObject.glj.quantity
      : 3;
  let assCoeQuantity = await calcWhenNoCustomQuantiyt(
    decimal,
    glj,
    gljList,
    coeList,
    assList
  ); //计算要用父工料机经过辅助子目换算后的量
  let unitPriceFileId = await commonFacade.getUnitPriceFileId(glj.projectID);
  let connect_key = gljUtil.getIndex(glj);
  let mixList = await mixRatioModel.find({
    unit_price_file_id: unitPriceFileId,
    connect_key: connect_key,
  });
  for (let m of mixList) {
    if (glj.createType == "replace" && glj.mIndexObj) {
      //如果是替换过的工料机，要造一条加的数据去补回下面的减数据
      //与下面的减相对应，如果有没被引用子组成物工料机，会少一条加的数据，这样，那条没被引用的消耗量会被减为0
      addToMixMap(m, mixRatioMap, assCoeQuantity, 0); //addToMixMap(m,mixRatioMap,glj.rationItemQuantity,0); -- 2019-04-15 和下面的减相对做修改
    }
    if (!noCustomQuantiyt(glj)) {
      //有自定义消耗量才做正常的计算处理
      addToMixMap(m, mixRatioMap, glj.customQuantity, assCoeQuantity);
    }
  }
  if (glj.createType == "replace" && glj.mIndexObj) {
    //如果这条是替换过的混凝土，原来的组成物的消耗量还要减去替换前的混凝土得到的消耗量
    let t_con_key = gljUtil.getIndex(glj.mIndexObj);
    let tmixList = await mixRatioModel.find({
      unit_price_file_id: unitPriceFileId,
      connect_key: t_con_key,
    });
    for (let tm of tmixList) {
      addToMixMap(tm, mixRatioMap, 0, assCoeQuantity); //addToMixMap(tm,mixRatioMap,0,glj.rationItemQuantity);
      // -- 2019-04-15 修改bugs 这里把glj.rationItemQuantity 改成assCoeQuantity。 定额下组成物的消耗量要减去父工料机经过辅助定额或者子目换算后的对应的增加量
    }
  }
  function addToMixMap(m, map, cust, ass, isReplace = false) {
    let mkey = gljUtil.getIndex(m);
    let pObj = {
      customQuantity: cust,
      assCoeQuantity: ass,
      consumption: m.consumption,
      isReplace: isReplace,
    };
    if (map[mkey]) {
      map[mkey].push(pObj);
    } else {
      map[mkey] = [pObj];
    }
  }
}

function noCustomQuantiyt(glj) {
  //是否有自定义消耗量
  return (
    glj.customQuantity === undefined ||
    glj.customQuantity === null ||
    glj.customQuantity == ""
  );
}

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, gljList, quantity) {
  //替换工料机 and 添加工料机
  if (glj.createType == "replace" && glj.rcode != glj.code) {
    adjustState.push({
      index: stateSeq.replace,
      content: glj.rcode + "换" + glj.code,
    });
  } else if (glj.createType == "add") {
    let displayQuantity = quantity;
    if (
      glj.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,
      type: "添" + glj.code,
    });
  }
  // to do

  //标准附注条件调整 + 自定义乘系数
  if (_.last(gljList).ID == glj.ID) {
    //最后一个工料机的时候才生成，生成一次就可以了
    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 {
          if (coeList[i].select_code && coeList[i].select_code != "") {
            _.remove(adjustState, {
              content: coeList[i].original_code + "换" + coeList[i].select_code,
            }); //去掉替换工料机自动生成的调整状态
            adjustState.push({
              index: stateSeq.coe,
              content:
                "调 : " +
                coeList[i].original_code +
                "换" +
                coeList[i].select_code,
            });
          }
          for (let c of coeList[i].coes) {
            if (c.coeType == "单个工料机")
              _.remove(adjustState, { type: "添" + c.gljCode }); //如果是单个工料机子目换算类型自动添加的，去掉前面手动生成的调整状态
            if (c.coeType == "替换人材机")
              _.remove(adjustState, {
                content: c.gljCode + "换" + c.replaceCode,
              }); //如果是替换人材机子目换算类型自动添加的，去掉前面手动生成的调整状态
          }
          if (coeList[i].content)
            adjustState.push({
              index: stateSeq.coe,
              content: "调 : " + coeList[i].content,
            }); //coeList[i].content
        }
      }
    }
  }

  //自定义消耗量
  if (glj.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.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 prepareAss(assList) {
  //处理辅助定额，支持多个辅助定额的情况
  for (let a of assList) {
    if (a.groupList && a.groupList.length > 1) {
      //组里有多个定额的情况
      let newList = _.sortByAll(a.groupList, [
        function (item) {
          return parseFloat(item.param);
        },
      ]); //先按参数排序
      let pre = 0;
      for (let n of newList) {
        if (a.actualValue > pre && a.actualValue <= parseFloat(n.param)) {
          //落在中间，则用组里的这条定额
          a._doc.param = n.param;
          a._doc.paramName = n.paramName;
          a._doc.assistCode = n.assistCode;
          break;
        }
        pre = parseFloat(n.param);
      }
    }
  }
}

function calculateTimes(ass) {
  if (ass.isAdjust == 0) return 0; //打勾辅助定额才计算
  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);
  } else if (ass.carryBit == "舍一") {
    times = _.floor(times, ass.decimal);
  }
  if (r) {
    times = times * -1;
  }
  return scMathUtil.roundTo(times, -6);
}

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

function everyCoe(quantity, coe, glj, gljList, decimal) {
  let coeQuantity = quantity;
  if (coe.isAdjust == 1) {
    for (let i = 0; i < coe.coes.length; i++) {
      if (
        coe.coes[i].coeType == "单个工料机" &&
        coe.coes[i].gljCode == glj.code
      ) {
        //if(coe.coes[i].coeType=='单个工料机'&&coe.coes[i].gljCode==glj.code)
        coeQuantity = getCalculateResult(
          coeQuantity,
          coe.coes[i],
          coe,
          gljList,
          decimal
        );
      } else if (
        coe.coes[i].coeType == "替换人材机" &&
        glj.rcode == coe.coes[i].gljCode &&
        glj.code == coe.coes[i].replaceCode
      ) {
        coeQuantity = getCalculateResult(
          coeQuantity,
          coe.coes[i],
          coe,
          gljList,
          decimal
        );
      } else if (
        coe.coes[i].coeType == "所选人材机" &&
        glj.rcode == coe.original_code &&
        glj.code == coe.select_code
      ) {
        coeQuantity = getCalculateResult(
          coeQuantity,
          coe.coes[i],
          coe,
          gljList,
          decimal
        );
      } else if (coe.coes[i].coeType == "定额") {
        coeQuantity = getCalculateResult(
          coeQuantity,
          coe.coes[i],
          coe,
          gljList,
          decimal
        );
      } else if (
        coeTypeMap[coe.coes[i].coeType] == getRootGLJType(glj.type).ID
      ) {
        coeQuantity = getCalculateResult(
          coeQuantity,
          coe.coes[i],
          coe,
          gljList,
          decimal
        );
      }
    }
  }
  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 (coeTypeMap[coe.coes[i].coeType] == getRootGLJType(glj.type).ID) {
        return getCalculateResult(quantify, coe.coes[i]);
      }
    }
  }
  return quantify;
}

function getCoeSelectedGLJ(gljList, rcode, code) {
  if (gljList && code && code != "") {
    let o_glj = _.find(gljList, { rcode: rcode, code: code });
    return o_glj;
  }
  return null;
}

function getCalculateResult(quantify, c, coe, gljList, decimal) {
  let q = quantify;
  let o_glj = null;
  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 "+*":
      o_glj = getCoeSelectedGLJ(gljList, coe.original_code, coe.select_code);
      if (o_glj) {
        q =
          q +
          c.amount * scMathUtil.roundForObj(o_glj.rationItemQuantity, decimal);
      }
      break;
    case "-*":
      o_glj = getCoeSelectedGLJ(gljList, coe.original_code, coe.select_code);
      if (o_glj) {
        q =
          q -
          c.amount * scMathUtil.roundForObj(o_glj.rationItemQuantity, decimal);
      }
      break;
    case "=":
      q = c.amount;
      break;
  }
  return q;
}

function getRootGLJType(id) {
  let glj_type_object = glj_type_util.getStdGljTypeCacheObj();
  let topTypeId = glj_type_object.getTopParentIdByItemId(id);
  let type = glj_type_object.getItemById(topTypeId);
  return type;
}

function getGLJTypeByID(id) {
  let type = getRootGLJType(id);
  if (type != undefined) {
    return type.fullName;
  } else {
    return "";
  }
}