YangHuCost/modules/main/facade/project_facade.js

/**
 * Created by zhang on 2018/1/26.
 */

module.exports = {
  setChildren,
  sortChildren,
  markUpdateProject: markUpdateProject,
  removeProjectMark: removeProjectMark,
  updateNodes: updateNodes,
  saveProperty: saveProperty,
  getDefaultColSetting: getDefaultColSetting,
  markProjectsToChange: markProjectsToChange,
  getBudgetSummayDatas: getBudgetSummayDatas,
  getGLJSummayDatas: getGLJSummayDatas,
};

let mongoose = require("mongoose");
let logger = require("../../../logs/log_helper").logger;
let projectsModel = mongoose.model("projects");
let async_n = require("async");
let _ = require("lodash");
let ration_model = require("../models/ration");
let optionModel = mongoose.model("options");
let bill_model = require("../models/bills");
let consts = require("../models/project_consts");
let projectConsts = consts.projectConst;
let ration_glj_model = mongoose.model("ration_glj");
let rationTemplateModel = mongoose.model("ration_template");
let project_glj_model = mongoose.model("glj_list");
let ration_glj_facade = require("../../ration_glj/facade/ration_glj_facade");
const uuidV1 = require("uuid/v1");
const gljUtil = require("../../../public/gljUtil");
let stdColSettingModel = mongoose.model("std_main_col_lib");
let decimal_facade = require("../../main/facade/decimal_facade");
const scMathUtil = require("../../../public/scMathUtil").getUtil();
const calcUtil = require("../../../public/calculate_util");
const { fixedFlag } = require("../../../public/common_constants");
const GLJListModel = require("../../glj/models/glj_list_model");
const projectDao = require("../../pm/models/project_model").project;
const UnitPriceFileModel = require("../../glj/models/unit_price_file_model");

async function createRationGLJData(glj) {
  glj.ID = uuidV1();
  let [info, projectGLJ] = await ration_glj_facade.getInfoFromProjectGLJ(glj);
  let newRecode = ration_glj_facade.createNewRecord(info);
  return [newRecode, projectGLJ];
}

function generateTasks(data, userID) {
  let tasks = [];
  let deleteInfo = {
    deleted: true,
    deleteDateTime: new Date(),
    deleteBy: userID,
  };
  if (data.delete && data.delete.length > 0) {
    for (let bd of data.delete) {
      //原先是假删除，现在改成真删除
      let task = {
        deleteOne: {
          filter: {
            ID: bd.ID,
            projectID: bd.projectID,
          },
        },
      };
      /* let task={
           updateOne:{
               filter:{
                   ID:bd.ID,
                   projectID:bd.projectID
               },
               update :{
                   deleteInfo:deleteInfo
               }
           }
       };*/
      tasks.push(task);
    }
  }
  if (data.add && data.add.length > 0) {
    for (let n_data of data.add) {
      let task = {
        insertOne: {
          document: n_data,
        },
      };
      tasks.push(task);
    }
  }
  return tasks;
}

