ConstructionCost/modules/glj/models/unit_price_model.js

/**
 * 单价业务模型
 *
 * @author CaiAoLin
 * @date 2017/6/30
 * @version
 */
import BaseModel from "../../common/base/base_model"
import CounterModel from "./counter_model"
import GLJListModel from "./glj_list_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
     * @return {Promise}
     */
    async updateUnitPrice(data, unitPriceFileId) {
        if (data.code === undefined || data.project_id === undefined || data.name === undefined
            || data.market_price === undefined) {
            return null;
        }
        let marketPrice = data.market_price !== undefined ? data.market_price : data.base_price;

        // 先查找是否有同code的单价记录 @todo 后续可能会加入单位这个字段进一步确定唯一性
        let unitPriceData = await this.findDataByCondition({code: data.code, unit_price_file_id: unitPriceFileId}, null, false);

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

        // 如果不存在基价单价，则在数据源中获取
        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;
            data.unit = firstUnitPrice.unit !== undefined ? firstUnitPrice.unit : 0;
        }

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

        // 统计当前同code的数量
        let sameCount = await this.count({code: data.code});

        if (sameCount > 0) {
            // 如果存在有别的同code的数据,则新增一条项目工料机，并更改name
            let regular = /\(\d\)/;
            let changeString = '(' + sameCount + ')';
            insertData.name = regular.test(insertData.name) ? insertData.name.replace(regular, changeString) :
                insertData.name + changeString;

            // 然后再插入一条项目工料机数据
            let gljListModel = new GLJListModel();
            // 首先先查找原有数据
            let originalData = await gljListModel.findDataByCondition({code: data.code, project_id: data.project_id}, {_id: 0});

            // 查不到数据直接抛出错误
            if(!originalData) {
                throw '没有找到code为:' + data.code + '的数据';
            }

            // 新增一条新name的项目工料机
            originalData.name = insertData.name;
            // 这里由于查出来的数据带有隐藏属性，所以先用json转一下
            originalData = JSON.stringify(originalData);
            let addGLJResult = await gljListModel.add(JSON.parse(originalData));
            if (!addGLJResult) {
                throw '新增工料机数据失败!';
            }
        }

        return this.add(insertData);
    }

    /**
     * 新增记录
     *
     * @param {object} data
     * @return {Promise}
     */
    async add(data) {
        let counterModel = new CounterModel();
        let unitPriceId = await counterModel.getId(collectionName);
        data.id = unitPriceId;

        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;
    }

}

export default UnitPriceModel;