ConstructionCost/modules/ration_glj/facade/ration_glj_facade.js

/**
 * Created by chen on 2017/6/29.
 */

let mongoose = require('mongoose');
const uuidV1 = require('uuid/v1');
let consts = require('../../main/models/project_consts')
let commonConsts = consts.commonConst;
let _=require("lodash");
let ration_glj = mongoose.model('ration_glj');
import GLJListModel from '../../glj/models/glj_list_model';
let std_glj_lib_gljList_model = mongoose.model('std_glj_lib_gljList');
let async_n = require("async");
let ration = mongoose.model('ration');
let ration_coe_facade = require('./ration_coe_facade');
let ration_coe = mongoose.model('ration_coe');
let std_ration_lib_ration_items = mongoose.model('std_ration_lib_ration_items');
let glj_calculate_facade = require('./glj_calculate_facade');
let quantity_detail_facade = require('./quantity_detail_facade');
let logger = require("../../../logs/log_helper").logger;


module.exports={
    save:save,
    getData:getData,
    deleteByRation:deleteByRation,
    getQuantityByProjectGLJ:getQuantityByProjectGLJ
}

let operationMap={
    'ut_create':create_ration_glj,
    'ut_update':update_ration_glj,
    'ut_delete':delete_ration_glj
};
let updateFunctionMap = {
    'normalUpdate':normalUpdate,
    'marketPriceAdjustUpdate':marketPriceAdjustUpdate,
    'customQuantityUpdate':customQuantityUpdate
};




/**
 * 根据项目工料机ID和项目ID取消耗量
 *
 * @param {object} condition
 * @return Array
 */
async function getQuantityByProjectGLJ(condition) {
    let query ={
        $and:[
            {'projectID':condition.projectID},
            {'projectGLJID':{$in:condition.projectGLJIDList}}
        ]
    }

    let results = await  ration_glj.find(query,['projectGLJID','quantity','rationID'],{sort: {projectGLJID: 1}});
    let rationList = _.uniq(_.map(results,'rationID'));

    let rationQuery={
        $and:[
            {'projectID':condition.projectID},
            {'ID':{$in:rationList}},
            {'deleteInfo': null}
        ]
    }
    let rations = await ration.find(rationQuery,['ID','quantity']);
    //deleteInfo: null
    console.log("rationList-----");
    console.log(rationList);

    return combineQuantity(results,rations);
}

function combineQuantity(results,rations) {
    let resultList=[];
    _.forEach(results,function (data) {
        let tmp = {
            projectGLJID:data.projectGLJID,
            quantity: data.quantity
        }
        let ration=_.find(rations,{ID:data.rationID});
        if(ration){
            tmp.rationID=ration.ID;
            tmp.rationQuantity=ration.quantity?Number(ration.quantity):undefined;
        }
        resultList.push(tmp);
      /*  if(resultMap.hasOwnProperty(data.projectGLJID)){
            resultMap[data.projectGLJID] += data.quantity;
        }else {
            resultMap[data.projectGLJID] = data.quantity;
        }*/
    });

 /*   var resultList =[];
    for(let key in resultMap){
       let newObject = {
            'projectGLJID':key,
            'quantity':resultMap[key]
        }
        resultList.push(newObject)
    }*/
    return resultList;
}


function get_lib_glj_info(ration_glj) {
    return function (result,cb) {
        std_glj_lib_gljList_model.findOne({'ID':ration_glj.GLJID},(err,glj)=>{
                if(err){
                cb(err,'')
            }else if(glj){
                ration_glj.name = glj.name;
                ration_glj.code = glj.code;
                ration_glj.unit = glj.unit;
                ration_glj.specs = glj.specs;
                ration_glj.basePrice = glj.basePrice;
                ration_glj.shortName = glj.shortName;
                ration_glj.type = glj.gljType;
                ration_glj.repositoryId = glj.ration_glj
                getInfoFromProjectGLJ(ration_glj).then(function (info) {
                    if(info){
                        let tem={};
                        tem.newRecode=createNewRecord(info);
                        tem.showData=info;
                        result.datas.push(tem);
                        cb(null,result);
                    }else {
                        cb(new Error('get project glj error'),null);
                    }
                });
            }else {
                cb(null,null);
            }
        })
    }
}