async function updateNodes(datas) {
  let nodeGroups = _.groupBy(datas, "type");
  let asyncTasks = [];
  let deleteRationIDs = [];
  let taskMap = {};
  taskMap[projectConsts.BILLS] = {
    tasks: [],
    model: bill_model.model,
  };
  taskMap[projectConsts.RATION] = {
    tasks: [],
    model: ration_model.model,
  };
  taskMap[projectConsts.RATION_GLJ] = {
    tasks: [],
    model: ration_glj_model,
  };
  taskMap[projectConsts.PROJECTGLJ] = {
    tasks: [],
    model: project_glj_model,
  };
  taskMap[projectConsts.PROJECT] = {
    tasks: [],
    model: projectsModel,
  };
  taskMap[projectConsts.RATION_TEMPLATE] = {
    tasks: [],
    model: rationTemplateModel,
  };

  for (let type in nodeGroups) {
    for (let node of nodeGroups[type]) {
      if (taskMap[type]) {
        if (type == projectConsts.RATION) {
          if (node.action == "delete") deleteRationIDs.push(node.data.ID);
        }
        if (type == projectConsts.RATION_GLJ) {
          if (node.action == "add") {
            //添加定額工料机的時候，要先走项目工料机的逻辑
            let [newRecode, projectGLJ] = await createRationGLJData(node.data);
            node.data = newRecode;
            node.projectGLJ = projectGLJ;
          }
        }
        taskMap[type].tasks.push(getTask(node));
      }
    }
  }

  for (let key in taskMap) {
    if (taskMap[key].tasks.length > 0)
      asyncTasks.push(taskMap[key].model.bulkWrite(taskMap[key].tasks));
  }

  if (asyncTasks.length > 0) await Promise.all(asyncTasks);
  if (deleteRationIDs.length > 0)
    await ration_glj_model.deleteMany({
      rationID: {
        $in: deleteRationIDs,
      },
    });

  return datas;

  function getTask(node, idFiled = "ID") {
    let task = {};
    if (node.action == "add") {
      task.insertOne = {
        document: node.data,
      };
    } else if (node.action == "delete") {
      task.deleteOne = {
        filter: {},
      };
      task.deleteOne.filter[idFiled] = node.data[idFiled];
    } else {
      task.updateOne = {
        filter: {},
        update: {}, //_.cloneDeep(node.data)
      };
      for (let key in node.data) {
        if (key.indexOf("function(") !== -1) {
          //有时候会出现field里包含一串 function(e){if(e.length>0)... 这些东西，本地测试又不出现，所以这里先把这些field删除看看
          delete node.data[key];
        } else {
          task.updateOne.update[key] = node.data[key];
        }
      }

      task.updateOne.filter[idFiled] = node.data[idFiled]; //现在复制项目也重新生成一个新的ID了，所以ID是唯一的
      delete task.updateOne.update[idFiled]; //防止误操作
    }

    return task;
  }
}

//data = {feeRateID:111111,projectID:1245}; type = feeRate
async function markUpdateProject(data, type) {
  let query = {
    deleteInfo: null,
  };
  if (type == "feeRate") {
    //更改了费率
    query["property.feeFile.id"] = data.feeRateID;
  }
  if (type == "unitFile") {
    //更改了单价文件
    query["property.unitPriceFile.id"] = data.unitFileID; //unitPriceFile
  }
  let projects = await projectsModel.find(query);
  return await markProjectsToChange(
    projects,
    type,
    data.projectID,
    data.isInclude
  );
}

async function markProjectsToChange(projects, type, extProjectID, isInclude) {
  let tasks = [];
  for (let p of projects) {
    if (isInclude != true) {
      if (extProjectID && p.ID === extProjectID) continue; //排除当前项目
    }
    tasks.push(generateMarkTask(type, p.ID));
  }
  return tasks.length > 0 ? await projectsModel.bulkWrite(tasks) : null;
}

async function removeProjectMark(projectID) {
  return await projectsModel.findOneAndUpdate(
    {
      ID: projectID,
    },
    {
      $unset: {
        changeMark: 1,
      },
    }
  );
}

function generateMarkTask(value, projectID) {
  let task = {
    updateOne: {
      filter: {
        ID: projectID,
      },
      update: {
        changeMark: value,
      },
    },
  };
  return task;
}

// {projectID: 5, propertyName: 'aaa', propertyValue: 1}
function saveProperty(data, callback) {
  let obj = {};
  let pn = "property." + data.propertyName;
  obj[pn] = data.propertyValue;
  projectsModel.update(
    {
      ID: data.projectID,
    },
    obj,
    function (err) {
      if (err) {
        logger.err(pn + " save error: " + err);
        callback(err, null);
      } else {
        logger.info(pn + " saved.");
        callback("", null);
      }
    }
  );
}

async function getDefaultColSetting(libID) {
  return await stdColSettingModel.findOne(
    {
      ID: libID,
      deleted: false,
    },
    "-_id main_tree_col"
  );
}

