YangHuOperation/modules/ration_repository/models/ration_item.js

/**
 * Created by Tony on 2017/4/28.
 */
const mongoose = require('mongoose');
let async = require("async");
let moment = require('moment');
let counter = require('../../../public/counter/counter');
let gljDao = require('./glj_repository');
let rationRepositoryDao = require('./repository_map');
const scMathUtil = require('../../../public/scMathUtil').getUtil();
const rationItemModel = mongoose.model('std_ration_lib_ration_items');
const rationItemBackupModel = mongoose.model('std_ration_lib_ration_items_backup');
const stdRationLibModel = mongoose.model('std_ration_lib_map');
const stdRationSectionModel = mongoose.model('std_ration_lib_ration_chapter_trees');
const stdRationSectionBackupModel = mongoose.model('std_ration_lib_ration_chapter_trees_backup');
const stdCoeModel = mongoose.model('std_ration_lib_coe_list');
const stdCoeBackupModel = mongoose.model('std_ration_lib_coe_list_backup');
const compleRationModel = mongoose.model('complementary_ration_items');
import STDGLJListModel from '../../std_glj_lib/models/gljModel';
import InstallationDao from '../models/installation';
const installationDao = new InstallationDao();
import GljDao from "../../std_glj_lib/models/gljModel";
const stdGljDao = new GljDao();
import stdgljutil from "../../../public/cache/std_glj_type_util";
const lossRateModel = mongoose.model('std_ration_lib_loss_rate_list');
const uuidV1 = require('uuid/v1');
//add
const stdGLJItemModel = mongoose.model('std_glj_lib_gljList');
const stdGLJItemModelBackup = mongoose.model('std_glj_lib_gljList_backup');
// const _rationItemModelBackup = mongoose.model('std_ration_lib_ration_items_backup');

var rationItemDAO = function () { };


async function getIDMapping(counterName, data) {
    const counterInfo = await counter.counterDAO.getIDAfterCount(counterName, data.length);
    const maxID = +counterInfo.sequence_value;
    const IDMapping = {};
    data.forEach((item, index) => {
        IDMapping[item.ID] = maxID - (data.length - 1) + index;
    });
    return IDMapping;
}

// 拷贝分类树
async function copyClassData(sourceLibID, targetLibID) {
    const sourceClassData = await stdRationSectionModel.find({ rationRepId: sourceLibID }, '-_id').lean();
    const IDMapping = await getIDMapping(counter.moduleName.rationTree, sourceClassData);
    const insertData = sourceClassData.map(item => ({
        ...item,
        rationRepId: targetLibID,
        ID: IDMapping[item.ID],
        ParentID: IDMapping[item.ParentID] || -1,
        NextSiblingID: IDMapping[item.NextSiblingID] || -1,
    }));
    if (insertData.length) {
        await stdRationSectionModel.insertMany(insertData);
    }
    return IDMapping;
}

// 拷贝子目换算
async function copyCoeData(sourceLibID, targetLibID) {
    const sourceCoeData = await stdCoeModel.find({ libID: sourceLibID }, '-_id').lean();
    const IDMapping = await getIDMapping(counter.moduleName.coeList, sourceCoeData);
    const insertData = sourceCoeData.map(item => ({
        ...item,
        libID: targetLibID,
        ID: IDMapping[item.ID],
    }));
    if (insertData.length) {
        await stdCoeModel.insertMany(insertData);
    }
    return IDMapping;
}

// 拷贝损耗率
async function copyLossRateData(sourceLibID, targetLibID) {
    const sourceLossData = await lossRateModel.find({ libID: sourceLibID }, '-_id').lean();
    const IDMapping = {};
    sourceLossData.forEach(item => {
        IDMapping[item.ID] = uuidV1();
    });

    const insertData = sourceLossData.map(item => ({
        ...item,
        libID: targetLibID,
        ID: IDMapping[item.ID],
    }));
    if (insertData.length) {
        await lossRateModel.insertMany(insertData);
    }
    return IDMapping;
}


// 拷贝定额库
rationItemDAO.prototype.copyLib = async function (sourceLibID, targetLibID, sourceGLJLibID, targetGLJLibID) {
    const sourceRationData = await rationItemModel.find({ rationRepId: sourceLibID }, '-_id').lean();
    const rationIDMapping = await getIDMapping(counter.moduleName.rations, sourceRationData);
    const classIDMapping = await copyClassData(sourceLibID, targetLibID);
    const coeIDMapping = await copyCoeData(sourceLibID, targetLibID);
    const lossRateIDMapping = await copyLossRateData(sourceLibID, targetLibID);
    const sourceGLJData = await stdGLJItemModel.find({ repositoryId: sourceGLJLibID }, '-_id code ID').lean();
    const sourceGLJCodeMapping = {};
    sourceGLJData.forEach(glj => sourceGLJCodeMapping[glj.code] = glj.ID);
    const targetGLJData = await stdGLJItemModel.find({ repositoryId: targetGLJLibID }, '-_id code ID').lean();
    // 旧ID-新ID映射
    const gljIDMapping = {};
    targetGLJData.forEach(glj => {
        const orgID = sourceGLJCodeMapping[glj.code];
        if (orgID) {
            gljIDMapping[orgID] = glj.ID;
        }
    });
    sourceRationData.forEach(ration => {
        ration.rationRepId = targetLibID;
        ration.ID = rationIDMapping[ration.ID];
        ration.sectionId = classIDMapping[ration.sectionId];
        ration.rationCoeList.forEach(coe => {
            coe.ID = coeIDMapping[coe.ID];
        });
        const rationGLJList = [];
        ration.rationGljList.forEach(rGLJ => {
            if (rGLJ.lossRateID) {
                rGLJ.lossRateID = lossRateIDMapping[rGLJ.lossRateID];
            }
            const newGLJID = gljIDMapping[rGLJ.gljId];
            if (newGLJID) {
                rGLJ.gljId = newGLJID;
                rationGLJList.push(rGLJ);
            }
        });
        ration.rationGljList = rationGLJList;
    });
    if (sourceRationData.length) {
        await rationItemModel.insertMany(sourceRationData);
    }

}