function createNewRecord(ration_glj) {
    let newRecoed={};
    newRecoed.ID=ration_glj.ID;
    newRecoed.projectID=ration_glj.projectID;
    newRecoed.GLJID=ration_glj.GLJID;
    newRecoed.rationID=ration_glj.rationID;
    newRecoed.rationItemQuantity=ration_glj.rationItemQuantity;
    newRecoed.quantity=ration_glj.quantity;
    newRecoed.name = ration_glj.name;
    newRecoed.code = ration_glj.code;
    newRecoed.unit = ration_glj.unit;
    newRecoed.specs = ration_glj.specs;
    newRecoed.shortName = ration_glj.shortName;
    newRecoed.type = ration_glj.type;
    newRecoed.repositoryId = ration_glj.repositoryId;
    newRecoed.projectGLJID=ration_glj.projectGLJID;
  return newRecoed
}

async function getInfoFromProjectGLJ(ration_glj) {
     let data = {
         glj_id: ration_glj.GLJID,
         project_id: ration_glj.projectID,
         code: ration_glj.code,
         name: ration_glj.name,
         specs: ration_glj.specs,
         unit: ration_glj.unit,
         type: ration_glj.type,
         type_of_work: ration_glj.type,
         base_price: ration_glj.basePrice,
         market_price: ration_glj.basePrice,
         repositoryId:ration_glj.repositoryId
     };

     try {
         let projectGljModel = new GLJListModel();
         let result = await projectGljModel.addList(data);
         ration_glj.marketPrice=result.unit_price.market_price;
         ration_glj.adjustPrice=result.unit_price.base_price;
         ration_glj.basePrice=result.unit_price.base_price;
         ration_glj.projectGLJID=result.id;
         ration_glj.isEstimate=result.is_evaluate;
         return ration_glj;
     } catch (err) {
         logger.err(err);
         return null;
     }

 }

function create_ration_glj(user_id,datas) {
    return function (callback) {
        let ration_glj_list=datas.ration_glj_list;
        var tasks=[];
        tasks.push(startingTask("get glj info"))
        for(let i =0;i<ration_glj_list.length;i++){
            ration_glj_list[i].ID = uuidV1();
            tasks.push(get_lib_glj_info(ration_glj_list[i]))
        }
        async_n.waterfall(tasks,(err,results)=>{
            if(err){
                callback(err,results)
            }else {
                let newRecords =[];
                let showDatas=[];
                for (let r of results.datas){
                    if(r){
                        newRecords.push(r.newRecode);
                        showDatas.push(r.showData);
                    }
                }
                if(newRecords.length>0){
                    ration_glj.insertMany(newRecords,(err,doc)=>{
                        if(err){
                            callback(err,null);
                        }else {
                            let returndata ={
                                updateTpye:commonConsts.UT_CREATE,
                                moduleName:'ration_glj',
                                data:{
                                    newRecords:newRecords,
                                    showDatas:showDatas
                                }
                            }
                            callback(null,returndata)
                        }
                    });
                }else {
                    logger.info("can't find gljs")
                    callback(null,null)
                }

            }
        })
    }

}

function update_ration_glj(user_id,datas) {
    if(datas.updateFunction){
        return updateFunctionMap[datas.updateFunction](user_id,datas);
    }else {
        return normalUpdate(user_id,datas);
    }
}

function normalUpdate(user_id,datas){
    return function(callback) {
        ration_glj.update(datas.query,datas.doc,(err,result)=>{
            if(err){
                callback(err,'');
            }else {
                let returndata ={
                    moduleName:'ration_glj',
                    data:{
                        updateTpye:commonConsts.UT_UPDATE,
                        query:datas.query,
                        doc:datas.doc
                    }
                }
                callback(null,returndata)
            }
        })
    }
}