async function getBudgetSummayDatas(
  projectIDs,
  userID,
  compilationID,
  overWriteUrl
) {
  try {
    let projects = [];
    let names = [];
    let prjTypeNames = [];
    let compilationScopes = [];
    let decimal = null;
    let isProgressiveType = true;
    for (let ID of projectIDs) {
      projects.push(await getBillsByProjectID(ID));
    }
    if (projects.length == 0) {
      return [];
    }
    let mp = projects[0];
    names.push(mp.name);
    prjTypeNames.push(mp.prjTypeName);
    compilationScopes.push(mp.compilationScope);
    if (projects.length == 1)
      decimal = await decimal_facade.getProjectDecimal(projectIDs[0]); //如果只有一个项目，则没走合并的那一步，decimal会为空，从面报错
    for (let i = 1; i < projects.length; i++) {
      names.push(projects[i].name);
      prjTypeNames.push(projects[i].prjTypeName);
      compilationScopes.push(projects[i].compilationScope);
      decimal = await mergeProject(mp.roots, projects[i].roots);
    }

    let options_setting = await optionModel
      .findOne({
        user_id: userID,
        compilation_id: compilationID,
      })
      .lean();
    if (
      options_setting &&
      options_setting.options &&
      options_setting.options.GENERALOPTS
    )
      isProgressiveType =
        options_setting.options.GENERALOPTS.progressiveType == 1 ? false : true;

    let SummaryAuditDetail = getReportData(
      names,
      mp.roots,
      prjTypeNames,
      compilationScopes,
      decimal,
      isProgressiveType,
      mp.progressiveInterval,
      overWriteUrl
    );
    let parentProject = await projectsModel.findOne({
      ID: mp.ParentID,
    });
    let result = {
      prj: {},
      SummaryAudit: {
        name: parentProject ? parentProject.name : "",
        编制: mp.author,
        复核: mp.auditor,
        编制范围: mp.compilationScope,
      },
      SummaryAuditDetail: SummaryAuditDetail,
    };
    return result;
  } catch (e) {
    // console.log(e.message)
    console.log(e);
  }
}