rationItemDAO.prototype.handleGLJCode = async function (rationLibID, gljLibID) {
    const rations = await rationItemModel.find({ rationRepId: rationLibID }, 'ID rationGljList').lean();
    const gljs = await stdGLJItemModel.find({ repositoryId: gljLibID }, 'ID code').lean();
    const gljMap = {};
    gljs.forEach(glj => gljMap[glj.ID] = glj.code);
    const bulks = [];
    rations.forEach(ration => {
        if (ration.rationGljList && ration.rationGljList.length) {
            ration.rationGljList.forEach(rGLJ => {
                rGLJ.gljCode = gljMap[rGLJ.gljId];
            });
            bulks.push({
                updateOne: {
                    filter: { ID: ration.ID },
                    update: { $set: { rationGljList: ration.rationGljList } }
                }
            })
        }
    });
    if (bulks.length) {
        await rationItemModel.bulkWrite(bulks);
    }
}

rationItemDAO.prototype.updateRationGLJByOrgID = async function (rationLibID, gljLibID) {
    const gljList = await stdGLJItemModel.find({ repositoryId: gljLibID }, 'ID orgID').lean();
    const IDMap = {};
    gljList.forEach(({ orgID, ID }) => IDMap[orgID] = ID);
    const rations = await rationItemModel.find({ rationRepId: rationLibID }, 'ID rationGljList').lean();
    const bulks = [];
    rations
        .filter(ration => ration.rationGljList.length)
        .forEach(ration => {
            const newRationGLJList = [];
            ration.rationGljList.forEach(rGLJ => {
                const newGLJID = IDMap[rGLJ.gljId];
                if (newGLJID) {
                    newRationGLJList.push({
                        ...rGLJ,
                        gljId: newGLJID
                    });
                }
            });
            bulks.push({
                updateOne: {
                    filter: { ID: ration.ID },
                    update: { rationGljList: newRationGLJList }
                }
            })
        });
    if (bulks.length) {
        await rationItemModel.bulkWrite(bulks);
    }
}

// 处理部颁数据
rationItemDAO.prototype.handleBBData = async function (rationLibID, gljLibID) {
    const rations = await rationItemModel.find({ rationRepId: rationLibID }, '-_id ID rationGljList').lean();
    const gljs = await stdGLJItemModel.find({ repositoryId: gljLibID, 'component.0': { $exists: true } }, '-_id ID component').lean();
    const gljIDMap = {};
    gljs.forEach(glj => gljIDMap[glj.ID] = gljs);
    const updateData = [];
    const errorRange = 0.004;
    for (const ration of rations) {
        if (!ration.rationGljList) {
            continue;
        }
        const componentAmtMap = {};
        for (const rGLJ of ration.rationGljList) {
            const stdGLJ = gljIDMap[rGLJ.gljId];
            if (!stdGLJ) {
                continue;
            }
            for (const c of stdGLJ.component) {
                const amt = c.consumeAmt * rGLJ.consumeAmt;
                if (componentAmtMap[c.ID]) {
                    componentAmtMap[c.ID] += amt;
                } else {
                    componentAmtMap[c.ID] = amt;
                }
            }
        }
        const newRationGljList = [];
        let isChanged = false;
        for (const rGLJ of ration.rationGljList) {
            if (componentAmtMap[rGLJ.gljId]) {
                const diff = Math.abs(componentAmtMap[rGLJ.gljId] - rGLJ.consumeAmt);
                if (diff <= errorRange) {
                    isChanged = true;
                } else {
                    newRationGljList.push(rGLJ);
                }
            } else {
                newRationGljList.push(rGLJ);
            }
        }
        if (isChanged) {
            updateData.push({
                updateOne: {
                    filter: { ID: ration.ID },
                    update: { rationGljList: newRationGljList }
                }
            });
        }
    }
    if (updateData.length) {
        await rationItemModel.bulkWrite(updateData);
    }
};

// 由于导入excel时，excel数据存在负的工程量，所以导入后一些定额人材机的消耗量可能为负，需要处理
rationItemDAO.prototype.handleMinusQuantity = async function () {
    const updateTask = [];
    const repIDs = new Set();
    const rations = await rationItemModel.find({ 'rationGljList.consumeAmt': { $lt: 0 } }).lean();
    for (const ration of rations) {
        repIDs.add(ration.rationRepId);
        const rationGLJList = [];
        for (const rGLJ of ration.rationGljList) {
            rationGLJList.push({
                gljId: rGLJ.gljId,
                consumeAmt: Math.abs(rGLJ.consumeAmt),
                proportion: rGLJ.proportion
            });
        }
        updateTask.push({
            updateOne: {
                filter: { ID: ration.ID },
                update: { $set: { rationGljList: rationGLJList } }
            }
        });
    }
    if (updateTask.length) {
        await rationItemModel.bulkWrite(updateTask);
    }
    console.log(`repIDs`);
    console.log(repIDs);
};