function customQuantityUpdate(user_id,datas){
    return function(callback) {
        doCustomQuantityUpdate(datas).then((result)=>{
            if(result.err){
                callback(result.err,'');
            }else {
                let ration_glj_data ={
                    moduleName:'ration_glj',
                    data:{
                        updateTpye:commonConsts.UT_UPDATE,
                        quantityRefresh:true,
                        glj_result:result.cal_result.glj_result
                    }
                };
                let ration_data ={
                    moduleName:'ration',
                    data:{
                        updateTpye:commonConsts.UT_UPDATE,
                        stateRefresh:true,
                        rationID:result.cal_result.rationID,
                        adjustState:result.cal_result.adjustState
                    }
                };
                callback(null,[ration_glj_data,ration_data]);
            }
        })
    }
}

async function doCustomQuantityUpdate(datas){
    let result = {
        err:null
    }
    try{
        await ration_glj.update(datas.query,datas.doc);
        let cal_result = await glj_calculate_facade.calculateQuantity({projectID:datas.query.projectID,rationID:datas.query.rationID});

        cal_result.glj_result.forEach(function (item) {
           if(!item.doc.hasOwnProperty('customQuantity')){
               item.doc.customQuantity=null;
           }
        });
        result.cal_result =cal_result;
        console.log(result);
        return result;
    }catch (err){
        result.err = err;
        console.log(err);
        return result;
    }
}


function marketPriceAdjustUpdate(user_id,datas) {
    return function (callback) {
        updateprojectGljAndRationGLJ(datas.query,datas.doc).then((result)=>{
            if(result.err){
                callback(result.err,'');
            }else {
                let returndata ={
                    moduleName:'ration_glj',
                    data:{
                        updateTpye:commonConsts.UT_UPDATE,
                        query:datas.query,
                        doc:result.doc
                    }
                };
                let ration_data ={
                    moduleName:'ration',
                    data:{
                        updateTpye:commonConsts.UT_UPDATE,
                        stateRefresh:true,
                        rationID:datas.query.rationID,
                        adjustState:result.adjustState
                    }
                }
                callback(null,[returndata,ration_data]);
            }
        })

    }
}

async function updateprojectGljAndRationGLJ(query,doc) {
    let returnresult={};
    try {
        let gljListModel = new GLJListModel();
        let temp = doc.market_price;
        if(doc.market_price==null){
            doc.market_price = doc.base_price;
        }
        delete doc.base_price;
        let result = await gljListModel.modifyMarketPrice(doc);
        let updateDoc ={
            marketPrice:result.unit_price.market_price,
            marketPriceAdjust:temp,
            projectGLJID:result.id,
            isEstimate:result.is_evaluate,
            name : result.name,
            code:result.code
        };
        let updateresult = await ration_glj.findOneAndUpdate(query, updateDoc);
        let stateResult =  await glj_calculate_facade.calculateQuantity({projectID:query.projectID,rationID:query.rationID},true);

         returnresult ={
            err:null,
            doc :updateDoc,
            adjustState:stateResult.adjustState
        }
        return returnresult;

        } catch (error) {
           returnresult.err = error;
            console.log(error);
            return returnresult
         }
}


function delete_ration_glj(user_id,datas) {
    return function (callback) {
        if(datas.deleteType=="RATION"){
            deleteByRation(datas,callback);
        }else if(datas.deleteType=="BILL"){
            deleteByBill(user_id,datas,callback);
        } else{
            deleteByID(datas,callback);
        }
    }
}

function deleteByRation(datas,callback) {
    let data = datas.updateData;
    let tasks=[];
    tasks.push(deleteGLJList(data));
    tasks.push(ration_coe_facade.delete_ration_coe(data));
    tasks.push(quantity_detail_facade.deleteByRation(data));
    async_n.parallel(tasks,function (err,result) {
        commonCallback(callback,result,err)
    })
}

