ConstructionCost/modules/main/facade/calc_program_facade.js

/**
 * Created by CSL on 2017-10-22.
 */

const uuidV1 = require('uuid/v1');
let logger = require("../../../logs/log_helper").logger;
let mongoose = require('mongoose');
let stdCalcProgramsModel = mongoose.model('std_calc_programs');
let projectCalcProgramsModel = mongoose.model('calc_programs');
let EngineeringLibModel = require("../../users/models/engineering_lib_model");
let _=require("lodash");
let consts = require('../models/project_consts');
let projectConsts = consts.projectConst;

module.exports = {
    newProjectCalcProgramFile: newProjectCalcProgramFile,
    getProjectCalcProgramFile: getProjectCalcProgramFile,
    getStdCalcProgramFile: getStdCalcProgramFile,
    getData: getData,
    save: save,
    saveCalcItem: saveCalcItem,
    saveCalcItems: saveCalcItems
};

async function newProjectCalcProgramFile(data) {
    logger.info(`Create new CalcProgram file for project : ${data.ID}`);
    let rst = null;
    let egnrModel = new EngineeringLibModel();
    let egnr = await egnrModel.getEngineering(data.property.engineering_id);
    if(!egnr) return rst;
    let valid_CP_libs = egnr._doc.program_lib;
    if (valid_CP_libs == undefined  || valid_CP_libs.length == 0) return rst;
    // 绑定多个计算程序标准文件时，默认取第一个作为标准模板。
    let stdCP = await getStdCalcProgramFile(valid_CP_libs[0].id);
    let doc={
        ID: uuidV1(),
        projectID: data.ID,
        name: data.name,
        libID: stdCP.ID,
        libName: stdCP.libName,
        templates: stdCP.templates
    };
    await projectCalcProgramsModel.create(doc);
    rst = {ID: doc.ID, name: doc.name};
    return rst;
};

async function getProjectCalcProgramFile(ID) {
    let projCP = await projectCalcProgramsModel.findOne({ID:ID});
    return projCP;
};

async function getStdCalcProgramFile(libID) {
    let stdCP = await stdCalcProgramsModel.findOne({ID:libID});
    return stdCP;
};

// 统一的 getData() 方法供project调用
function getData(projectID, callback) {
    projectCalcProgramsModel.findOne({projectID: projectID}, '-_id', function (err, datas) {
        if (!err) {
            // 旧项目没有计算程序文件，默认给它生成一个。
            if (!datas) {
                logger.info(`Create a calcProgram file for old project : ${projectID}`);
                getStdCalcProgramFile(1).then(function (stdCP) {
                    let doc = {
                        ID: uuidV1(),
                        projectID: projectID,
                        name: '[旧项目补计算程序文件]',
                        libID: stdCP.ID,
                        libName: stdCP.libName,
                        templates: stdCP.templates
                    };
                    projectCalcProgramsModel.create(doc);
                    callback(0, projectConsts.CALC_PROGRAM, stdCP);
                });
            } else {
                callback(0, projectConsts.CALC_PROGRAM, datas);
            };
        } else {
            callback(1, projectConsts.CALC_PROGRAM, null);
        };
    });
};

// 统一的 save() 方法供project调用
function save (user_id, datas, callback) {
    projectCalcProgramsModel.update({"projectID": 553}, {"libName":"goo—test"}, callback(null, {data: 'test'}));
}

function saveCalcItem(dataObj, callback) {
    dataObj=JSON.parse(dataObj);
    projectCalcProgramsModel.findOne({projectID: dataObj.projectID}, function (err, data) {
        if(!err){
            for (let i = 0; i < data.templates.length; i++){
                if (data.templates[i].ID == dataObj.templatesID){
                    for (let j=0; j < data.templates[i].calcItems.length; j++){
                        if (data.templates[i].calcItems[j].ID == dataObj.calcItem.ID){
                            data.templates[i].calcItems[j] = dataObj.calcItem;
                            data.save(function (err) {
                                if (err) {
                                    callback({err:1, msg:'本条计算规则保存失败'});
                                } else {
                                    callback({err:0, msg:'本条计算规则保存成功'});
                                }
                            });
                            break;
                        };
                    };
                    break;
                };
            };
        }
        else {
            callback( {err:1, msg:'没有找到计算程序文件'} );
        }
    });
};

// {  projectID: projectID, calcItems: [{templatesID, calcItem}]  }
function saveCalcItems(datas, callback) {
    let datasObj = JSON.parse(datas);
    projectCalcProgramsModel.findOne({projectID: datasObj.projectID}, function (err, data) {
        if(!err){
            for (let cI of datasObj.calcItems){
                for (let i = 0; i < data.templates.length; i++){
                    if (data.templates[i].ID == cI.templatesID){
                        for (let j=0; j < data.templates[i].calcItems.length; j++){
                            if (data.templates[i].calcItems[j].ID == cI.calcItem.ID){
                                data.templates[i].calcItems[j] = cI.calcItem;
                                data.save(function (err) {
                                    if (err) {
                                        callback({err:1, msg:'本条计算规则保存失败'});
                                    } else {
                                        callback({err:0, msg:'本条计算规则保存成功'});
                                    }
                                });
                                break;
                            };
                        };
                        break;
                    };
                };
            };
        }
        else {
            callback( {err:1, msg:'没有找到计算程序文件'} );
        }
    });
};

// for test
/*let udata = {ID:8, code: '8.8.8', name: '被改成了888', hehe: '增加的属性'};
saveCalcItem({projectID: 597, templatesID: 4, data: udata}, function (data) {
    console.log({msg:data.msg, data: data.data});
})*/