rationItemDAO.prototype.prepareInitData = async function (rationRepId) {
    // 定额库
    const libTask = stdRationLibModel.findOne({ ID: rationRepId }, '-_id ID dispName gljLib');
    // 定额编码
    const codesTask = rationItemModel.find({ rationRepId }, '-_id code', { lean: true });
    // 定额章节树
    const sectionTreeTask = stdRationSectionModel.find({ rationRepId }, '-_id', { lean: true });
    // 安装增加费
    const installationTask = installationDao.getInstallation(rationRepId);
    const [libInfo, codesArr, sectionTree, installationList] = await Promise.all([libTask, codesTask, sectionTreeTask, installationTask]);
    const rationsCodes = codesArr.reduce((acc, cur) => {
        acc.push(cur.code);
        return acc;
    }, []);
    // 人材机分类树
    const gljLibId = libInfo.gljLib;
    const gljTreeTask = stdGljDao.getGljTreeSync(gljLibId);
    const gljTask = stdGljDao.getGljItemsSync(gljLibId);
    const [gljTree, gljList] = await Promise.all([gljTreeTask, gljTask]);
    const gljDistTypeList = stdgljutil.getStdGljTypeCacheObj().toArray();
    return {
        libInfo,
        rationsCodes,
        sectionTree,
        installationList,
        gljTree,
        gljList,
        gljDistTypeList
    };
};

//将消耗量为负的人材机改为正的
rationItemDAO.prototype.toPositive = async function (rationRepId) {
    let rations = await rationItemModel.find({ rationRepId: rationRepId, 'rationGljList.consumeAmt': { $lt: 0 } });
    let task = [];
    for (let ration of rations) {
        let update = false;
        for (let rGlj of ration.rationGljList) {
            if (rGlj.consumeAmt < 0) {
                update = true;
                rGlj.consumeAmt = Math.abs(rGlj.consumeAmt);
            }
        }
        if (update) {
            task.push({ updateOne: { filter: { ID: ration.ID }, update: { rationGljList: ration.rationGljList } } });
        }
    }
    if (task.length > 0) {
        await rationItemModel.bulkWrite(task);
    }
};

rationItemDAO.prototype.getRationItemsByLib = async function (rationRepId, showHint = null, returnFields = '') {
    let rationLib = await stdRationLibModel.findOne({ ID: rationRepId, deleted: false });
    if (!rationLib) {
        return [];
    }
    let startDate = new Date();
    let rations = await rationItemModel.find({ rationRepId: rationRepId }, returnFields);
    console.log(`Date: ${new Date() - startDate}====================================`);
    if (!showHint) {
        return rations;
    }
    else {
        const stdBillsLibListsModel = new STDGLJListModel();
        const stdGLJData = await stdBillsLibListsModel.getGljItemsByRepId(rationLib.gljLib, '-_id ID code name unit gljType');
        let gljMapping = {};
        for (let glj of stdGLJData) {
            gljMapping[glj.ID] = glj;
        }
        //设置悬浮
        for (let ration of rations) {
            let hintsArr = [];
            //对人材机进行排序
            ration.rationGljList.sort(function (a, b) {
                let gljA = gljMapping[a.gljId],
                    gljB = gljMapping[b.gljId];
                if (gljA && gljB) {
                    let aV = gljA.gljType + gljA.code,
                        bV = gljB.gljType + gljB.code;
                    if (aV > bV) {
                        return 1;
                    } else if (aV < bV) {
                        return -1;
                    }
                }
                return 0;
            });
            for (let rationGlj of ration.rationGljList) {
                let subGlj = gljMapping[rationGlj.gljId];
                if (subGlj) {
                    hintsArr.push(` ${subGlj.code} ${subGlj.name}${subGlj.specs ? '&nbsp;&nbsp;&nbsp;' + subGlj.specs : ''}&nbsp;&nbsp&nbsp;${subGlj.unit}&nbsp;&nbsp;&nbsp;${rationGlj.consumeAmt}`);
                }
            }
            hintsArr.push(`基价 元 ${ration.basePrice}`);
            if (ration.jobContent && ration.jobContent.toString().trim() !== '') {
                hintsArr.push(`工作内容:`);
                hintsArr = hintsArr.concat(ration.jobContent.split('\n'));
            }
            if (ration.annotation && ration.annotation.toString().trim() !== '') {
                hintsArr.push(`附注:`);
                hintsArr = hintsArr.concat(ration.annotation.split('\n'));
            }
            ration._doc.hint = hintsArr.join('<br>');
        }
        return rations;
    }
};

rationItemDAO.prototype.sortToNumber = function (datas) {
    for (let i = 0, len = datas.length; i < len; i++) {
        let data = datas[i]._doc;
        if (_exist(data, 'labourPrice')) {
            data['labourPrice'] = parseFloat(data['labourPrice']);
        }
        if (_exist(data, 'materialPrice')) {
            data['materialPrice'] = parseFloat(data['materialPrice']);
        }
        if (_exist(data, 'machinePrice')) {
            data['machinePrice'] = parseFloat(data['machinePrice']);
        }
        if (_exist(data, 'basePrice')) {
            data['basePrice'] = parseFloat(data['basePrice']);
        }
        if (_exist(data, 'rationGljList')) {
            for (let j = 0, jLen = data['rationGljList'].length; j < jLen; j++) {
                let raGljObj = data['rationGljList'][j]._doc;
                if (_exist(raGljObj, 'consumeAmt')) {
                    raGljObj['consumeAmt'] = parseFloat(raGljObj['consumeAmt']);
                }
            }
        }
    }
    function _exist(data, attr) {
        return data && data[attr] !== undefined && data[attr];
    }
};