function  deleteGLJList(data) {
    return function (callback) {
        ration_glj.deleteMany({projectID: data.projectID, rationID: data.ID},(err,result)=>{
            commonCallback(callback,result,err)
        });
    }
}


function deleteByBill(user_id,datas,callback) {
    let tasks = [];
    tasks.push(startingTask("deleteByBill"));
    tasks.push(getRationsByBill(datas));
    tasks.push(deleteRationsbyBill(user_id,datas));
    tasks.push(deleteByMultiRations(datas));
    async_n.waterfall(tasks,function (err,results) {
        if(err){
            callback(err,'');
        }else {
            callback(null,results);
        }
    })
}


function  deleteByID(datas,callback){
    ration_glj.deleteOne(datas.query,(err,result)=>{
        if(err){
            callback(err,'');
        }else {
            let returndata ={
                moduleName:'ration_glj',
                data:{
                    updateTpye:commonConsts.UT_DELETE,
                    query:datas.query,
                }
            }
            callback(null,returndata)
        }
    })
}

function startingTask(processName){
    return function(asyncCallBack){
        var result = {
            processName : processName,
            datas:[]
        };
        asyncCallBack(null, result);
    };
}

function  getRationsByBill(datas) {
    return function (results,callback) {
        ration.find({projectID:datas.updateData.projectID,billsItemID:datas.updateData.ID,deleteInfo: null},function (err,rations) {
            if(err){
                callback(err,'')
            }else {
                results.rations=rations;
                callback(null,results)
            }
        })
    }
}

function deleteRationsbyBill (user_id,datas){
    return function (results,callback) {
       let deleteInfo ={
            deleteInfo :{deleted: true, deleteDateTime: new Date(), deleteBy: user_id}
        };
        ration.update({projectID: datas.updateData.projectID, billsItemID:datas.updateData.ID},deleteInfo,{multi: true},(err,deleteresults)=>{
            if(err){
                callback(err,'');
            }else {
                callback(null,results);
            }
        });
    }
}


function deleteByMultiRations(datas) {
    return function (results,deleteCallBack) {
        var delete_tasks = [];
        var deleteOne=function (ration) {
            return function (callback) {
                ration_glj.deleteMany({projectID: ration.projectID, rationID: ration.ID},function (err,result) {
                    commonCallback(callback,result,err)
                });
            }
        }
        let rations = results.rations;
        for(let i=0;i<rations.length;i++){
            delete_tasks.push(deleteOne(rations[i]._doc));
            delete_tasks.push(ration_coe_facade.delete_ration_coe(rations[i]._doc));
            delete_tasks.push(quantity_detail_facade.deleteByRation(rations[i]._doc));
        }
        delete_tasks.push(quantity_detail_facade.deleteByBill(datas.updateData));
        async_n.parallel(delete_tasks,(err,results)=>{
            if (err){
                deleteCallBack(err,'')
            }else {
                deleteCallBack(null,results)
            }
        })
    }
}


/*
function  deleteByRation(doc) {
    return function (callback){
        ration_glj.deleteMany({projectID: doc.updateData.projectID, rationID: doc.updateData.ID},callback);
    }
}
*/

function save (user_id, datas, callback) {
    let operations=[];
    if(_.isArray(datas)){
        for(let i=0;i<datas.length;i++){
            operations.push(operationMap[datas[i].updateType](user_id,datas[i]));
        }
    }else {
        operations.push(operationMap[datas.updateType](user_id,datas));
    }
    async_n.parallel(operations,function (err,results) {
        if(err){
            callback(err,'');
        }else {
            if(results.length==1){
                callback(null,results[0])
            }else {
                callback(null,results)
            }
        }
    })
}

function getData(projectID, callback) {
    ration_glj.find({'projectID':projectID},(err,datas)=>{
        if(err){
            callback(1, '', null);
        }else {
            callback(0, consts.projectConst.RATION_GLJ, datas);
        }
    })
}

function commonCallback(callback,result,err) {
    if(err){
        callback(err,'');
    }else {
        callback(null,result);
    }
}