function getReportData(
  nameList,
  items,
  prjTypeNames,
  compilationScopes,
  decimal,
  isProgressiveType,
  progressiveInterval,
  overWriteUrl
) {
  let datas = [],
    totalItem = null,
    one_to_four_Item = null;
  let overWrite = null;
  if (overWriteUrl && overWriteUrl != "") {
    overWrite = require("../../.." + overWriteUrl);
  }
  setChildrenDatas(items, datas);
  if (one_to_four_Item)
    recalcTotalItem(
      one_to_four_Item,
      datas,
      isProgressiveType,
      progressiveInterval
    );
  if (totalItem)
    recalcTotalItem(totalItem, datas, isProgressiveType, progressiveInterval);
  for (let d of datas) {
    if (d.billsTtlPrice && totalItem.billsTtlPrice) {
      d["各项费用比例"] = scMathUtil.roundForObj(
        (d.billsTtlPrice / totalItem.billsTtlPrice) * 100,
        2
      );
    }
    d["prjNames"] = nameList;
    d["prjTypeNames"] = prjTypeNames;
    d["编制范围明细"] = compilationScopes;
  }

  return datas;

  function recalcTotalItem(
    item,
    datas,
    isProgressiveType,
    progressiveInterval
  ) {
    let totalExp = item.calcBase;
    if (totalExp.indexOf("@") == -1) return;
    if (isProgressiveType && progressiveInterval) {
      //有累进的要重新计算总金额和技术经济综合指标
      let hasReplace = false;
      for (let t of datas) {
        if (totalExp.includes(t.ID)) hasReplace = true; // 强壮性处理：控制提前计算问题(ID在datas中找不到)
        totalExp = totalExp.replace(t.ID, t.billsTtlPrice + "");
      }
      if (hasReplace) {
        totalExp = totalExp.replace(/@/g, "");
        //还有其他符号（如%）
        totalExp = totalExp.replace(/%/g, " / 100 ");
        let nTotal = eval(totalExp);
        item.billsTtlPrice = scMathUtil.roundForObj(
          nTotal,
          decimal.bills.totalPrice
        );
        item["技术经济综合指标"] =
          item.billsTtlAmt && parseFloat(item.billsTtlAmt) !== 0
            ? scMathUtil.roundForObj(item.billsTtlPrice / item.billsTtlAmt, 2)
            : scMathUtil.roundForObj(item.billsTtlPrice, 2);
      }
    }
  }

  function setChildrenDatas(children, arr, level = 0, rootFlag) {
    let temTotalPrice = 0;
    for (let c of children) {
      if (level == 0) rootFlag = c.flag; //取最顶层节点的固定清单类别
      let tbill = getBillDatas(c, level, rootFlag);
      arr.push(tbill);
      let sumChildren = setChildrenDatas(c.children, arr, level + 1, rootFlag);
      if (isProgressiveType && progressiveInterval) {
        //如果要累进的，父节点要重新汇总
        if (c.children.length > 0) {
          tbill.billsTtlPrice = sumChildren;
          tbill["技术经济综合指标"] =
            tbill.billsTtlAmt && parseFloat(tbill.billsTtlAmt) !== 0
              ? scMathUtil.roundForObj(
                  tbill.billsTtlPrice / tbill.billsTtlAmt,
                  2
                )
              : scMathUtil.roundForObj(tbill.billsTtlPrice, 2);
        } else if (
          tbill.calcBase &&
          tbill.calcBase.indexOf("@") >= 0 &&
          tbill.calcBase.indexOf("{") < 0
        ) {
          // 说明：在实际中，发现清单‘第一、二、三部分费用合计’没有再计算，这样会造成问题(实际情况比较复杂，需要多方测试)
          recalcTotalItem(tbill, arr, isProgressiveType, progressiveInterval);
        }
        if (level > 0)
          temTotalPrice = scMathUtil.roundForObj(
            tbill.billsTtlPrice + temTotalPrice,
            decimal.bills.totalPrice
          );
      }
    }
    return temTotalPrice;
  }

  function getBillDatas(bills, level, rootFlag) {
    let tem = {
      ID: bills.ID,
      billsName: bills.name,
      billsCode: bills.code,
      billsUnit: bills.unit,
      billsTtlAmt: bills.quantity,
      billsPrices: [],
      billsUnitPrices: [],
      rationCommons: [],
      billsAmounts: [],
      技术经济指标: [],
      billsLevel: level,
      calcBase: bills.calcBase,
      billsMemos: bills.remark,
    };
    let total = 0;
    let rationTotal = 0;
    let baseTotal = 0;
    for (let n of nameList) {
      let p = 0; //金额
      let up = 0; //单价
      let ra = 0; //定额建安费
      let bt = 0; //累计相关
      if (bills.unitPrices[n])
        up = scMathUtil.roundForObj(
          bills.unitPrices[n],
          decimal.bills.unitPrice
        );
      tem.billsUnitPrices.push(up);
      if (bills.prices[n]) {
        p = scMathUtil.roundForObj(bills.prices[n], decimal.bills.totalPrice);
        total = scMathUtil.roundForObj(p + total, decimal.process);
      }
      tem.billsPrices.push(p);
      if (bills.rationCommons[n]) {
        ra = scMathUtil.roundForObj(
          bills.rationCommons[n],
          decimal.bills.totalPrice
        );
        rationTotal = scMathUtil.roundForObj(ra + rationTotal, decimal.process);
      }
      tem.rationCommons.push(ra);
      if (bills.quantityMap[n] && parseFloat(bills.quantityMap[n]) !== 0) {
        tem.billsAmounts.push(bills.quantityMap[n]);
        tem["技术经济指标"].push(
          scMathUtil.roundForObj(p / bills.quantityMap[n], 2)
        );
      } else {
        tem.billsAmounts.push(0);
        tem["技术经济指标"].push(scMathUtil.roundForObj(p, 2));
      }
      //如果是第三部分下的子清单，才要计算累计的相关信息
      // 10-26 需求变更，所有清单都算累计
      /* if (rootFlag == fixedFlag.MAINTENANCE_EXPENSES) { 
        if (bills.baseProgressiveFees[n]) {
          bt = scMathUtil.roundForObj(bills.baseProgressiveFees[n], decimal.bills.totalPrice);
          baseTotal = scMathUtil.roundForObj(bt + baseTotal, decimal.process);
        }
      } */
      if (bills.baseProgressiveFees[n]) {
        bt = scMathUtil.roundForObj(
          bills.baseProgressiveFees[n],
          decimal.bills.totalPrice
        );
        baseTotal = scMathUtil.roundForObj(bt + baseTotal, decimal.process);
      }
    }
    tem.billsTtlPrice = scMathUtil.roundForObj(total, decimal.bills.totalPrice);
    // 10-26 需求变更，所有清单都算累计   && rootFlag == fixedFlag.MAINTENANCE_EXPENSES
    if (progressiveInterval && isProgressiveType) {
      let baseArr = calcUtil.getProgressive(
        bills.calcBase,
        overWrite ? overWrite.progression : undefined
      );
      if (baseArr.length > 0) {
        let deficiency = (overWrite && overWrite.deficiency) || null;
        let beyond = (overWrite && overWrite.beyond) || null;
        let calcTotal = calcUtil.getProgressiveFee(
          baseTotal,
          baseArr[0],
          progressiveInterval,
          decimal.bills.totalPrice,
          deficiency,
          beyond
        );
        tem.billsTtlPrice = calcTotal;
        let rate = scMathUtil.roundForObj(
          (calcTotal * 100) / baseTotal,
          decimal.feeRate
        );
        tem.billsMemos = "费率：" + rate + "%";
        //“费率：n%”，n为汇总后重算的金额/汇总后的基数
      }
    }
    tem.rationTotal = scMathUtil.roundForObj(
      rationTotal,
      decimal.bills.totalPrice
    ); //定额总建安费
    tem["技术经济综合指标"] =
      tem.billsTtlAmt && parseFloat(tem.billsTtlAmt) !== 0
        ? scMathUtil.roundForObj(tem.billsTtlPrice / tem.billsTtlAmt, 2)
        : scMathUtil.roundForObj(tem.billsTtlPrice, 2);
    if (bills.flag == fixedFlag.TOTAL_COST) totalItem = tem;
    if (bills.flag == fixedFlag.ONE_TO_FOUR_TOTAL) one_to_four_Item = tem;
    return tem;
  }
}

