ConstructionOperation/modules/users/models/engineering_lib_model.js

/**
 * 计价规则标准库业务逻辑
 *
 * @author CaiAoLin
 * @date 2017/8/31
 * @version
 */
import mongoose from "mongoose";
import BaseModel from "../../common/base/base_model";
import CompilationModel from "./compilation_model";
let stdRationLibModel = mongoose.model("std_ration_lib_map");
import {
  default as EngineeringConst,
  List as EngineeringList,
} from "../../common/const/engineering";
const billsGuidanceLibModel = mongoose.model("std_billsGuidance_lib");
const billsLibListsModel = mongoose.model("std_bills_lib_lists");

class EngineeringLibModel extends BaseModel {
  /**
   * 构造函数
   *
   * @return {void}
   */
  constructor() {
    let parent = super();
    parent.model = mongoose.model("engineering_lib");
    parent.init();
  }

  /**
   * 获取标准库数据
   *
   * @param {Object} data
   * @param {Number} engineering
   * @return {Promise}
   */
  async getLib(data, engineering) {
    let result = {};
    if (data.length <= 0) {
      return result;
    }
    let id = "";
    for (let tmp of data) {
      if (tmp.engineering === engineering) {
        id = tmp.engineering_id;
        break;
      }
    }
    if (id === "") {
      return result;
    }
    let condition = { _id: id };
    return this.findDataByCondition(condition);
  }

  async getLibsByValuationID(valuationID) {
    return this.findDataByCondition({ valuationID: valuationID }, null, false);
  }

  async deleteByValuationID(valuationID) {
    return await this.db.delete({ valuationID: valuationID });
  }

  //添加空的默认的所有标准库
  /**
   * @param valuationID
   * @returns {Promise.<*>}
   */
  async addStdLib(valuationID) {
    let stdLibs = [];
    for (let eng of EngineeringList) {
      let tem = {
        glj_col: { showAdjustPrice: false },
        valuationID: valuationID,
        name: eng.name,
        engineering: eng.value,
      };
      stdLibs.push(tem);
    }
    let result = await this.db.create(stdLibs);
    return result;
  }

  async addEngineer(data) {
    data.glj_col = { showAdjustPrice: false };
    if (data.compilationId && data.compilationId != "") {
      data.ration_lib = [];
      let rationList = await stdRationLibModel.find(
        { compilationId: data.compilationId },
        ["ID", "dispName"]
      );
      for (let i = 0; i < rationList.length; i++) {
        let tem = {
          id: rationList[i].ID,
          name: rationList[i].dispName,
          isDefault: false,
        };
        if (i == 0) tem.isDefault = true;
        data.ration_lib.push(tem);
      }
    }
    let result = await this.db.create(data);
    return result;
  }

  // 拷贝工程专业
  async copyEngineer(sourceID) {
    const engineering = await this.db.findOne({ _id: sourceID });
    const newEngineering = engineering._doc;
    delete newEngineering._id;
    newEngineering.visible = false;
    await this.db.create(newEngineering);
  }

  /**
   * 新增标准库
   *
   * @param {String} valuationId
   * @param {Object} data
   * @return {Promise}
   */
  async addLib(engineerId, data) {
    if (data.glj_col) {
      data.glj_col = JSON.parse(data.glj_col);
    }
    data.isInstall == "true"
      ? (data.isInstall = true)
      : (data.isInstall = false);
    data.isItemIncrease == "true"
      ? (data.isItemIncrease = true)
      : (data.isItemIncrease = false);
    data.isAreaIncrease == "true"
      ? (data.isAreaIncrease = true)
      : (data.isAreaIncrease = false);
    let result = false;
    data = this.filterLibData(data);
    try {
      // 处理清单指引
      if (data.billsGuidance_lib && data.billsGuidance_lib.length) {
        const billsGuidanceLibIDs = data.billsGuidance_lib.map(
          (item) => item.id
        );
        const billsGuidanceLibs = await billsGuidanceLibModel
          .find({ ID: { $in: billsGuidanceLibIDs } }, "-_id ID type")
          .lean();
        const libTypeMap = {};
        billsGuidanceLibs.forEach((lib) => (libTypeMap[lib.ID] = lib.type));
        data.billsGuidance_lib.forEach((lib) => {
          lib.type = libTypeMap[lib.id] || 1;
        });
      }
      // 标准清单新增清单类型
      if (data.bill_lib && data.bill_lib.length) {
        const billLibIDs = data.bill_lib.map((item) => +item.id);
        const billLibs = await billsLibListsModel
          .find({ billsLibId: { $in: billLibIDs } }, "-_id billsLibId libType")
          .lean();
        const libTypeMap = {};
        billLibs.forEach((lib) => (libTypeMap[lib.billsLibId] = lib.libType));
        data.bill_lib.forEach((lib) => {
          lib.libType = libTypeMap[lib.id] || "1";
        });
      }
      let engineeringLib = await this.findDataByCondition({ _id: engineerId });
      if (engineeringLib) {
        // 存在则直接更新
        delete data.id;
        delete data.section;
        let condition = { _id: engineerId };
        result = await this.db.update(condition, data);
        result = result.ok === 1;
      } else {
        throw new Error("找不到对应的工程专业");
      }
    } catch (error) {
      console.log(error);
      result = false;
    }

    return result;
  }

