Calculation/app/service/stage_pos.js

'use strict';

/**
 *
 *
 * @author Mai
 * @date
 * @version
 */

const measureType = require('../const/tender').measureType;
const timesLen = require('../const/audit').stage.timesLen;

module.exports = app => {
    class StagePos extends app.BaseService {
        /**
         * 构造函数
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        constructor(ctx) {
            super(ctx);
            this.tableName = 'stage_pos';
            this.qtyFields = ['contract_qty', 'qc_qty']
        }

        _getPosFilterSql(where, asTable = '') {
            let whereSql = '';
            if (!where) return whereSql;
            if (where.pid) {
                if (where.pid instanceof Array) {
                    whereSql += ' And ' + asTable + 'pid in ('  + this.ctx.helper.getInArrStrSqlFilter(where.pid) + ')';
                } else if (typeof where.pid === "string") {
                    whereSql += ' And ' + asTable + 'pid = ' + this.db.escape(where.pid);
                }
            }
            if (where.lid) {
                if (where.lid instanceof Array) {
                    whereSql += ' And ' + asTable + 'lid in ('  + this.ctx.helper.getInArrStrSqlFilter(where.lid) + ')';
                } else if (typeof where.pid === "string") {
                    whereSql += ' And ' + asTable + 'lid = ' + this.db.escape(where.lid);
                }
            }
            return whereSql;
        }

        /**
         * 查询期计量最后审核人数据
         * @param {Number} tid - 标段id
         * @param {Number} sid - 期id
         * @param {Number|Array} pid - 部位明细id（可以为空）
         * @returns {Promise<*>}
         */
        async getLastestStageData(tid, sid, where) {
            const filterSql = this._getPosFilterSql(where);
            const sql = 'SELECT Pos.id, Pos.tid, Pos.sid, Pos.lid, Pos.pid, Pos.contract_qty, Pos.qc_qty, Pos.postil, Pos.times, Pos.order FROM ' +
                '  (SELECT * FROM ' + this.tableName + ' WHERE tid = ? And sid = ?) As Pos ' +
                '  INNER JOIN ( ' +
                '    SELECT MAX(`times` * ' + timesLen + ' + `order`) As `flow`, `tid`, `sid`, `pid` From ' + this.tableName +
                '      WHERE `tid` = ? And sid = ?' + filterSql +
                '      GROUP BY `pid`' +
                '  ) As MaxFilter ' +
                '  ON (Pos.times * ' + timesLen + ' + Pos.order) = MaxFilter.flow And Pos.pid = MaxFilter.pid And Pos.sid = MaxFilter.sid';
            const sqlParam = [tid, sid, tid, sid];
            return await this.db.query(sql, sqlParam);
        }
        /**
         * 查询 某期 某轮审批 某审核人数据
         * @param {Number} tid - 标段id
         * @param {Number} sid - 期id
         * @param {Number} times - 期第几轮审批
         * @param {Number} order - 审核人顺序
         * @param {Number|Array|Null} pid - 部位明细id - 为空则查询全部
         * @returns {Promise<*>}
         */
        async getAuditorStageData(tid, sid, times, order, where) {
            const filterSql = this._getPosFilterSql(where);
            const sql = 'SELECT Pos.id, Pos.tid, Pos.sid, Pos.pid, Pos.lid, Pos.contract_qty, Pos.qc_qty, Pos.postil, Pos.times, Pos.order FROM ' +
                '  (SELECT * FROM '+ this.tableName + ' WHERE tid = ? And sid = ?) As Pos ' +
                '  INNER JOIN ( ' +
                '    SELECT MAX(`times` * ' + timesLen + ' + `order`) As `flow`, `pid`, `sid` From ' + this.tableName +
                '      WHERE `times` < ? OR (`times` = ? AND `order` <= ?) And tid = ? And sid = ?' + filterSql +
                '      GROUP BY `pid`' +
                '  ) As MaxFilter ' +
                '  ON (Pos.times * ' + timesLen + ' + Pos.order) = MaxFilter.flow And Pos.pid = MaxFilter.pid And Pos.sid = MaxFilter.sid';
            const sqlParam = [tid, sid, times, times, order, tid, sid];
            return await this.db.query(sql, sqlParam);
        }

        /**
         * 新增部位明细数据（仅供updateStageData调用）
         *
         * @param transaction - 事务
         * @param data - 新增数据
         * @returns {Promise<{}>}
         * @private
         */
        async _addStagePosData(data) {
            let bills , precision;
            const  result = {pos: [], ledger: []};
            const datas = data instanceof Array ? data : [data], calcBills = [], calcStageBills = [];

            const transaction = await this.db.beginTransaction();
            try {
                for (const d of datas) {
                    if (d.sgfh_qty !== undefined || d.sjcl_qty !== undefined || d.qtcl_qty !== undefined) {
                        if (!bills || bills.id !== data.lid) {
                            bills = await this.ctx.service.ledger.getDataById(d.lid);
                            precision = this.ctx.helper.findPrecision(this.ctx.tender.info.precision, bills.unit);
                        }
                    }
                    // 在主表pos中新增数据
                    const p = {
                        id: this.uuid.v4(), tid: this.ctx.tender.id, lid: d.lid, name: d.name, porder: d.porder,
                        add_stage: this.ctx.stage.id,
                        add_times: this.ctx.stage.curTimes,
                        add_user: this.ctx.session.sessionUser.accountId,
                    };
                    if (d.sgfh_qty) p.sgfh_qty = this.round(d.sgfh_qty, precision.value);
                    if (d.sjcl_qty) p.sjcl_qty = this.round(d.sjcl_qty, precision.value);
                    if (d.qtcl_qty) p.qtcl_qty = this.round(d.qtcl_qty, precision.value);
                    p.quantity = this.ctx.helper.sum([p.sgfh_qty, p.sjcl_qty, p.qtcl_qty]);
                    const addRst = await transaction.insert(this.ctx.service.pos.tableName, p);
                    result.pos.push(p.id);
                    // 如果存在复核数据，更新计算主表清单
                    if (p.sgfh_qty || p.sjcl_qty || p.qtcl_qty) {
                        calcBills.push(p.lid);
                        result.ledger.push(p.lid);
                    }
                    // 如果存在本期计算数据，更新计算清单本期计量数据
                    if (d.contract_qty || d.qc_qty || d.postil) {
                        const ps = {
                            pid: d.id,
                            lid: d.lid,
                            tid: this.ctx.tender.id,
                            sid: this.ctx.stage.id,
                            said: this.ctx.session.sessionUser.accountId,
                            times: this.ctx.stage.curTimes,
                            order: this.ctx.stage.curOrder,
                        };
                        if (d.contract_qty) ps.contract_qty = this.round(d.contract_qty, precision.value);
                        if (d.qc_qty) ps.qc_qty = this.round(d.qc_qty, precision.value);
                        if (d.postil) ps.postil = d.postil;
                        await transaction.insert(ps);
                        if (d.contract_qty || d.qc_qty) {
                            calcStageBills.push(ps.lid);
                        }
                        result.stageUpdate = true;
                    }
                }
                for (const lid of calcBills) {
                    await this.ctx.service.ledger.calc(this.ctx.tender.id, lid, transaction);
                }
                for (const lid of calcStageBills) {
                    await this.ctx.service.stageBills.calc(ctx.tender.id, ctx.stage.id, lid, transaction);
                }
                await transaction.commit();
                return result;
            } catch(err) {
                await transaction.rollback();
                throw err;
            }
        }

        /**
         * 更新部位明细数据（仅供updateStageData调用）
         *
         * @param transaction - 事务
         * @param data - 更新数据(允许一次性提交多条)
         * @returns {Promise<{ledger: Array, pos: Array}>}
         * @private
         */
        async _updateStagePosData(data) {
            let bills, precision;
            const result = {ledger: [], pos: [], stageUpdate: true}, ledgerCalc = [];
            const datas = data instanceof Array ? data : [data];
            const orgPos = await this.ctx.service.pos.getPosDataByIds(this._.map(datas, 'pid'));
            const orgStagePos = await this.getLastestStageData(this.ctx.tender.id, this.ctx.stage.id, {pid: this._.map(datas, 'pid')});

            const transaction = await this.db.beginTransaction();
            try {
                for (const d of datas) {
                    if (d.sgfh_qty || d.qtcl_qty || d.sjcl_qty || d.contract_qty || d.qc_qty) {
                        if (!bills || bills.id !== data.lid) {
                            bills = await this.ctx.service.ledger.getDataById(d.lid);
                            precision = this.ctx.helper.findPrecision(this.ctx.tender.info.precision, bills.unit);
                        }
                    }
                    if (d.name !== undefined || d.sgfh_qty !== undefined || d.qtcl_qty !== undefined || d.sjcl_qty !== undefined || d.drawing_code !== undefined) {
                        const op = this._.find(orgPos, {id: d.pid});
                        if (op.add_stage !== this.ctx.stage.id) throw '不可修改数据';
                        const p = {id: d.pid};
                        if (d.name !== undefined) p.name = d.name;
                        if (d.sgfh_qty !== undefined || d.qtcl_qty !== undefined || d.sjcl_qty !== undefined) {
                            p.sgfh_qty = d.sgfh_qty !== undefined ? d.sgfh_qty : op.sgfh_qty;
                            p.sjcl_qty = d.sjcl_qty !== undefined ? d.sjcl_qty : op.sjcl_qty;
                            p.qtcl_qty = d.qtcl_qty !== undefined ? d.qtcl_qty : op.qtcl_qty;
                            p.quantity = this.ctx.helper.sum([p.sgfh_qty, p.sjcl_qty, p.qtcl_qty]);
                            if (ledgerCalc.indexOf(op.lid) === -1) {
                                ledgerCalc.push(op.lid);
                            }
                        }
                        if (d.drawing_code !== undefined) p.drawing_code = d.drawing_code;
                        await transaction.update(this.ctx.service.pos.tableName, p);
                    }

                    if (d.contract_qty !== undefined || d.qc_qty !== undefined || d.postil !== undefined) {
                        const sp = {pid: d.pid, lid: d.lid, contract_qty: d.contract_qty, qc_qty: d.qc_qty, postil: d.postil};
                        const osp = this._.find(orgStagePos, function (p) { return p.pid === d.pid; });
                        if (precision) {
                            this.ctx.helper.checkFieldPrecision(sp, this.qtyFields, precision.value);
                        }
                        if (osp && osp.times === this.ctx.stage.curTimes && osp.order === this.ctx.stage.curOrder) {
                            await transaction.update(this.tableName, d, {where: {id: osp.id}});
                        } else {
                            sp.tid = this.ctx.tender.id;
                            sp.sid = this.ctx.stage.id;
                            sp.said = this.ctx.session.sessionUser.accountId;
                            sp.times = this.ctx.stage.curTimes;
                            sp.order = this.ctx.stage.curOrder;
                            await transaction.insert(this.tableName, sp);
                        }
                    }
                    result.pos.push(d.pid);
                    if ((d.sgfh_qty !== undefined || d.qtcl_qty !== undefined || d.sjcl_qty !== undefined ||
                            d.contract_qty === undefined || d.qc_qty === undefined) && (result.ledger.indexOf(d.lid) === -1)) {
                        result.ledger.push(d.lid);
                    }
                }
                for (const lid of ledgerCalc) {
                    await this.ctx.service.ledger.calc(this.ctx.tender.id, lid, transaction);
                }
                for (const lid of result.ledger) {
                    await this.ctx.service.stageBills.calc(this.ctx.tender.id, this.ctx.stage.id, lid, transaction);
                }
                await transaction.commit();
                return result;
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
        }

        /**
         * 删除部位明细数据（仅供updateStageData调用）
         *
         * @param transaction - 事务
         * @param data - 删除的部位明细(允许一次提醒多条，也允许跨清单（但前端操作不允许）)
         * @returns {Promise<{}>}
         * @private
         */
        async _deleteStagePosData(data) {
            const pos = await this.ctx.service.pos.getPosData({tid: this.ctx.tender.id, id: data});
            const result = { pos: data, isDeletePos: true};
            if (pos instanceof Array) {
                for (const p of pos) {
                    if (p.add_stage !== this.ctx.stage.id /*|| p.add_times !== this.ctx.stage.curTimes || p.add_user !== this.ctx.session.sessionUser.accountId*/) {
                        throw '不可删除该数据';
                    }
                }
            } else if (pos.add_stage !== this.ctx.stage.id /*|| pos.add_times !== this.ctx.stage.curTimes || pos.add_user !== this.ctx.session.sessionUser.accountId*/) {
                throw '不可删除该数据';
            }
            const ledgerIds = this._.map(pos, 'lid');

            const transaction = await this.db.beginTransaction();
            try {
                // 删除部位明细
                await transaction.delete(this.ctx.service.pos.tableName, {tid: this.ctx.tender.id, id: data});
                for (const lid of ledgerIds) {
                    await this.ctx.service.ledger.calc(this.ctx.tender.id, lid, transaction);
                }
                // 删除部位明细计量数据
                await transaction.delete(this.tableName, {tid: this.ctx.tender.id, lid: data});
                for (const lid of ledgerIds) {
                    await this.ctx.service.stageBills.calc(this.ctx.tender.id, this.ctx.stage.id, lid, transaction);
                }
                await transaction.commit();
                // 获取需要更新的数据
                result.ledger = ledgerIds;
                result.stageUpdate = true;
                return result;
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
        }

        /**
         * 根据前端提交数据，更新并计算
         *
         * @param data
         * @returns {Promise<{ledger: {}, pos: {}}>}
         */
        async updateStageData(data) {
            if ((data.updateType === 'add' || data.upateType === 'delete') && this.ctx.tender.measure_type === measureType.tz) {
                throw '台账模式下，不可在计量中新增或删除部位明细，如需操作，请进行台账修订';
            }
            let refreshData;
            if (data.updateType === 'add') {
                refreshData = await this._addStagePosData(data.updateData);
            } else if (data.updateType === 'update') {
                refreshData = await this._updateStagePosData(data.updateData);
            } else if (data.updateType === 'delete') {
                if (!data.updateData || data.updateData.length === 0) {
                    throw '提交数据错误';
                }
                refreshData = await this._deleteStagePosData(data.updateData);
            } else {
                throw '提交数据错误';
            }

            try {
                const result = {ledger: {}, pos: {}};
                if (refreshData.ledger && refreshData.ledger.length > 0) {
                    result.ledger.bills = await this.ctx.service.ledger.getDataByIds(refreshData.ledger);
                    if (refreshData.stageUpdate) {
                        result.ledger.curStageData = await this.ctx.service.stageBills.getLastestStageData(this.ctx.tender.id, this.ctx.stage.id, refreshData.ledger);
                    }
                }
                if (refreshData.pos) {
                    if (refreshData.isDeletePos) {
                        result.pos.pos = refreshData.pos;
                    } else if (refreshData.pos.length > 0) {
                        result.pos.pos = await this.ctx.service.pos.getPosData({id: refreshData.pos});
                        if (refreshData.stageUpdate) {
                            result.pos.curStageData = await this.getLastestStageData(this.ctx.tender.id, this.ctx.stage.id, {pid: refreshData.pos});
                        }
                    }
                }
                return result;
            } catch(err) {
                throw '获取数据异常，请刷新页面。';
            }
        }

        async updateChangeQuantity(transaction, pos, qty) {
            let orgPos = await this.getLastestStageData(this.ctx.tender.id, this.ctx.stage.id, {pid: pos.id});
            if (orgPos.length > 1) {
                throw '数据错误';
            } else {
                orgPos = orgPos[0];
            }
            if (orgPos && orgPos.times === this.ctx.stage.curTimes && orgPos.order === this.ctx.stage.curOrder) {
                await transaction.update(this.tableName, {id: orgPos.id, qc_qty: qty});
            } else {
                await transaction.insert(this.tableName, {
                    tid: this.ctx.tender.id,
                    sid: this.ctx.stage.id,
                    lid: pos.lid,
                    pid: pos.id,
                    said: this.ctx.session.sessionUser.accountId,
                    times: this.ctx.stage.curTimes,
                    order: this.ctx.stage.curOrder,
                    qc_qty: qty,
                });
            }
            await this.ctx.service.stageBills.calc(this.ctx.tender.id, this.ctx.stage.id, pos.lid, transaction);
        }

        /**
         * 统计清单下部位明细合计
         * @param {Number} tid - 标段id
         * @param {Number} sid - 期id
         * @param {Number} lid - 清单节点id
         * @param transaction - 事务（不为空则在事务中查询，反之在数据库中查询）
         * @returns {Promise<*>}
         */
        async getPosGather(tid, sid, lid, transaction) {
            const calcQtySql = 'SELECT SUM(`contract_qty`) As `contract_qty`, SUM(`qc_qty`) As `qc_qty` FROM (' +
                '  SELECT `contract_qty`, `qc_qty` FROM ' + this.ctx.service.stagePos.tableName + ' As Pos ' +
                '    INNER JOIN (' +
                '      SELECT MAX(`times` * ' + timesLen + ' + `order`) As `flow`, `pid` ' +
                '        FROM ' + this.ctx.service.stagePos.tableName +
                '        WHERE `tid` = ? And sid = ? And `lid` = ? ' +
                '        GROUP BY `pid`' +
                '    ) As MaxFilter ' +
                '    ON (Pos.times * ' + timesLen + ' + Pos.order) = MaxFilter.flow And Pos.pid = MaxFilter.pid ' +
                '    WHERE Pos.tid = ? And Pos.sid = ? And Pos.lid = ?' +
                '  ) As Gather';
            const param = [tid, sid, lid];
            const sqlParam = param.concat(param);
            if (transaction) {
                return await transaction.queryOne(calcQtySql, sqlParam);
            } else {
                return await this.db.queryOne(calcQtySql, sqlParam);
            }
        }
    }

    return StagePos;
};