rationItemDAO.prototype.getRationItemsBySection = async function (rationRepId, sectionId, callback) {
    let me = this;
    try {
        let rations = await rationItemModel.find({ rationRepId: rationRepId, sectionId: sectionId });
        me.sortToNumber(rations);
        let matchRationIDs = [],
            matchRations = [];
        for (let ration of rations) {
            if (ration.rationTemplateList) {
                for (let rt of ration.rationTemplateList) {
                    if (rt.rationID) {
                        matchRationIDs.push(rt.rationID);
                    }
                }
            }
        }
        if (matchRationIDs.length > 0) {
            matchRations = await rationItemModel.find({ ID: { $in: matchRationIDs } }, '-_id ID code name');
        }
        for (let mr of matchRations) {
            for (let ration of rations) {
                if (ration.rationTemplateList) {
                    for (let rt of ration.rationTemplateList) {
                        if (rt.rationID && rt.rationID === mr.ID) {
                            rt.code = mr.code ? mr.code : '';
                            rt.name = mr.name ? mr.name : '';
                        }
                    }
                }
            }
        }
        callback(false, "Get items successfully", rations);
    } catch (err) {
        console.log(err);
        callback(true, "Fail to get items", "");
    }
    /*  rationItemModel.find({"rationRepId": rationRepId, "sectionId": sectionId, "$or": [{"isDeleted": null}, {"isDeleted": false} ]},function(err,data){
          if(err) callback(true, "Fail to get items", "");
          else {
              me.sortToNumber(data);
              callback(false,"Get items successfully", data);
          }
      })*/
};
rationItemDAO.prototype.mixUpdateRationItems = function (rationLibId, lastOpr, sectionId, updateItems, addItems, rIds, callback) {
    var me = this;
    if (updateItems.length == 0 && rIds.length == 0) {
        me.addRationItems(rationLibId, lastOpr, sectionId, addItems, callback);
    } else {
        me.removeRationItems(rationLibId, lastOpr, rIds, function (err, message, docs) {
            if (err) {
                callback(true, "Fail to remove", false);
            } else {
                me.updateRationItems(rationLibId, lastOpr, sectionId, updateItems, function (err, results) {
                    if (err) {
                        callback(true, "Fail to save", false);
                    } else {
                        if (addItems && addItems.length > 0) {
                            me.addRationItems(rationLibId, lastOpr, sectionId, addItems, callback);
                        } else {
                            callback(false, "Save successfully", results);
                        }
                    }
                });
            }
        })
    }
};

rationItemDAO.prototype.removeRationItems = function (rationLibId, lastOpr, rIds, callback) {
    if (rIds.length > 0) {
        rationItemModel.collection.remove({ ID: { $in: rIds } }, null, function (err, docs) {
            if (err) {
                callback(true, "Fail to remove", false);
            } else {
                rationRepositoryDao.updateOprArr({ ID: rationLibId }, lastOpr, moment(Date.now()).format('YYYY-MM-DD HH:mm:ss'), function (err) {
                    if (!err) {
                        rationItemModel.update({ rationRepId: rationLibId }, { $pull: { rationTemplateList: { rationID: { $in: rIds } } } }, function (theErr) {
                            if (!theErr) {
                                callback(false, "Remove successfully", docs);
                            } else {
                                callback(true, "Fail to remove", false);
                            }

                        });
                    } else {
                        callback(true, "Fail to remove", false);
                    }
                })
            }
        })
    } else {
        callback(false, "No records were deleted!", null);
    }
};

rationItemDAO.prototype.getRationItemsByCode = function (repId, code, callback) {
    rationItemModel.find({ "rationRepId": repId, "code": { '$regex': code, $options: '$i' }, "$or": [{ "isDeleted": null }, { "isDeleted": false }] }, function (err, data) {
        if (err) callback(true, "Fail to get items", "")
        else callback(false, "Get items successfully", data);
    })
};

rationItemDAO.prototype.findRation = function (repId, keyword, callback) {
    var filter = {
        'rationRepId': repId,
        '$and': [{
            '$or': [{ 'code': { '$regex': keyword, $options: '$i' } }, { 'name': { '$regex': keyword, $options: '$i' } }]
        }, {
            '$or': [{ 'isDeleted': { "$exists": false } }, { 'isDeleted': null }, { 'isDeleted': false }]
        }]
    };
    rationItemModel.find(filter, function (err, data) {
        if (err) {
            callback(true, 'Fail to find ration', null);
        } else {
            callback(false, '', data);
        }
    })
}

rationItemDAO.prototype.getRationItem = async function (repId, code) {
    let ration = await rationItemModel.findOne({ rationRepId: repId, code: code });
    return ration;
};

rationItemDAO.prototype.addRationItems = function (rationLibId, lastOpr, sectionId, items, callback) {
    if (items && items.length > 0) {
        counter.counterDAO.getIDAfterCount(counter.moduleName.rations, items.length, function (err, result) {
            var maxId = result.sequence_value;
            var arr = [];
            for (var i = 0; i < items.length; i++) {
                var obj = new rationItemModel(items[i]);
                obj.ID = (maxId - (items.length - 1) + i);
                obj.sectionId = sectionId;
                obj.rationRepId = rationLibId;
                arr.push(obj);
            }
            rationItemModel.collection.insert(arr, null, function (err, docs) {
                if (err) {
                    callback(true, "Fail to save", false);
                } else {
                    rationRepositoryDao.updateOprArr({ ID: rationLibId }, lastOpr, moment(Date.now()).format('YYYY-MM-DD HH:mm:ss'), function (err) {
                        if (err) {
                            callback(true, "Fail to sava operator", false);
                        }
                        else {
                            callback(false, "Save successfully", docs);
                        }
                    })
                }
            })
        });
    } else {
        callback(true, "Source error!", false);
    }
};