async function mergeProject(main, sub) {
  //合并两个项目
  let decimal = await decimal_facade.getProjectDecimal(main[0].projectID);
  let project = await projectsModel.findOne({
    ID: main[0].projectID,
  });
  let notMatchList = [];
  for (let s of sub) {
    //先找有没有相同的大项费用
    let same = findTheSameItem(main, s);
    same
      ? await mergeItem(same, s, decimal, project._doc)
      : notMatchList.push(s); //如果找到，则合并,找不到就放在未匹配表
  }
  for (let n of notMatchList) {
    main.push(n);
  }

  return decimal;
}

async function mergeItem(a, b, decimal, project) {
  let bqDecimal = await decimal_facade.getBillsQuantityDecimal(
    a.projectID,
    a.unit,
    project
  );
  a.quantity = a.quantity ? scMathUtil.roundForObj(a.quantity, bqDecimal) : 0;
  b.quantity = b.quantity ? scMathUtil.roundForObj(b.quantity, bqDecimal) : 0;
  a.quantity = scMathUtil.roundForObj(a.quantity + b.quantity, decimal.process);
  for (let name in b.prices) {
    a.prices[name] = b.prices[name];
    a.rationCommons[name] = b.rationCommons[name];
    a.quantityMap[name] = b.quantityMap[name];
    a.unitPrices[name] = b.unitPrices[name];
    a.baseProgressiveFees[name] = b.baseProgressiveFees[name];
  }
  for (let name in a.quantityMap) {
    a.quantityMap[name] = a.quantityMap[name]
      ? scMathUtil.roundForObj(a.quantityMap[name], bqDecimal)
      : 0;
  }

  await mergeChildren(a, b, decimal, project);
}

async function mergeChildren(a, b, decimal, project) {
  let notMatchList = [];
  if (a.children.length > 0 && b.children.length == 0) {
    return;
  } else if (a.children.length == 0 && b.children.length > 0) {
    a.children = b.children;
    return;
  }
  //=============剩下的是两者都有的情况
  for (let s of b.children) {
    let same = findTheSameItem(a.children, s);
    same ? await mergeItem(same, s, decimal, project) : notMatchList.push(s); //如果找到，则合并,找不到就放在未匹配表
  }
  for (let n of notMatchList) {
    let match = false; //符合插入标记
    //对于未匹配的子项，如果是固定清单：第100章至700章清单的子项，要匹配名字中的数字来做排充
    if (a.flag == fixedFlag.ONE_SEVEN_BILLS) {
      for (let i = 0; i < a.children.length; i++) {
        let m_name = a.children[i].name.replace(/[^0-9]/gi, "");
        let s_name = n.name.replace(/[^0-9]/gi, "");
        m_name = parseFloat(m_name);
        s_name = parseFloat(s_name);
        if (m_name && s_name) {
          if (m_name == s_name) {
            await mergeItem(a.children[i], n, project);
            match = true;
            break;
          }
          if (m_name > s_name) {
            //主节点名字中的数字大于被插节点，则被插节点放在主节点前面
            a.children.splice(i, 0, n);
            match = true;
            break;
          }
        }
      }
    } else {
      //其它的子项按编号进行排序
      for (let i = 0; i < a.children.length; i++) {
        let m_code = a.children[i].code;
        let s_code = n.code;
        if (m_code && s_code && m_code != "" && s_code != "") {
          if (m_code > s_code) {
            a.children.splice(i, 0, n);
            match = true;
            break;
          }
        }
      }
    }
    if (match == false) a.children.push(n); //没有插入成功，直接放到最后面
  }
}