  /**
   * 过滤计价数据
   *
   * @param {Object} data
   * @return {Object}
   */
  filterLibData(data) {
    if (Object.keys(data).length <= 0 || data.section === undefined) {
      console.log("1");
      throw "数据有误";
    }
    data.engineering = parseInt(data.engineering);
    //需求修改，工程专业可以随便输入了
    //检测专业工程是否合法
    /*     let match = false;
             for(let index in EngineeringConst) {
                 if (EngineeringConst[index] === data.engineering) {
                     match = true;
                     break;
                 }
             }
             if (!match) {
                 throw '工程专业错误';
             }*/

    // 判断标准清单
    data.bill_lib = this._validLib(data.bill_lib);

    // 判断定额库
    data.ration_lib = this._validLib(data.ration_lib);

    //设置默认定额库
    this.setDefaultRation(data);

    // 判断工料机库
    data.glj_lib = this._validLib(data.glj_lib);

    // 判断清单指引库
    data.billsGuidance_lib = this._validLib(data.billsGuidance_lib);

    /*// 判断费率标准
        data.fee_lib = this._validLib(data.fee_lib);*/

    // 判断人工系数
    data.artificial_lib = this._validLib(data.artificial_lib);

    //判断工程特征库
    data.feature_lib = this._validLib(data.feature_lib);

    //判断基本信息
    data.info_lib = this._validLib(data.info_lib);

    //判断工程信息
    data.engineer_info_lib = this._validLib(data.engineer_info_lib);

    //判断累进区间库
    data.progressive_lib = this._validLib(data.progressive_lib);

    //判断工程特征指标信息
    data.engineer_feature_lib = this._validLib(data.engineer_feature_lib);

    //判断主要工料指标信息
    data.material_lib = this._validLib(data.material_lib);

    //判断主要工料指标信息
    data.main_quantity_lib = this._validLib(data.main_quantity_lib);

    //判断主要经济指标信息
    data.economic_lib = this._validLib(data.economic_lib);

    data.over_height_lib = this._validLib(data.over_height_lib);

    //计税方式组合
    data.tax_group = this._validLib(data.tax_group);

    return data;
  }

  /**
   * 校验库数据
   *
   * @param {Object} libData
   * @return {Object}
   */
  _validLib(libData) {
    let result = [];
    // 判断标准库
    if (libData === undefined || libData === null || libData === "") {
      return result; //throw '标准库不能为空'; 按新需求，标准库等不做非空判断
    }
    libData = libData instanceof Array ? libData : [libData];
    for (let tmp in libData) {
      result[tmp] = JSON.parse(libData[tmp]);
    }
    return result;
  }

  //设置默认定额库
  setDefaultRation(data) {
    if (data.ration_lib && data.ration_lib.length > 0) {
      if (data.ration_isDefault && data.ration_isDefault != "") {
        for (let r of data.ration_lib) {
          r.id.toString() == data.ration_isDefault
            ? (r.isDefault = true)
            : (r.isDefault = false);
          // 通过表单来识别那些定额库是专业版可用
          data["ration_onlyProfession_" + r.id.toString()]
            ? (r.onlyProfession = true)
            : (r.onlyProfession = false);
        }
      } else {
        data.ration_lib[0].isDefault = true;
      }
    }
  }

  /**
   * 获取对应标准库数量
   *
   * @param {Object} valuationData
   * @return {Object}
   */
  async getLibCount(valuationData) {
    let result = {};
    if (
      valuationData.engineering_list === undefined ||
      valuationData.engineering_list.length <= 0
    ) {
      return result;
    }

    // 整理需要查找的数据
    let findIdList = [];
    for (let engineering of valuationData.engineering_list) {
      findIdList.push(engineering.engineering_id);
    }

    let condition = { _id: { $in: findIdList } };
    let libData = await this.findDataByCondition(condition, null, false);
    if (libData === null) {
      return result;
    }

    // 整理数据
    let countData = {};
    for (let tmp of libData) {
      countData[tmp._id] = {
        bill_count: tmp.bill_lib.length,
        ration_count: tmp.ration_lib.length,
        glj_count: tmp.glj_lib.length,
        fee_count: tmp.fee_lib.length,
        artificial_count: tmp.artificial_lib.length,
        program_count: tmp.program_lib.length,
      };
    }

    for (let engineering of valuationData.engineering_list) {
      if (countData[engineering.engineering_id] !== undefined) {
        result[engineering.engineering] = countData[engineering.engineering_id];
      }
    }

    return result;
  }

  async copyRationLibsToOthers(valuationID, engineeringID) {
    const compilationModel = new CompilationModel();
    const compilation = await compilationModel.model.findOne({
      $or: [
        { "bill_valuation.id": valuationID },
        { "ration_valuation.id": valuationID },
      ],
    });
    if (!compilation) {
      return;
    }
    const valuationIDList = [];
    const allValuation = compilation.ration_valuation.concat(
      compilation.bill_valuation
    );
    for (const valuation of allValuation) {
      valuationIDList.push(valuation.id);
    }
    const engineering = await this.findDataByCondition({ _id: engineeringID });
    if (!engineering) {
      return;
    }
    await this.model.updateMany(
      { valuationID: { $in: valuationIDList } },
      { $set: { ration_lib: engineering.ration_lib } }
    );
  }
}

export default EngineeringLibModel;