rationItemDAO.prototype.updateRationItems = function (rationLibId, lastOpr, sectionId, items, callback) {
    console.log('enter============');
    var functions = [];
    for (var i = 0; i < items.length; i++) {
        functions.push((function (doc) {
            return function (cb) {
                var filter = {};
                if (doc.ID) {
                    filter.ID = doc.ID;
                } else {
                    filter.sectionId = sectionId;
                    if (rationLibId) filter.rationRepId = rationLibId;
                    filter.code = doc.code;
                }
                rationItemModel.update(filter, doc, cb);
            };
        })(items[i]));
    }
    functions.push((function () {
        return function (cb) {
            rationRepositoryDao.updateOprArr({ ID: rationLibId }, lastOpr, moment(Date.now()).format('YYYY-MM-DD HH:mm:ss'), function (err) {
                if (err) {
                    cb(err);
                }
                else {
                    cb(null);
                }
            });
        }
    })());
    async.parallel(functions, function (err, results) {
        callback(err, results);
    });
};
//ration round func
function round(v, e) {
    var t = 1;
    for (; e > 0; t *= 10, e--);
    for (; e < 0; t /= 10, e++);
    return Math.round(v * t) / t;
}


rationItemDAO.prototype.updateRationBasePrc = function (basePrcArr, callback) {
    async.each(basePrcArr, function (basePrcObj, finalCb) {
        let adjGljId = basePrcObj.gljId, adjBasePrice = basePrcObj.basePrice, adjGljType = basePrcObj.gljType;
        async.waterfall([
            function (cb) {
                if (typeof basePrcObj.delete !== 'undefined' && basePrcObj.delete === 1) {
                    rationItemModel.find({ 'rationGljList.gljId': adjGljId }, { ID: 1, rationGljList: 1 }, function (err, result) {
                        if (err) {
                            cb(err);
                        }
                        else {
                            //删除
                            rationItemModel.update({ 'rationGljList.gljId': adjGljId }, { $pull: { rationGljList: { gljId: adjGljId } } }, { multi: true }, function (err) {
                                if (err) {
                                    cb(err);
                                }
                                else {
                                    //补充定额
                                    compleRationModel.find({ 'rationGljList.gljId': adjGljId }, { ID: 1, rationGljList: 1 }, function (err, compleRst) {
                                        if (err) {
                                            cb(err);
                                        }
                                        else {
                                            compleRationModel.update({ 'rationGljList.gljId': adjGljId }, { $pull: { rationGljList: { gljId: adjGljId } } }, { multi: true }, function (err) {
                                                if (err) {
                                                    cb(err);
                                                }
                                                else {
                                                    for (let i = 0, len = compleRst.length; i < len; i++) {
                                                        compleRst[i]._doc.type = 'complementary';
                                                    }
                                                    cb(null, result.concat(compleRst));
                                                }
                                            });
                                        }
                                    });
                                }
                            });
                        }
                    });
                }
                else {
                    rationItemModel.find({ 'rationGljList.gljId': adjGljId }, { ID: 1, rationGljList: 1 }, function (err, result) {
                        if (err) {
                            cb(err);
                        }
                        else {
                            compleRationModel.find({ 'rationGljList.gljId': adjGljId }, { ID: 1, rationGljList: 1 }, function (err, compleRst) {
                                if (err) {
                                    cb(err);
                                }
                                else {
                                    for (let i = 0, len = compleRst.length; i < len; i++) {
                                        compleRst[i]._doc.type = 'complementary';
                                    }
                                    cb(null, result.concat(compleRst));
                                }
                            });
                        }
                    });
                }
            },
            function (result, cb) {
                let compleRTasks = [], stdRTasks = [];
                //重算时需要用到的所有工料机,一次性取
                let compleGljIds = [], stdGljIds = [];
                for (let ration of result) {
                    for (let glj of ration.rationGljList) {
                        if (glj.type !== undefined && glj.type === 'complementary') {
                            compleGljIds.push(glj.gljId);
                        }
                        else {
                            stdGljIds.push(glj.gljId);
                        }
                    }
                }
                gljDao.getStdCompleGljItems(compleGljIds, stdGljIds, function (err, allGljs) {
                    if (err) {
                        cb(err);
                    }
                    else {
                        let gljIndex = {};
                        for (let glj of allGljs) {
                            gljIndex[glj.ID] = glj;
                        }
                        async.each(result, function (rationItem, ecb) {
                            let rationGljList = rationItem.rationGljList;
                            let gljArr = [];
                            for (let i = 0; i < rationGljList.length; i++) {
                                let theGlj = gljIndex[rationGljList[i].gljId];
                                if (theGlj !== undefined && theGlj) {
                                    if (theGlj.ID === adjGljId) {
                                        gljArr.push({ gljId: theGlj.ID, basePrice: adjBasePrice, consumeAmt: rationGljList[i].consumeAmt });
                                    } else {
                                        if (theGlj.priceProperty && Object.keys(theGlj.priceProperty).length > 0) {
                                            let priceKeys = Object.keys(theGlj.priceProperty);
                                            gljArr.push({ gljId: theGlj.ID, basePrice: parseFloat(theGlj.priceProperty[priceKeys[0]]), consumeAmt: rationGljList[i].consumeAmt });
                                        } else {
                                            gljArr.push({ gljId: theGlj.ID, basePrice: parseFloat(theGlj.basePrice), consumeAmt: rationGljList[i].consumeAmt });
                                        }
                                    }
                                }
                            }
                            //recalculate the price of ration
                            let basePrice = 0;
                            gljArr.forEach(function (gljItem) {
                                basePrice += gljItem.basePrice * gljItem.consumeAmt;
                            });
                            basePrice = scMathUtil.roundTo(basePrice, 0);
                            let task = {
                                updateOne: {
                                    filter: {
                                        ID: rationItem.ID
                                    },
                                    update: {
                                        basePrice: basePrice.toString()
                                    }
                                }
                            };
                            //updateDataBase
                            if (rationItem._doc.type !== undefined && rationItem._doc.type === 'complementary') {
                                compleRTasks.push(task);
                                ecb(null);
                            }
                            else {
                                stdRTasks.push(task);
                                ecb(null);
                            }
                        }, async function (err) {
                            if (err) {
                                cb(err);
                            }
                            else {
                                //do sth
                                try {
                                    if (compleRTasks.length > 0) {
                                        await compleRationModel.bulkWrite(compleRTasks);
                                    }
                                    if (stdRTasks.length > 0) {
                                        await rationItemModel.bulkWrite(stdRTasks);
                                    }
                                }
                                catch (e) {
                                    cb(err);
                                }
                                cb(null);
                            }
                        });
                    }
                });
            },
        ], function (err) {
            if (err) {
                finalCb(err);
            }
            else {
                finalCb(null);
            }
        });
    }, function (err) {
        if (err) {
            callback(err, 'Error');
        }
        else {
            callback(null, '');
        }
    });
};