function findTheSameItem(main, item) {
  //编号名称单位三个相同，认为是同一条清单
  return _.find(main, function (tem) {
    return (
      isEqual(tem.code, item.code) &&
      isEqual(tem.name, item.name) &&
      isEqual(tem.unit, item.unit)
    );
  });
}

function isEqual(a, b) {
  //粗略匹配，null undefind "" 认为相等
  return getValue(a) == getValue(b);

  function getValue(t) {
    if (t == null || t == undefined || t == "") return null;
    return t;
  }
}

async function getBillsByProjectID(projectID) {
  let roots = [],
    parentMap = {};
  let bills = await bill_model.model.find(
    {
      projectID: projectID,
    },
    "-_id"
  ); //取出所有清单
  let project = await projectsModel.findOne({
    ID: projectID,
  });
  if (!project) throw new Error(`找不到项目：${projectID}`);
  let projectName = project.name;
  let author = ""; //编制人
  let auditor = ""; //审核人
  let compilationScope = ""; //编制范围
  let engineering = ""; //养护类别
  let progressiveType = 0; //累进计算类型
  let progressiveInterval = null;
  if (project.property && project.property.projectFeature) {
    for (let f of project.property.projectFeature) {
      if (f.key == "author") author = f.value;
      if (f.key == "auditor") auditor = f.value;
      if (f.key == "compilationScope") compilationScope = f.value;
      if (f.key == "engineering") engineering = f.value;
    }
    if (project.property.progressiveType)
      progressiveType = project.property.progressiveType;
    progressiveInterval = project.property.progressiveInterval;
  }
  for (let b of bills) {
    let commonFee = _.find(b._doc.fees, {
      fieldName: "common",
    });
    let prices = {};
    let quantityMap = {};
    let unitPrices = {};
    let rationCommons = {};
    let baseProgressiveFees = {};
    let rationFee = _.find(b._doc.fees, {
      fieldName: "rationCommon",
    });
    if (commonFee && commonFee.tenderTotalFee)
      prices[projectName] = commonFee.tenderTotalFee;
    if (commonFee && commonFee.tenderUnitFee)
      unitPrices[projectName] = commonFee.tenderUnitFee;
    if (rationFee && rationFee.tenderTotalFee)
      rationCommons[projectName] = rationFee.tenderTotalFee;
    baseProgressiveFees[projectName] = b.baseProgressiveFee;

    quantityMap[projectName] = b.quantity;
    let flagIndex = _.find(b._doc.flags, {
      fieldName: "fixed",
    });
    let doc = {
      ID: b.ID,
      name: b.name,
      code: b.code,
      unit: b.unit,
      projectID: b.projectID,
      ParentID: b.ParentID,
      NextSiblingID: b.NextSiblingID,
      unitPrices: unitPrices,
      quantity: b.quantity,
      prices: prices,
      rationCommons: rationCommons,
      quantityMap: quantityMap,
      flag: flagIndex ? flagIndex.flag : -99,
      remark: b.remark,
      calcBase: b.calcBase,
      baseProgressiveFees: baseProgressiveFees,
    }; //选取有用字段
    if (b.ParentID == -1) roots.push(doc);
    parentMap[b.ParentID]
      ? parentMap[b.ParentID].push(doc)
      : (parentMap[b.ParentID] = [doc]);
  } //设置子节点
  for (let r of roots) {
    setChildren(r, parentMap);
  }
  roots = sortChildren(roots);
  return {
    name: projectName,
    roots: roots,
    author: author,
    auditor: auditor,
    compilationScope: compilationScope,
    ParentID: project.ParentID,
    prjTypeName: engineering,
    progressiveType: progressiveType,
    progressiveInterval: progressiveInterval,
  };
}

function setChildren(bill, parentMap) {
  let children = parentMap[bill.ID];
  if (children) {
    for (let c of children) {
      setChildren(c, parentMap);
    }
    bill.children = children;
  } else {
    bill.children = [];
  }
}

