1.修改原有定额工料机交互逻辑

2.新增手工修改单价的条件判断

modules/common/base/base_model.js

@@ -54,7 +54,7 @@ class BaseModel {
             return null;
         }
 
-        let data = await singleData ? this.db.findOne(condition, fields) : this.db.find(condition);
+        let data = await singleData ? this.db.findOne(condition, fields) : this.db.find(condition, fields);
         return data;
     }
 

modules/common/helper/mongoose_helper.js

@@ -46,12 +46,13 @@ class MongooseHelper {
      *
      * @param {object} conditions
      * @param {object} fields
+     * @param {object} option
      * @return {Promise}
      */
-    find(conditions, fields = null) {
+    find(conditions, fields = null, option = null) {
         let self = this;
         return new Promise(function (resolve, reject) {
-            self.model.find(conditions, fields, function (error, data) {
+            self.model.find(conditions, fields, option, function (error, data) {
                 if (error) {
                     reject(error);
                 } else {

modules/glj/controllers/glj_controller.js

@@ -40,11 +40,12 @@ class GLJController extends BaseController {
             // 先获取对应标段的项目工料机数据
             let gljListModel = new GLJListModel();
             let gljList = await gljListModel.getListByProjectId(projectId);
-            console.log(gljList);
 
             let renderData = {
                 gljList: JSON.stringify(gljList),
-                materialIdList: gljListModel.materialIdList
+                materialIdList: gljListModel.materialIdList,
+                autoChangeGLJType: UnitPriceModel.autoChangeGLJType,
+                triggerCalculateGLJType: UnitPriceModel.triggerCalculateGLJType
             };
             response.render('glj/html/glj_index', renderData);
 
@@ -85,25 +86,25 @@ class GLJController extends BaseController {
             modelString = fieldArray.length > 1 ? fieldArray[0] : modelString;
             field = fieldArray.length > 1 ? fieldArray[1] : field;
 
+            // 组合数据
+            let updateData = new Object();
+            updateData[field] = value;
+
+            let result = false;
             let model = null;
             switch (modelString) {
                 case 'glj':
                     model = new GLJListModel();
+                    // 更新数据
+                    result = await model.updateById(id, updateData);
                     break;
                 case 'unit_price':
                     model = new UnitPriceModel();
+                    // 更新数据
+                    result = await model.updatePriceById(id, updateData);
                     break;
             }
 
-            if (!model) {
-                throw '创建模块失败!';
-            }
-            // 组合数据
-            let updateData = new Object();
-            updateData[field] = value;
-
-            // 更新数据
-            let result = await model.updateById(id, updateData);
             if (!result) {
                 throw '更新失败';
             }
@@ -125,15 +126,15 @@ class GLJController extends BaseController {
     async test(request, response) {
         // 从定额库获取的数据
         let data = {
-            glj_repository_id: 3,
+            glj_repository_id: 1,
             project_id: 1,
-            code: '01010101',
-            name: '水泥',
-            specs: '32.5',
-            unit: 'kg',
-            type: 5,
-            base_price: 28.76,
-            market_price: 28.76
+            code: '00010201',
+            name: '土石方综合工日',
+            specs: '',
+            unit: '工日',
+            type: 2,
+            base_price: '44.76',
+            market_price: '44.76'
         };
         try {
             let gljListModel = new GLJListModel();
@@ -156,25 +157,17 @@ class GLJController extends BaseController {
      */
     async testModify(request, response) {
         let projectId = request.query.project;
-        // 修改数据
+        // // 修改数据
         let updateData = {
-            code: '01010101',
-            market_price: '40',
-            name: '水泥',
+            code: '00010201',
+            market_price: '49',
+            name: '土石方综合工日',
             project_id: projectId
         };
 
         try {
-            // 获取标段对应的单价文件id
-            let unitPriceFileModel = new UnitPriceFileModel();
-            let unitPriceFile = await unitPriceFileModel.getDataByProject(projectId);
-            if (!unitPriceFile) {
-                throw '没有对应的单价文件';
-            }
-            let unitPriceFileId = unitPriceFile.id;
-
-            let unitPriceModel = new UnitPriceModel();
-            let result = await unitPriceModel.updateUnitPrice(updateData, unitPriceFileId);
+            let gljListModel = new GLJListModel();
+            let result = await gljListModel.modifyMarketPrice(updateData);
 
             console.log(result);
         } catch (error) {

modules/glj/models/glj_list_model.js

@@ -83,6 +83,10 @@ class GLJListModel extends BaseModel {
             // 组合数据
             this.combineUnitPrice(gljData, unitPriceList);
 
+            // 排序
+            gljData.sort(function (a, b) {
+                return a.unit_price.type - b.unit_price.type;
+            });
         } catch (error) {
             console.log("glj_list_model:" + error);
             gljData = [];
@@ -110,14 +114,14 @@ class GLJListModel extends BaseModel {
             }
             glj.unit_price = unitPriceList[glj.code + glj.name] !== undefined ? unitPriceList[glj.code + glj.name] : null;
             // 计算调整基价
-            switch (glj.type) {
+            switch (glj.type + '') {
                 // 人工: 调整基价=基价单价*调整系数
                 case labour:
                     glj.adjust_price = glj.adjustment * glj.unit_price.base_price;
                     break;
                 // 机械类型的算法
                 case machine:
-
+                    console.log('机械');
                     break;
                 // 材料、主材、设备
                 default:
@@ -161,7 +165,7 @@ class GLJListModel extends BaseModel {
 
             // 新增单价文件
             let unitPriceModel = new UnitPriceModel();
-            let unitPriceInsertData = await unitPriceModel.updateUnitPrice(data, unitPriceFileId);
+            let [unitPriceInsertData, isAdd] = await unitPriceModel.addUnitPrice(data, unitPriceFileId);
 
             if (!unitPriceInsertData) {
                 throw '新增单价失败!';
@@ -196,6 +200,104 @@ class GLJListModel extends BaseModel {
         return result;
     }
 
+    /**
+     * 根据工料机id修改市场单价
+     *
+     * @param {Object} updateData
+     * @return {Promise}
+     */
+    async modifyMarketPrice(updateData) {
+        let result = {};
+        try {
+            if (updateData.code === undefined || updateData.market_price === undefined ||
+                updateData.name === undefined || updateData.project_id === undefined) {
+                throw '参数有误!';
+            }
+
+            // 先查是否有对应code的数据
+            let gljListData = await this.findDataByCondition({code: updateData.code,
+                project_id: updateData.project_id}, {_id: 0}, false);
+            if (!gljListData) {
+                throw '不存在对应code数据';
+            }
+
+            // 获取标段对应的单价文件id
+            let unitPriceFileModel = new UnitPriceFileModel();
+            let unitPriceFile = await unitPriceFileModel.getDataByProject(updateData.project_id);
+            if (!unitPriceFile) {
+                throw '没有对应的单价文件';
+            }
+            let unitPriceFileId = unitPriceFile.id;
+            let unitPriceModel = new UnitPriceModel();
+
+            let gljCount = gljListData.length;
+            let [unitPriceData, isAdd] = await unitPriceModel.addUnitPrice(updateData, unitPriceFileId, gljCount);
+
+            // 判断是否已存在对应数据
+            let includeField = [
+                {field: 'name', value: unitPriceData.name}
+            ];
+            let gljIndex = this.isIncluded(gljListData, includeField);
+            let gljData = isAdd ? {} : gljListData[gljIndex];
+
+            // 如果单价数据新增则工料机也需要新增
+            if (isAdd) {
+                // 如果没有对应的记录则新增一条工料机数据，并更改name
+                let regular = /\(\d\)/;
+                let changeString = '(' + gljCount + ')';
+                updateData.name = regular.test(updateData.name) ? updateData.name.replace(regular, changeString) :
+                    updateData.name + changeString;
+
+                // 获取第一条数据作为数据源
+                let originalData = gljListData[0];
+
+                // 更改名称
+                originalData.name = updateData.name;
+                originalData = JSON.stringify(originalData);
+                gljData = await this.add(JSON.parse(originalData));
+                if (!gljData) {
+                    throw '新增工料机数据失败!';
+                }
+            }
+
+            gljData.unit_price = unitPriceData;
+
+            result = gljData;
+        } catch (error) {
+            console.log(error);
+            result = {};
+        }
+
+        return result;
+    }
+
+    /**
+     * 判断数据中是否包含某个数据
+     *
+     * @param {Array} data
+     * @param {Array} includeField
+     * @return {Number}
+     */
+    isIncluded(data, includeField) {
+        let index = -1;
+        if (data.length <= 0) {
+            return index;
+        }
+        for(let tmp in data) {
+            let counter = 0;
+            for (let includeTmp of includeField) {
+                if (data[tmp][includeTmp.field] === includeTmp.value) {
+                    counter++;
+                }
+            }
+            if (counter === includeField.length) {
+                index = tmp;
+                break;
+            }
+        }
+
+        return index;
+    }
 }
 
 export default GLJListModel;

modules/glj/models/unit_price_model.js

@@ -13,6 +13,22 @@ import {default as UnitPriceSchema, collectionName as collectionName} from "./sc
 class UnitPriceModel extends BaseModel {
 
     /**
+     * 自动赋值的工料机类型集
+     * (主材、设备)
+     *
+     * @var {Array}
+     */
+    static autoChangeGLJType = [10, 11];
+
+    /**
+     * 触发计算混凝土、砂浆、配合比、机械的市场单价
+     * (人工、材料(普通材料))
+     *
+     * @var {Array}
+     */
+    static triggerCalculateGLJType = [2, 5];
+
+    /**
      * 构造函数
      *
      * @return {void}
@@ -70,18 +86,18 @@ class UnitPriceModel extends BaseModel {
     }
 
     /**
-     * 更新单价数据(定额中修改价格时调用)
+     * 新增单价数据
      *
      * @param {Object} data
      * @param {Number} unitPriceFileId
-     * @return {Promise}
+     * @param {Number} gljCount
+     * @return {Promise} 返回数据以及是否新增
      */
-    async updateUnitPrice(data, unitPriceFileId) {
+    async addUnitPrice(data, unitPriceFileId, gljCount = 0) {
         if (data.code === undefined || data.project_id === undefined || data.name === undefined
             || data.market_price === undefined) {
-            return null;
+            return [null, false];
         }
-        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);
@@ -89,7 +105,7 @@ class UnitPriceModel extends BaseModel {
         // 如果有记录，判断是否存在一样的市场单价，有则直接返回数据
         let unitPriceIndex = this.isPriceIncluded(unitPriceData, data.market_price);
         if (unitPriceData && unitPriceIndex >= 0) {
-            return unitPriceData[unitPriceIndex];
+            return [unitPriceData[unitPriceIndex], false];
         }
 
         // 如果不存在基价单价，则在数据源中获取
@@ -100,47 +116,26 @@ class UnitPriceModel extends BaseModel {
             data.unit = firstUnitPrice.unit !== undefined ? firstUnitPrice.unit : 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: marketPrice,
+            market_price: data.market_price,
             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);
+        let addPriceResult = await this.add(insertData);
+        return [addPriceResult, true];
     }
 
     /**
@@ -180,6 +175,33 @@ class UnitPriceModel extends BaseModel {
         return index;
     }
 
+    /**
+     * 更新市场单价
+     *
+     * @param {Number} id
+     * @param {Object} updateData
+     * @return {Promise}
+     */
+    async updatePriceById(id, updateData) {
+        id = parseInt(id);
+        if (isNaN(id) || id <= 0 || Object.keys(updateData).length <= 0) {
+            return false;
+        }
+        // 首先查找相应的数据判断工料机类型
+        let unitPriceData = this.findDataByCondition({id: id});
+        if (!unitPriceData) {
+            throw '找不到对应的单价数据';
+        }
+
+        // 如果是主材、设备自动赋值基价单价=市场单价、调整基价=市场单价
+        if (UnitPriceModel.autoChangeGLJType.indexOf(unitPriceData.type) >= 0) {
+            updateData.base_price = updateData.market_price;
+        }
+
+        let result = await this.updateById(id, updateData);
+        return result;
+    }
+
 }
 
 export default UnitPriceModel;

web/glj/html/glj_index.html

@@ -31,14 +31,16 @@
 <script type="text/javascript">
     let jsonData = '<%- gljList %>';
     let materialIdList = '<%- materialIdList %>';
+    materialIdList = materialIdList !== '' ? materialIdList.split(",") : '';
     // 不能修改市场价格的类型id
     let canNotChangeTypeId = '64';
-    if(materialIdList !== '') {
-        materialIdList = materialIdList.split(",");
-    }
-    if(canNotChangeTypeId !== '') {
-        canNotChangeTypeId = canNotChangeTypeId.split(",");
-    }
+    canNotChangeTypeId = canNotChangeTypeId !== '' ? canNotChangeTypeId.split(",") : '';
+    // 自动赋值的工料机类型
+    let autoChangeGLJType = '<%- autoChangeGLJType %>';
+    autoChangeGLJType = autoChangeGLJType !== '' ? autoChangeGLJType.split(",") : '';
+    // 触发计算混凝土、砂浆、配合比、机械的市场单价的工料机类型
+    let triggerCalculateGLJType = '<%- triggerCalculateGLJType %>';
+    triggerCalculateGLJType = triggerCalculateGLJType !== '' ? triggerCalculateGLJType.split(",") : '';
 </script>
 <%include footer.html %>
 <script type="text/javascript" src="/web/glj/js/glj_index.js"></script>

web/glj/js/glj_index.js

@@ -5,9 +5,11 @@
  * @date 2017/6/15
  * @version
  */
+let header = [];
+let sheet = null;
 $(document).ready(function () {
     // excel
-    let header = [
+     header = [
         {name: '编码', field: 'code', visible: true},
         {name: '名称', field: 'name', visible: true},
         {name: '规格型号', field: 'unit_price.specs', visible: true},
@@ -40,7 +42,7 @@ $(document).ready(function () {
     spread.options.scrollbarShowMax = true;
     spread.options.scrollbarMaxAlign = true;
     spread.options.showHorizontalScrollbar = true;
-    let sheet = spread.getActiveSheet();
+    sheet = spread.getActiveSheet();
 
     // 设置表单不可编辑
     sheet.options.isProtected = true;
@@ -179,7 +181,6 @@ $(document).ready(function () {
         }
         let id = sheet.getValue(row, idColumn);
 
-
         $.ajax({
             url: '/glj/update',
             type: 'post',
@@ -199,7 +200,8 @@ $(document).ready(function () {
                     sheet.setValue(row, column, info.oldValue);
                     alert('更改数据失败!');
                 } else {
-                    // 成功
+                    // 成功则触发相应事件
+                    successTrigger(field, info);
                 }
             }
         });
@@ -233,7 +235,19 @@ $(document).ready(function () {
 
     // 绑定双击事件
     sheet.bind(GC.Spread.Sheets.Events.CellDoubleClick, function (element, info) {
-        console.log(info);
+        let column = info.col;
+        let row = info.row;
+        let field = header[column] !== undefined && header[column].field !== undefined ?
+            header[column].field : '';
+
+        // 获取类型
+        let typeColumn = getFieldColumn(header, 'unit_price.type');
+        let type = sheet.getValue(row, typeColumn);
+
+        // 如果类型为混凝土、砂浆、配合比、机械，则提示
+        if (field === 'unit_price.market_price' && canNotChangeTypeId.indexOf(type + '') >= 0) {
+            alert('当前工料机的市场单价由组成物计算得出，不可直接修改');
+        }
     });
 
 });
@@ -294,4 +308,37 @@ function checkData(validator, value) {
     }
 
     return result;
+}
+
+/**
+ * 成功事件
+ *
+ * @param {string} field
+ * @param {object} info
+ * @return {void}
+ */
+function successTrigger(field, info) {
+    switch (field) {
+        case 'unit_price.market_price':
+            let row = info.row;
+            let basePriceColumn = getFieldColumn(header, 'unit_price.base_price');
+            let adjustPriceColumn = getFieldColumn(header, 'adjust_price');
+
+            // 获取类型
+            let typeColumn = getFieldColumn(header, 'unit_price.type');
+            let type = sheet.getValue(row, typeColumn);
+
+            // 主材、设备自动赋值基价单价=市场单价、调整基价=市场单价
+            if (autoChangeGLJType.indexOf(type + '') >= 0) {
+                sheet.setValue(info.row, basePriceColumn, info.newValue);
+                sheet.setValue(info.row, adjustPriceColumn, info.newValue);
+            }
+
+            // 人工、材料(普通材料)触发 需计算混凝土、砂浆、配合比、机械的市场单价 @todo 后续添加
+            if (triggerCalculateGLJType.indexOf(type + '') >= 0) {
+                // 计算
+                console.log('触发计算');
+            }
+            break;
+    }
 }