ConstructionCost/modules/glj/models/unit_price_model.js

/**
 * 单价业务模型
 *
 * @author CaiAoLin
 * @date 2017/6/30
 * @version
 */
import BaseModel from "../../common/base/base_model"
import GLJTypeConst from "../../common/const/glj_type_const"
import CounterModel from "./counter_model"
import {default as UnitPriceSchema, collectionName as collectionName} from "./schemas/unit_price";

class UnitPriceModel extends BaseModel {

    /**
     * 构造函数
     *
     * @return {void}
     */
    constructor() {
        let parent = super();
        parent.model = UnitPriceSchema;
        parent.init();
    }

    /**
     * 根据单价文件id获取单价数据
     *
     * @param {Number} fileId
     * @return {Promise}
     */
    async getDataByFileId(fileId) {
        fileId = parseInt(fileId);
        if (isNaN(fileId) || fileId <= 0) {
            return null;
        }

        let unitPriceList = await this.db.model.find({unit_price_file_id: fileId});
        if (unitPriceList.length <= 0) {
            return null;
        }

        // 整理数据
        let result = {};
        for(let tmp of unitPriceList) {
            result[tmp.code + tmp.name] = tmp;
        }

        return result;
    }

    /**
     * 设置场景
     *
     * @param {string} scene
     * @return {void}
     */
    setScene(scene = '') {
        switch (scene) {
            // 新增数据的验证规则
            case 'add':
                this.model.schema.path('base_price').required(true);
                this.model.schema.path('market_price').required(true);
                this.model.schema.path('name').required(true);
                this.model.schema.path('code').required(true);
                // this.model.schema.path('unit').required(true);
                this.model.schema.path('type').required(true);
                this.model.schema.path('unit_price_file_id').required(true);
        }
    }

    /**
     * 新增单价数据
     *
     * @param {Object} data
     * @param {Number} unitPriceFileId
     * @param {Number} gljCount
     * @return {Promise} 返回数据以及是否新增
     */
    async addUnitPrice(data, unitPriceFileId, gljCount = 0) {
        if (data.code === undefined || data.project_id === undefined || data.name === undefined
            || data.market_price === undefined) {
            return [null, false];
        }

        // 先查找是否有同code的单价记录
        let unitPriceData = await this.findDataByCondition({code: data.code, unit_price_file_id: unitPriceFileId}, null, false);

        // 如果有记录，判断是否存在一样的市场单价，有则直接返回数据
        data.market_price = parseFloat(data.market_price);
        let unitPriceIndex = this.isPriceIncluded(unitPriceData, data.market_price);
        if (unitPriceData && unitPriceIndex >= 0) {
            return [unitPriceData[unitPriceIndex], false];
        }

        // 如果不存在基价单价，则在数据源中获取
        if (data.base_price === undefined) {
            let firstUnitPrice = unitPriceData[0] !== undefined ? unitPriceData[0] : [];
            data.base_price = firstUnitPrice.base_price !== undefined ? firstUnitPrice.base_price : 0;
            data.type = firstUnitPrice.type !== undefined ? firstUnitPrice.type : 0;
        }

        // 更改名称
        if (gljCount > 0) {
            let regular = /\(\d+\)/;
            let changeString = '(' + gljCount + ')';
            data.name = regular.test(data.name) ? data.name.replace(regular, changeString) :
                data.name + changeString;
        }

        let insertData = {
            code: data.code,
            base_price: data.base_price,
            market_price: data.market_price,
            unit_price_file_id: unitPriceFileId,
            name: data.name,
            type: data.type,
        };

        let addPriceResult = await this.add(insertData);
        return [addPriceResult, true];
    }

    /**
     * 新增记录
     *
     * @param {object} data
     * @return {Promise}
     */
    async add(data) {
        let counterModel = new CounterModel();
        if (data instanceof Array) {
            // 如果是批量新增
            for(let tmp in data) {
                data[tmp].id = await counterModel.getId(collectionName);
            }
        } else {
            data.id = await counterModel.getId(collectionName);
        }

        this.setScene('add');
        return this.db.model.create(data);
    }

    /**
     * 判断数据中是否包含某个市场价格的记录
     *
     * @param {Array} data
     * @param {Number} price
     * @return {Number}
     */
    isPriceIncluded(data, price) {
        let index = -1;
        if (data.length <= 0) {
            return index;
        }
        for(let tmp in data) {
            if (data[tmp].market_price === price) {
                index = tmp;
                break;
            }
        }

        return index;
    }

    /**
     * 更新市场单价
     *
     * @param {Object} condition
     * @param {Object} updateData
     * @param {String} extend
     * @return {Promise}
     */
    async updatePrice(condition, updateData, extend = '') {
        if (Object.keys(condition).length <= 0 || Object.keys(updateData).length <= 0) {
            return false;
        }
        // 首先查找相应的数据判断工料机类型
        let unitPriceData = await this.findDataByCondition(condition);
        if (!unitPriceData) {
            throw '找不到对应的单价数据';
        }

        // 基价单价的计算
        switch (unitPriceData.type) {
            // 主材、设备自动赋值基价单价=市场单价
            case GLJTypeConst.MAIN_MATERIAL:
            case GLJTypeConst.EQUIPMENT:
                updateData.base_price = updateData.market_price;
                break;
        }

        // 额外更新数据
        if (extend !== '') {
            extend = JSON.parse(extend);
            for (let code in extend) {
                let extendUpdateData = {
                    market_price: extend[code].market_price,
                };
                let tmpCondition = {
                    unit_price_file_id: unitPriceData.unit_price_file_id,
                    code: code
                };
                let extendResult = await this.db.update(tmpCondition, extendUpdateData);
                if (!extendResult) {
                    throw '更新额外数据，编码为' + code + '的数据失败!';
                }
            }
        }

        let result = await this.db.update(condition, updateData);
        return result.ok !== undefined && result.ok === 1;
    }

    /**
     * 复制单价文件数据
     *
     * @param {Number} currentUnitPriceId
     * @param {Number} changeUnitPriceId
     * @return {Promise}
     */
    async copyNotExist(currentUnitPriceId, changeUnitPriceId) {
        let result = false;
        // 首先查找原单价文件id下的数据
        let currentUnitList = await this.findDataByCondition({unit_price_file_id: currentUnitPriceId}, null, false);
        if (currentUnitList === null) {
            return result;
        }
        // 过滤mongoose格式
        currentUnitList = JSON.stringify(currentUnitList);
        currentUnitList = JSON.parse(currentUnitList);

        let codeList = [];
        for (let tmp of currentUnitList) {
            if (codeList.indexOf(tmp.code) >= 0) {
                continue;
            }
            codeList.push(tmp.code);
        }

        // 查找即将更替的单价文件是否存在对应的工料机数据
        let condition = {unit_price_file_id: changeUnitPriceId, code: {"$in": codeList}};
        let targetUnitList = await this.findDataByCondition(condition, null, false, 'code');

        // 如果没有重叠的数据则原有的数据都复制一份
        let insertData = [];
        for (let tmp of currentUnitList) {
            if (targetUnitList !== null && targetUnitList[tmp.code] !== undefined) {
                continue;
            }
            // 删除原有id信息
            delete tmp._id;
            delete tmp.id;
            tmp.unit_price_file_id = changeUnitPriceId;
            insertData.push(tmp);
        }

        return insertData.length > 0 ? this.add(currentUnitList) : true;

    }


}

export default UnitPriceModel;