function sortChildren(lists) {
  let IDMap = {},
    nextMap = {},
    firstNode = null,
    newList = [];
  for (let l of lists) {
    if (l.children && l.children.length > 0)
      l.children = sortChildren(l.children); //递规排序
    IDMap[l.ID] = l;
    if (l.NextSiblingID != -1) nextMap[l.NextSiblingID] = l;
  }
  for (let t of lists) {
    if (!nextMap[t.ID]) {
      //如果在下一节点映射没找到，则是第一个节点
      firstNode = t;
      break;
    }
  }
  if (firstNode) {
    newList.push(firstNode);
    delete IDMap[firstNode.ID];
    setNext(firstNode, newList);
  }
  //容错处理，如果链断了的情况，直接添加到后面
  for (let key in IDMap) {
    if (IDMap[key]) newList.push(IDMap[key]);
  }
  return newList;

  function setNext(node, array) {
    if (node.NextSiblingID != -1) {
      let next = IDMap[node.NextSiblingID];
      if (next) {
        array.push(next);
        delete IDMap[next.ID];
        setNext(next, array);
      }
    }
  }
}

async function getGLJSummayDatas(projectIDs, compilationName = "") {
  let projects = [];
  let names = [];
  let prjTypeNames = [];
  let compilationScopes = [];
  try {
    for (let ID of projectIDs) {
      projects.push(await getProjectData(ID));
    }
    if (projects.length == 0) {
      return [];
    }
    let mp = projects[0];
    for (let p of projects) {
      names.push(p.name);
      prjTypeNames.push(p.prjTypeName);
      p.gljList = await getProjectGLJData(p.ID, p.unitPriceFileId, mp.property);
      compilationScopes.push(p.compilationScope);
    }

    let mList = mergeGLJ(mp, projects, names, prjTypeNames, compilationName);
    mList = gljUtil.sortProjectGLJ(mList, _);
    let summaryGLJDatas = getSummaryGLJDatas(
      mList,
      mp.property.decimal,
      names,
      prjTypeNames,
      compilationScopes
    );

    let parentProject = await projectsModel.findOne({
      ID: mp.ParentID,
    });
    let result = {
      prj: {},
      SummaryGljAudit: {
        name: parentProject ? parentProject.name : "",
        编制: mp.author,
        复核: mp.auditor,
        编制范围: mp.compilationScope,
      },
      SummaryGljAuditDetail: summaryGLJDatas,
    };
    return result;
  } catch (e) {
    console.log(e.toString());
  }
}

function getSummaryGLJDatas(
  gljList,
  decimal,
  nameList,
  prjTypeNames,
  compilationScopes
) {
  let datas = [],
    qdecimal = decimal.glj.quantity,
    upDecimal = decimal.glj.unitPrice,
    process = decimal.process;
  for (let tem of gljList) {
    let d = {
      code: tem.code,
      name: tem.name,
      type: tem.type,
      unit: tem.unit,
      specs: tem.specs,
      marketPrice: tem.marketPrice,
      marketPriceList: [],
      prjNames: nameList,
      prjTypeNames: prjTypeNames,
      quantityList: [],
      编制范围明细: compilationScopes,
    };
    let totalQuantity = 0;
    let totalPrice = 0;
    for (let n of nameList) {
      let q = tem.quantityMap[n]
        ? scMathUtil.roundForObj(tem.quantityMap[n], qdecimal)
        : 0;
      totalQuantity = scMathUtil.roundForObj(q + totalQuantity, process);
      d.quantityList.push(q);
      let up = tem.unitPriceMap[n]
        ? scMathUtil.roundForObj(tem.unitPriceMap[n], upDecimal)
        : 0;
      d.marketPriceList.push(up);
      totalPrice = scMathUtil.roundForObj(q * up + totalPrice, process);
    }
    d.totalQuantity = scMathUtil.roundForObj(totalQuantity, qdecimal);
    d.totalPrice = scMathUtil.roundForObj(totalPrice, upDecimal);
    datas.push(d);
  }
  return datas;
}