rationItemDAO.prototype.getRationGljIds = function (data, callback) {
    let repId = data.repId;
    rationItemModel.find({ rationRepId: repId }, function (err, result) {
        if (err) {
            callback(err, 'Error', null);
        }
        else {
            let rstIds = [], newRst = [];
            result.forEach(function (data) {
                if (data.rationGljList.length > 0) {
                    data.rationGljList.forEach(function (gljObj) {
                        rstIds.push(gljObj.gljId);
                    })
                }
            });
            for (let i = 0; i < rstIds.length; i++) {
                if (newRst.indexOf(rstIds[i]) === -1) {
                    newRst.push(rstIds[i]);
                }
            }
            callback(null, '', newRst);
        }
    });
};

rationItemDAO.prototype.getRationsCodes = function (data, callback) {
    let repId = data.repId;
    rationItemModel.find({ rationRepId: repId, isDeleted: false }, function (err, result) {
        if (err) {
            callback(err, 'Error', null);
        }
        else {
            let rstCodes = [];
            result.forEach(function (rationItem) {
                rstCodes.push(rationItem.code);
            });
            callback(null, 'get all rationCodes success', rstCodes);
        }
    })
};

rationItemDAO.prototype.updateJobContent = function (lastOpr, repId, updateArr, callback) {
    rationRepositoryDao.updateOprArr({ ID: repId }, lastOpr, moment(Date.now()).format('YYYY-MM-DD HH:mm:ss'), function (err) {
        async.each(updateArr, function (obj, cb) {
            rationItemModel.update({ rationRepId: repId, code: obj.code }, { $set: { jobContent: obj.jobContent } }, function (err) {
                if (err) {
                    cb(err);
                }
                else {
                    cb(null);
                }
            })
        }, function (err) {
            if (err) {
                callback(err);
            }
            else {
                callback(null);
            }
        });
    });
}

rationItemDAO.prototype.updateAnnotation = function (lastOpr, repId, updateArr, callback) {
    rationRepositoryDao.updateOprArr({ ID: repId }, lastOpr, moment(Date.now()).format('YYYY-MM-DD HH:mm:ss'), function (err) {
        async.each(updateArr, function (obj, cb) {
            rationItemModel.update({ rationRepId: repId, code: obj.code }, { $set: { annotation: obj.annotation } }, function (err) {
                if (err) {
                    cb(err);
                }
                else {
                    cb(null);
                }
            })
        }, function (err) {
            if (err) {
                callback(err);
            }
            else {
                callback(null);
            }
        });
    });
};

//更新定额下模板关联
rationItemDAO.prototype.updateRationTemplate = async function (rationRepId, rationID, templateData) {
    //自动匹配定额
    let matachCodes = [],
        matchRations = [];
    //要保存的数据
    let saveData = [];
    for (let data of templateData) {
        if (data.code) {
            matachCodes.push(data.code);
        }
    }
    matachCodes = Array.from(new Set(matachCodes));
    if (matachCodes.length > 0) {
        matchRations = await rationItemModel.find({ rationRepId: rationRepId, code: { $in: matachCodes } }, '-_id ID code name');
    }
    let validData = [];
    //设置展示数据
    for (let data of templateData) {
        let match = false;
        for (let ration of matchRations) {
            if (data.code && data.code === ration.code) {
                match = true;
                data.name = ration.name;
                data.rationID = ration.ID;
                break;
            }
        }
        if (!match) {
            data.code = '';
            data.name = '';
        }
        if (data.type || data.code || data.name || data.billsLocation) {
            validData.push(data);
        }
    }
    for (let data of validData) {
        saveData.push({ rationID: data.rationID ? data.rationID : null, type: data.type, billsLocation: data.billsLocation });
    }
    //更新
    await rationItemModel.update({ ID: rationID }, { $set: { rationTemplateList: saveData } });
    return validData;
};