function mergeGLJ(mp, projects, names, prjTypeNames, compilationName = "") {
  let gljMap = {},
    gljList = [];
  const noPriceChkList = [
    "甘肃养护(2021)",
    "重庆养护(2018)",
    "浙江养护(2005)",
    "安徽养护(2018)",
    "山东养护(2016/2024)",
    "湖南养护(2014)",
    "广西日常养护年度预算(2020)",
  ];
  const noPriceCheck = noPriceChkList.indexOf(compilationName) >= 0;
  for (let g of mp.gljList) {
    g.quantityMap = {};
    g.quantityMap[mp.name] = g.tenderQuantity;
    g.unitPriceMap = {};
    g.unitPriceMap[mp.name] = g.marketPrice;
    gljMap[gljUtil.getIndex(g)] = g;
    gljList.push(g);
  }
  for (let i = 1; i < projects.length; i++) {
    let temList = projects[i].gljList;
    for (let t of temList) {
      t.quantityMap = {};
      t.quantityMap[projects[i].name] = t.tenderQuantity;
      t.unitPriceMap = {};
      t.unitPriceMap[projects[i].name] = t.marketPrice;
      //这里除了5个属性相同判断为同一个之外，还要判断市场价相同，才认为是同一个工料机
      //但有些省份不需要检测，体现在noPriceCheck标记
      let connect_key = gljUtil.getIndex(t);
      let g = gljMap[connect_key];
      if (g && (noPriceCheck || g.marketPrice == t.marketPrice)) {
        g.quantityMap[projects[i].name] = t.tenderQuantity;
        g.unitPriceMap[projects[i].name] = t.marketPrice;
      } else {
        gljMap[connect_key] = t;
        gljList.push(t);
      }
    }
  }
  return gljList;
}

async function getProjectGLJData(projectID, unitPriceFileId, property) {
  //取项目工料机数据
  let projectGLJDatas = await getProjectGLJPrice(
    projectID,
    unitPriceFileId,
    property
  );
  await calcProjectGLJQuantity(projectID, projectGLJDatas, property);
  _.remove(projectGLJDatas.gljList, {
    quantity: 0,
  });
  return projectGLJDatas.gljList;
}

async function getProjectData(projectID) {
  let project = await projectsModel.findOne({
    ID: projectID,
  });
  if (!project) throw new Error(`找不到项目：${projectID}`);
  let projectName = project.name;
  let author = ""; //编制人
  let auditor = ""; //审核人
  let compilationScope = ""; //编制范围
  let engineering = ""; //养护类别
  if (project.property && project.property.projectFeature) {
    for (let f of project.property.projectFeature) {
      if (f.key == "author") author = f.value;
      if (f.key == "auditor") auditor = f.value;
      if (f.key == "compilationScope") compilationScope = f.value;
      if (f.key == "engineering") engineering = f.value;
    }
  }
  if (!(project.property && project.property.unitPriceFile))
    throw new Error(`找不到单价文件：${projectID}`);
  let unitPriceFileId = project.property.unitPriceFile.id;
  return {
    ID: projectID,
    name: projectName,
    author: author,
    auditor: auditor,
    compilationScope: compilationScope,
    ParentID: project.ParentID,
    prjTypeName: engineering,
    property: project.property,
    unitPriceFileId: unitPriceFileId,
  };
}

async function getProjectGLJPrice(projectID, unitPriceFileId, property) {
  //取项目工料机数据
  let calcOptions = property.calcOptions;
  let decimalObj = property.decimal;
  let labourCoeDatas = []; //取调整价才需要用到
  let gljListModel = new GLJListModel();
  let [gljList, mixRatioConnectData, mixRatioMap, unitPriceMap] =
    await gljListModel.getListByProjectId(projectID, unitPriceFileId);

  let unitPriceFileModel = new UnitPriceFileModel();
  let unitFileInfo = await unitPriceFileModel.findDataByCondition({
    id: unitPriceFileId,
  });
  let machineConstCoe = unitFileInfo.machineConstCoe
    ? unitFileInfo.machineConstCoe
    : 1;

  gljList = JSON.parse(JSON.stringify(gljList));
  for (let glj of gljList) {
    let tenderCoe = gljUtil.getTenderPriceCoe(glj, property);
    let result = gljUtil.getGLJPrice(
      glj,
      {
        gljList: gljList,
        constData: { machineConstCoe: machineConstCoe },
      },
      calcOptions,
      labourCoeDatas,
      decimalObj,
      false,
      tenderCoe,
      true
    );
    glj.marketPrice = result.marketPrice;
    glj.basePrice = result.basePrice;
  }
  return {
    gljList: gljList,
    mixRatioMap: mixRatioMap,
  };
}

async function calcProjectGLJQuantity(projectID, projectGLJDatas, property) {
  let q_decimal = property.decimal.glj.quantity;
  let rationGLJDatas = await ration_glj_model.find({
    projectID: projectID,
  });
  let rationDatas = await ration_model.model.find({
    projectID: projectID,
  });
  let billDatas = await bill_model.model.find({
    projectID: projectID,
  });
  gljUtil.calcProjectGLJQuantity(
    projectGLJDatas,
    rationGLJDatas,
    rationDatas,
    billDatas,
    q_decimal
  );
}