//计算导入数据的价格
rationItemDAO.prototype.calcForRation = function (stdGljList, ration) {
    let rationGljList = ration.rationGljList;
    let basePrice = 0;
    for (let rationGlj of rationGljList) {
        let glj = stdGljList[rationGlj.gljId];
        if (glj) {
            basePrice += glj.basePrice * rationGlj.consumeAmt;
        }
    }
    ration.basePrice = scMathUtil.roundTo(basePrice, 0).toString();
};

/**
 * 根据条件获取定额数据
 *
 * @param {Object} condition
 * @param {Object} fields
 * @param {String} indexBy
 * @return {Promise|Array}
 */
rationItemDAO.prototype.getRationItemByCondition = async function (condition, fields = null, indexBy = null) {
    let result = [];
    if (Object.keys(condition).length <= 0) {
        return result;
    }
    result = await rationItemModel.find(condition, fields).sort({ code: 1 });
    if (indexBy !== null && result.length > 0) {
        let tmpResult = {};
        for (let tmp of result) {
            tmpResult[tmp[indexBy]] = tmp;
        }
        result = tmpResult;
    }
    return result;
};

/**
 * 从excel中批量新增数据
 *
 * @param {Number} rationRepId
 * @param {Array} data
 * @return {bool}
 */
rationItemDAO.prototype.batchAddFromExcel = async function (rationRepId, data) {
    if (data.length <= 0) {
        return false;
    }
    // 获取定额库相关数据
    const rationRepository = await rationRepositoryDao.getRepositoryById(rationRepId);
    if (rationRepository.length !== 1 || rationRepository[0].gljLib === undefined) {
        return false;
    }
    // 获取标准工料机库数据
    const stdBillsLibListsModel = new STDGLJListModel();
    const stdGLJData = await stdBillsLibListsModel.getGljItemsByRepId(rationRepository[0].gljLib);
    // 整理标准工料机库数据
    let stdGLJList = {};
    let stdGLJListByID = {};
    for (const tmp of stdGLJData) {
        stdGLJList[tmp.code.toString()] = tmp.ID;
        stdGLJListByID[tmp.ID] = tmp;
    }
    let lastData = {};
    const rationData = [];
    // 编码列表，用于查找库中是否有对应数据
    let rationCodeList = [];
    let gljCodeList = [];
    // 插入失败的工料机列表(用于提示)
    this.failGLJList = [];
    for (const tmp of data) {
        if (tmp.length <= 0) {
            continue;
        }
        console.log(typeof tmp[0], tmp[0]);
        // 如果第一个字段为null则是工料机数据，放入上一个数据的工料机字段
        if (!tmp[0] && Object.keys(lastData).length > 0) {
            // 如果不存在对应的工料机库数据则跳过
            if (!stdGLJList[tmp[1]]) {
                const failString = '定额' + lastData.code + '下的' + tmp[1];
                this.failGLJList.push(failString);
                continue;
            }
            const tmpRationGlj = {
                gljId: stdGLJList[tmp[1]],
                consumeAmt: Math.abs(tmp[4]),
                proportion: 0,
            };
            lastData.rationGljList.push(tmpRationGlj);
            if (gljCodeList.indexOf(tmp[1]) < 0) {
                gljCodeList.push(tmp[1]);
            }
            continue;
        }

        if (tmp[0] === '定额' && Object.keys(lastData).length > 0) {
            rationData.push(lastData);
        }

        // 组装数据
        lastData = {
            code: tmp[1],
            name: tmp[2],
            unit: tmp[3],
            caption: tmp[2],
            rationRepId: rationRepId,
            sectionId: 0,
            labourPrice: '0',
            materialPrice: '0',
            machinePrice: '0',
            basePrice: '0',
            rationGljList: []
        };
        // 防止重复加入
        if (rationCodeList.indexOf(tmp[1]) < 0) {
            rationCodeList.push(tmp[1]);
        }
    }
    // 最后一个入数组
    rationData.push(lastData);

    // 查找数据库中是否已存在待插入数据
    const condition = {
        rationRepId: rationRepId,
        code: { $in: rationCodeList }
    };
    const existCodeList = await this.getRationItemByCondition(condition, ['code'], 'code');
    // 过滤插入数据
    let insertData = [];
    //已存在定额，则更新价格及rationGLjList字段
    let updateData = [];
    for (const ration of rationData) {
        if (existCodeList[ration.code] !== undefined) {
            updateData.push(ration);
            continue;
        }
        insertData.push(ration);
    }
    //更新定额
    let updateBulk = [];
    for (let ration of updateData) {
        this.calcForRation(stdGLJListByID, ration);
        updateBulk.push({
            updateOne: {
                filter: { rationRepId: rationRepId, code: ration.code },
                update: { $set: { rationGljList: ration.rationGljList, basePrice: ration.basePrice } }
            }
        });
    }
    //更新数据库
    if (updateBulk.length > 0) {
        await rationItemModel.bulkWrite(updateBulk);
    }
    // 如果都已经存在，直接返回
    if (insertData.length <= 0) {
        return true;
    }
    //计算价格
    for (let ration of insertData) {
        this.calcForRation(stdGLJListByID, ration);
    }

    // 组织id
    const counterInfo = await counter.counterDAO.getIDAfterCount(counter.moduleName.rations, insertData.length);
    let maxId = counterInfo.sequence_value;
    maxId = parseInt(maxId);

    let count = 0;
    for (const index in insertData) {
        insertData[index].ID = maxId - (insertData.length - 1) + count;
        count++;
    }
    // 插入数据库
    const result = await rationItemModel.create(insertData);
    return result.length > 0;
};

/**
 * 导出到excel的数据
 *
 * @param {Number} rationRepId
 * @return {Array}
 */
rationItemDAO.prototype.exportExcelData = async function (rationRepId) {
    const condition = {
        rationRepId: rationRepId
    };
    // @todo 限制导出的数量以防内存溢出
    const rationDataList = await this.getRationItemByCondition(condition, ['name', 'code', 'ID', 'sectionId', 'feeType', 'caption', 'basePrice', 'jobContent', 'annotation', 'unit']);

    // 整理数据
    let rationData = [];
    for (const tmp of rationDataList) {
        const sectionId = tmp.sectionId <= 0 || tmp.sectionId === undefined ? null : tmp.sectionId;
        const feeType = tmp.feeType === '' || tmp.feeType === undefined ? null : tmp.feeType;
        const ration = [sectionId, feeType, tmp.ID, tmp.code, tmp.name, tmp.caption, tmp.basePrice, tmp.jobContent, tmp.annotation, tmp.unit];
        rationData.push(ration);
    }
    //根据编号排序，优先级：number-number-..., number, Anumber....
    /*let regConnector = /-/g,
        regLetter = /[a-z,A-Z]/g,
        regNum = /\d+/g;
    rationData.sort(function (a, b) {
        let aCode = a[3],
            bCode = b[3],
            rst = 0;
        function compareConnector(arrA, arrB) {
            let lessArr = arrA.length <= arrB ? arrA : arrB;
            for (let i = 0; i < lessArr.length; i++) {
                let result = compareUnit(arrA[i], arrB[i]);
                if (result !== 0) {
                    return result;
                } else {

                }
            }
            function compareUnit(uA, uB) {
                let uAV = parseFloat(uA),
                    uBV = parseFloat(uB);
                if (uAV > uBV) {
                    return 1;
                } else if (uAV < uBV) {
                    return -1;
                }
                return 0;
            }
        }
        if (regConnector.test(a) && !regConnector.test(b)) {
            rst = -1;
        } else if (!regConnector.test(a) && regConnector.test(b)) {
            rst = 1;
        } else if (regConnector.test(a) && regConnector.test(b)) {

        }
    });
    rationData.sort(function (a, b) {
        let aCode = a[3],
            bCode = b[3],
            rst = 0,
            splitA = aCode.split('-'),
            splitB = bCode.split('-');
        if(splitA[0] > splitB[0]){
            rst = 1;
        }
        else if(splitA[0] < splitB[0]){
            rst = -1;
        }
        else {
            if(splitA[1] && splitB[1]){
                let floatA = parseFloat(splitA[1]),
                    floatB = parseFloat(splitB[1]);
                if(floatA > floatB){
                    rst = 1;
                }
                else if(floatA < floatB){
                    rst = -1;
                }
            }
        }
        return rst;
    });*/
    const excelData = [['树ID', '取费专业', '定额ID', '定额编码', '定额名', '定额显示名称', '基价', '工作内容', '附注', '单位']];
    excelData.push.apply(excelData, rationData);

    console.log(excelData);
    return excelData;
};

/**
 * 批量更改章节id
 *
 * @param {Object} data
 * @return {bool}
 */
rationItemDAO.prototype.batchUpdateSectionIdFromExcel = async function (data) {
    if (data.length <= 0) {
        return false;
    }
    // 批量执行update
    let rationTasks = [],
        sectionIDs = [];
    for (const tmp of data) {
        let rationId = parseInt(tmp[2]);
        rationId = isNaN(rationId) || rationId <= 0 ? 0 : rationId;
        let sectionId = parseInt(tmp[0]);
        sectionId = isNaN(sectionId) || sectionId <= 0 ? 0 : sectionId;
        if (sectionId <= 0 || rationId <= 0) {
            continue;
        }
        sectionIDs.push(sectionId);
        // 取费专业
        let feeType = tmp[1] || '';
        let name = tmp[4];
        name = name ? name : '';
        let caption = tmp[5];
        caption = caption ? caption : '';
        let jobContent = tmp[7] ? tmp[7] : '';
        let annotation = tmp[8] ? tmp[8] : '';
        rationTasks.push({
            updateOne: {
                filter: { ID: rationId },
                update: {
                    $set: {
                        sectionId,
                        feeType,
                        name,
                        caption,
                        jobContent,
                        annotation
                    }
                }
            }
        });
    }
    if (rationTasks.length <= 0) {
        throw '无有效数据(树ID、定额ID不为空、且为数值)';
    }
    // 更新定额数据
    await rationItemModel.bulkWrite(rationTasks);
    // 更新章节树工作内容、附注节点选项（全设置为ALL）
    sectionIDs = Array.from(new Set(sectionIDs));
    if (sectionIDs.length) {
        await stdRationSectionModel.updateMany(
            { ID: { $in: sectionIDs } },
            {
                $set: {
                    jobContentSituation: 'ALL',
                    annotationSituation: 'ALL'
                }
            }
        )
    }
};

module.exports = new rationItemDAO();