Calculation/app/service/stage_pay.js

'use strict';

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

const timesLen = require('../const/audit').stage.timesLen;
const payConst = require('../const/deal_pay');
const auditConst = require('../const/audit');

module.exports = app => {
    class StagePay extends app.BaseService {
        /**
         * 构造函数
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        constructor(ctx) {
            super(ctx);
            this.tableName = 'stage_pay';
        }

        /**
         * 查询 某期 某轮审批 某审核人数据
         *
         * @param {Number} pid - 合同支付id
         * @param {Number} sid - 期id
         * @param {Number} times - 期第几轮审批
         * @param {Number} order - 审核人顺序
         * @param {Number|Array|Null} pid - 部位明细id - 为空则查询全部
         * @returns {Promise<*>}
         */
        async getAuditorStagePay(pid, sid, times, order) {
            const pidSql = pid instanceof Array ? ' And SP.`pid` in (' + pid.join(',') + ')' : 'And SP.`pid` = ' + pid;
            const sql = 'SELECT SP.*, P.`csorder`, P.`cstimes`, P.`csaorder`, P.`order`, P.uid, P.minus, P.ptype, P.sprice, P.sexpr, P.rprice, P.rexpr, P.is_yf, P.dl_type, P.dl_count, P.dl_tp_type, P.dl_tp ' +
                '  FROM ' + this.tableName + ' As SP ' +
                '  LEFT JOIN ' + this.ctx.service.pay.tableName + ' As P ' +
                '  ON SP.pid = P.id' +
                '  WHERE SP.`sid` = ? AND SP.`stimes` = ? AND SP.`sorder` = ? AND SP.`pid` = P.`id` AND (P.`valid` || SP.porder > 0)' + pidSql +
                '  ORDER BY P.`order`';
            const sqlParam = [sid, times, order, pid];
            if (pid instanceof Array) {
                return await this.db.query(sql, sqlParam);
            } else {
                return await this.db.queryOne(sql, sqlParam);
            }
        }

        /**
         * 查询 某期 某轮审批 某审核人数据
         * @param {Number} sid - 期id
         * @param {Number} times - 期第几轮审批
         * @param {Number} order - 审核人顺序
         * @param {Number|Array|Null} pid - 部位明细id - 为空则查询全部
         * @returns {Promise<*>}
         */
        async getAuditorStageData(sid, times, order) {
            const sql = 'SELECT SP.*,' +
                '    P.`csorder`, P.`cstimes`, P.`csaorder`, P.`order`, P.uid, P.minus, P.ptype, P.sprice, P.sexpr,' +
                '    P.rprice, P.rexpr, P.is_yf, P.dl_type, P.dl_count, P.dl_tp_type, P.dl_tp, P.name as pName ' +
                '  FROM ' + this.tableName + ' As SP ' +
                '  LEFT JOIN ' + this.ctx.service.pay.tableName + ' As P ' +
                '  ON SP.pid = P.id' +
                '  WHERE SP.`sid` = ? AND SP.`stimes` = ? AND SP.`sorder` = ? AND SP.`pid` = P.`id` AND (P.`valid` || SP.porder > 0)' +
                '  ORDER BY P.`order`';
            const sqlParam = [sid, times, order];
            return await this.db.query(sql, sqlParam);
        }

        /**
         * 新增期时，初始化 期--合同支付 数据
         * @param {Object} stage - 新增的期
         * @param transaction - 事务
         * @returns {Promise<void>}
         */
        async addInitialStageData(stage, transaction) {
            const basesReg = new RegExp(payConst.calcBase.map(x => {return '(' + x.code + ')'}).join('|'));
            const orderReg = /f\d+/im;
            if (!stage) {
                throw '初始化期合同支付数据失败';
            }
            let pays = await this.ctx.service.pay.getAllDataByCondition({where: { tid: this.ctx.tender.id } });
            // 兼容旧项目，无初始化合同支付数据
            if (!pays || pays.length === 0) {
                const result = await this.ctx.service.pay.addDefaultPayData(this.ctx.tender.id, transaction);
                if (!result) {
                    throw '初始化合同支付数据失败';
                }
                pays = await transaction.select(this.ctx.service.pay.tableName, {where: { tid: this.ctx.tender.id } });
            }
            const stagePays = [];
            // 获取截止上期数据
            if (stage.preCheckedStage) {
                const preStage = await this.ctx.service.stage.getDataByCondition({tid: stage.tid, order: stage.preCheckedStage.order});
                if (!preStage) {
                    throw '标段数据有误';
                }
                const prePays = await this.getStageLastestPays(preStage);
                for (const pp of prePays) {
                    const p = this._.find(pays, {id: pp.pid});
                    if (!p.valid) continue;
                    stagePays.push({
                        tid: p.tid, sid: stage.id, pid: p.id,
                        stimes: stage.times, sorder: 0,
                        name: pp.name,
                        expr: (p.ptype === payConst.payType.normal || p.ptype === payConst.payType.sf)
                            ? (basesReg.test(pp.expr) || orderReg.test(pp.expr) ? pp.expr : null)
                            : (p.type === payConst.wc ? pp.expr : null),
                        pause: pp.pause,
                        pre_tp: pp.end_tp,
                        pre_used: pp.pre_used || !this.ctx.helper.checkZero(pp.tp),
                        pre_finish: pp.pre_finish || (pp.rprice ? pp.end_tp === pp.rprice : false),
                        start_stage_order: pp.start_stage_order,
                    });
                }
            } else {
                for (const p of pays) {
                    stagePays.push({
                        tid: p.tid, sid: stage.id, pid: p.id,
                        stimes: stage.times, sorder: 0, expr: p.expr, name: p.name,
                    });
                }
            }
            let result;
            if (transaction) {
                result = await transaction.insert(this.tableName, stagePays);
            } else {
                result = await this.db.insert(this.tableName, stagePays);
            }
            return result.affectedRows === stagePays.length;
        }
        async reInitialStageData(preStage, stage, transaction) {
            if (!stage || !preStage || !transaction) throw '检查合同支付数据失败';

            const basesReg = new RegExp(payConst.calcBase.map(x => {return '(' + x.code + ')'}).join('|'));
            const orderReg = /f\d+/im;

            let pays = await this.ctx.service.pay.getAllDataByCondition({where: { tid: this.ctx.tender.id } });
            const stagePays = [];
            const prePays = await this.getStageLastestPays(preStage);
            for (const pp of prePays) {
                console.log(pp);
                const p = this._.find(pays, {id: pp.pid});
                if (!p.valid) continue;
                stagePays.push({
                    tid: p.tid, sid: stage.id, pid: p.id,
                    stimes: stage.times, sorder: 0,
                    name: pp.name,
                    expr: (p.ptype === payConst.payType.normal || p.ptype === payConst.payType.sf)
                        ? (basesReg.test(pp.expr) || orderReg.test(pp.expr) ? pp.expr : null)
                        : (p.type === payConst.wc ? pp.expr : null),
                    pause: pp.pause,
                    pre_tp: pp.end_tp,
                    pre_used: pp.pre_used || !this.ctx.helper.checkZero(pp.tp),
                    pre_finish: pp.pre_finish || (pp.rprice ? pp.end_tp === pp.rprice : false),
                    start_stage_order: pp.start_stage_order,
                });
            }
            await transaction.delete(this.tableName, { sid: stage.id });
            await transaction.insert(this.tableName, stagePays);
        }

        async getStagePay(stage, pid) {
            return await this.getAuditorStagePay(pid, stage.id, stage.curTimes, stage.curOrder);
        }

        async resortStagePays(stage, stagePays) {
            if (stage.status !== auditConst.stage.status.checked) return;
            stagePays.sort((x, y) => { return x.porder - y.porder; });
        }

        /**
         * 获取某期合同支付数据
         *
         * @param {Object} stage - 期数据(通过StageController._getStageData()获取)
         * @returns {Promise<*>}
         */
        async getStagePays(stage) {
            const result = await this.getAuditorStageData(stage.id, stage.curTimes, stage.curOrder);
            this.resortStagePays(stage, result);
            return result;
        }

        /**
         * 获取某期最后数据(不限制该期是否已经审批通过)
         *
         * @param {Number} stage - 期数据(通过StageController._getStageData()获取)
         * @returns {Promise<*>}
         */
        async getStageLastestPays(stage) {
            const sql = 'SELECT SP.*, P.`order`, P.uid, P.minus, P.ptype, P.sprice, P.sexpr, P.rprice, P.rexpr, P.is_yf, P.dl_type, P.dl_count, P.dl_tp_type, P.dl_tp ' +
                '  FROM ' + this.tableName + ' As SP' +
                '  INNER JOIN ' + this.ctx.service.pay.tableName + ' As P ON SP.pid = P.id' +
                '  INNER JOIN ( ' +
                '    SELECT MAX(`stimes` * ' + timesLen + ' + `sorder`) As `sprogress` ' +
                '      FROM ' + this.tableName +
                '      WHERE `sid` = ? ' +
                '      GROUP BY `sid`) As M ON (SP.`stimes` * ' + timesLen + ' + SP.`sorder`) = M.`sprogress`' +
                '  WHERE SP.`sid` = ? AND (P.`valid` || SP.porder > 0)' +
                '  ORDER BY P.`order`';
            const sqlParam = [stage.id, stage.id];
            const result = await this.db.query(sql, sqlParam);
            this.resortStagePays(stage, result);
            return result;
        }

        /**
         * 同步新增 (仅供合同支付新增时调用)
         * @param {Object} pay - 合同支付项数据
         * @param transaction - 新增合同支付的事务
         * @returns {Promise<{tid, sid: number|*, pid, stimes: number|*, sorder: number|*}>}
         */
        async syncAdd(pay, transaction) {
            const stagePay = {
                tid: pay.tid,
                sid: pay.csid,
                pid: pay.id,
                stimes: pay.cstimes,
                sorder: pay.csaorder,
            };
            const result = await transaction.insert(this.tableName, stagePay);
            if (result.affectedRows !== 1) {
                throw '新增数据失败';
            }
            stagePay.id = result.insertId;
            return stagePay;
        }

        /**
         * 保存本期金额/表达式
         * @param data
         * @returns {Promise<void>}
         */
        async save(saveData) {
            const datas = saveData instanceof Array ? saveData : [saveData], updateDatas = [];
            const stagePays = await this.getStagePay(this.ctx.stage, this._.map(datas, 'pid'));
            for (const data of datas) {
                const stagePay = stagePays.find(x => {
                    return x.pid === data.pid;
                });
                const updateData = {id: stagePay.id};
                if (data.name !== undefined) { updateData.name = data.name }
                if (data.expr !== undefined) { updateData.expr = data.expr }
                if (data.tp !== undefined) { updateData.tp = data.tp; updateData.end_tp = this.ctx.helper.add(data.tp, data.pre_tp); }
                if (data.pause !== undefined) { updateData.pause = data.pause }
                if (data.postil !== undefined) updateData.postil = data.postil;
                updateDatas.push(updateData);
            }
            const result = await this.db.updateRows(this.tableName, updateDatas);
            if (result.affectedRows !== updateDatas.length) {
                throw '保存数据失败';
            }
        }

        /**
         * 计算
         * @param {object} stage - 期数据
         * @param {object} transaction - 事务
         * @return {Promise<Array>} 计算结果（应付和实付数据）
         */
        async calcAllStagePays(stage, transaction) {
            if (!stage) throw '计算数据错误';

            const stagePays = await this.getStagePays(stage);
            const PayCalculator = require('../lib/pay_calc');
            const payCalculator = new PayCalculator(this.ctx, stage, this.ctx.tender.info);
            await payCalculator.calculateAll(stagePays);
            const srUpdate = [], update = [];
            for (const sp of stagePays) {
                update.push({
                    id: sp.id,
                    tp: sp.tp,
                    end_tp: sp.end_tp,
                    start_stage_order: sp.start_stage_order && sp.start_stage_order < stage.order
                        ? sp.start_stage_order
                        : (this.ctx.helper.checkZero(sp.tp) ? null : stage.order),
                });
                srUpdate.push({
                    id: sp.pid,
                    sprice: sp.sprice,
                    rprice: sp.rprice,
                });
            }
            const conn = transaction || await this.db.beginTransaction();
            try {
                await conn.updateRows(this.tableName, update);
                if (srUpdate.length > 0) {
                    await conn.updateRows(this.ctx.service.pay.tableName, srUpdate);
                }
                if (!transaction) await conn.commit();
            } catch (err) {
                if (!transaction) await conn.rollback();
                throw '计算合同支付数据错误';
            }
            const yf = this._.find(stagePays, {ptype: payConst.payType.yf});
            const sf = this._.find(stagePays, {ptype: payConst.payType.sf});
            return [yf, sf, stagePays];
        }

        async getSpecialTotalPrice(stage) {
            if (!stage) throw '计算数据错误';
            const stagePays = await this.getStagePays(stage);
            const PayCalculator = require('../lib/pay_calc');
            const tenderInfo = await this.ctx.service.tenderInfo.getTenderInfo(stage.tid);
            const payCalculator = new PayCalculator(this.ctx, stage, tenderInfo);
            await payCalculator.calculateAll(stagePays);
            const yf = this._.find(stagePays, {ptype: payConst.payType.yf});
            const sf = this._.find(stagePays, {ptype: payConst.payType.sf});
            return { yf: yf ? yf.tp : 0, sf: sf ? sf.tp : 0 };
        }

        async getHistorySf(stage) {
            if (!stage) return 0;
            const stagePays = stage.status === auditConst.stage.status.checked
                ? await this.getStageLastestPays(stage)
                : await this.getStagePays(stage);
            const sf = this._.find(stagePays, { ptype: payConst.payType.sf });
            return sf;
        }

        /**
         * 拷贝上一操作人数据 为 下一操作人数据
         * @param {object} stage - 期数据
         * @param {int} times - 下一操作人 该期第几次
         * @param {int} order - 下一操作人顺序
         * @param {object} transaction - 事务
         * @return {Promise<*>} 初始化sql执行结果
         */
        async copyAuditStagePays(stage, times, order, transaction, curTimes = stage.curTimes, curOrder = stage.curOrder) {
            if (!stage || !transaction || !times || order === undefined) {
                throw '数据错误';
            }
            const sql = 'INSERT INTO ?? (`tid`, `sid`, `pid`, `stimes`, `sorder`, `name`, `tp`, `expr`, `pause`,' +
                        '    `pre_tp`, `end_tp`, `pre_used`, `pre_finish`, `start_stage_order`, `postil`) ' +
                        '  SELECT SP.`tid`, SP.`sid`, SP.`pid`, ?, ?, SP.name, SP.`tp`, SP.`expr`, SP.`pause`,' +
                        '     SP.`pre_tp`, SP.`end_tp`, SP.`pre_used`, SP.`pre_finish`, SP.`start_stage_order`, SP.`postil` ' +
                        '  FROM ?? As SP' +
                        '  WHERE SP.`sid` = ? AND SP.`stimes` = ? AND SP.`sorder` = ?';
            const sqlParam = [this.tableName, times, order, this.tableName, stage.id, curTimes, curOrder];
            return await transaction.query(sql, sqlParam);
        }

        /**
         * 删除操作人数据
         * @param stage - 期数据
         * @param times - 操作人 该期第几次
         * @param order - 操作人顺序
         * @param transaction - 事务
         * @returns {Promise<*>}
         */
        async deleteAuditStagePays(stage, times, order, transaction) {
            if (!stage || !transaction || !times || order === undefined) {
                throw '数据错误';
            }
            return await transaction.delete(this.tableName, { sid: stage.id, stimes: times, sorder: order });
        }

        async getLastestPayId(id) {
            const info = await this.getDataById(id);
            const sql = 'SELECT SP.* FROM ?? As SP WHERE SP.`sid` = ? AND SP.`pid` = ? ORDER BY SP.`stimes` DESC, SP.`sorder` DESC';
            const sqlParam = [this.tableName, info.sid, info.pid];
            const lst = await this.db.queryOne(sql, sqlParam);
            if (!lst || !lst.id) throw '数据错误';
            return lst.id;
        }

        /**
         * 删除审批流程时，拷贝数据
         * @param {object} stage - 期数据
         * @param {int} times - 拷贝至 该期第几次
         * @param {int} order - 拷贝至 槽作人顺序
         * @param {int} copyTimes - 源 该期第几次
         * @param {int} copyOrder - 源 操作人顺序
         * @param {object} transaction - 事务
         * @return {Promise<*>} 初始化sql执行结果
         */
        async copyStagePays4DeleteTimes(stage, times, order, copyTimes, copyOrder, transaction) {
            const sql = 'INSERT INTO ?? (`tid`, `sid`, `pid`, `stimes`, `sorder`, `name`, `tp`, `expr`, `pause`,' +
                '    `pre_tp`, `end_tp`, `pre_used`, `pre_finish`, `start_stage_order`) ' +
                '  SELECT SP.`tid`, SP.`sid`, SP.`pid`, ?, ?, SP.name, SP.`tp`, SP.`expr`, SP.`pause`,' +
                '     SP.`pre_tp`, SP.`end_tp`, SP.`pre_used`, SP.`pre_finish`, SP.`start_stage_order` ' +
                '  FROM ?? As SP, ?? As P ' +
                '  WHERE SP.`sid` = ? AND SP.`stimes` = ? AND SP.`sorder` = ? And SP.`pid` = P.`id` And P.`valid`';
            const sqlParam = [this.tableName, times, order, this.tableName, this.ctx.service.pay.tableName,
                stage.id, copyTimes, copyOrder];
            return await transaction.query(sql, sqlParam);
        }

        _splitExprByOrder(expr) {
            const orderParam = [...expr.matchAll(/f\d+/ig)];
            if (orderParam.length === 0) return [false, expr];

            const exprPart = [];
            for (const [i, op] of orderParam.entries()) {
                if (i === 0) {
                    exprPart.push(expr.substring(0, op.index));
                } else {
                    const preOp = orderParam[i-1];
                    exprPart.push(expr.substring(preOp.index + preOp[0].length, op.index));
                }
                exprPart.push(op[0]);
                if (i === orderParam.length - 1) exprPart.push(expr.substring(op.index + op[0].length, expr.length));
            }
            return [true, exprPart];
        }

        _newExprAfterChangeOrder(expr, orderPart1, orderPart2) {
            if (!expr) return [false, expr];
            const [hasOrder, exprPart] = this._splitExprByOrder(expr);
            if (!hasOrder) return [false, expr];

            const newExprPart = [];

            let change = false;
            for (const ep of exprPart) {
                if (ep === orderPart1) {
                    newExprPart.push(orderPart2);
                    change = true;
                } else if (ep === orderPart2) {
                    newExprPart.push(orderPart1);
                    change = true;
                } else {
                    newExprPart.push(ep);
                }
            }
            return [change, newExprPart.join('')];
        }
        /**
         * 交换两个合同支付项的顺序
         * @param {Number} id1 - 合同支付项1的id
         * @param {Number} id2 - 合同支付项1的id
         * @returns {Promise<void>}
         */
        async changeOrder(id1, id2) {
            if (!this.ctx.tender || !this.ctx.stage) throw '数据错误';
            const pay1 = await this.ctx.service.pay.getDataByCondition({tid: this.ctx.tender.id, id: id1});
            const pay2 = await this.ctx.service.pay.getDataByCondition({tid: this.ctx.tender.id, id: id2});
            if (!pay1 || !pay2) throw '数据错误';

            const stagePays = await this.getStagePays(this.ctx.stage);

            const conn = await this.db.beginTransaction();
            try {
                const orderPart1 = `f${pay1.order}`;
                const orderPart2 = `f${pay2.order}`;
                const updateData = [{id: pay1.id, order: pay2.order}, {id: pay2.id, order: pay1.order}];
                const updateStageData = [];
                for (const p of stagePays) {
                    const [change, newExpr] = this._newExprAfterChangeOrder(p.expr, orderPart1, orderPart2);
                    if (change) {
                        updateStageData.push({ condition: { where: { sid: this.ctx.stage.id, pid: p.pid } }, update: { expr: newExpr } });
                    }
                }
                await conn.updateRows(this.ctx.service.pay.tableName, updateData);
                for (const usd of updateStageData) {
                    await conn.update(this.tableName, usd.update, usd.condition);
                }
                await conn.commit();
                return await this.getStagePays(this.ctx.stage);
            } catch (err) {
                await conn.rollback();
                throw err;
            }
        }

        _newExprAfterDelete(expr, orderParts) {
            if (!expr) return [false, expr];
            const [hasOrder, exprPart] = this._splitExprByOrder(expr);
            if (!hasOrder) return [false, expr];

            const newExprPart = [];

            let change = false;
            for (const ep of exprPart) {
                const orderPart = orderParts.find(x => {return x.orgOrder === ep; });
                if (orderPart) {
                    change = true;
                    newExprPart.push(orderPart.newOrder);
                } else {
                    newExprPart.push(ep);
                }
            }
            return [change, newExprPart.join('')];
        }

        async del(id) {
            if (!this.ctx.tender || !this.ctx.stage) throw '数据错误';
            // 检查是否可以删除
            const pay = await this.ctx.service.pay.getDataByCondition({id: id});
            if (!pay) {
                throw '合同支付项不存在';
            } else if (pay.ptype !== payConst.payType.normal) {
                throw '该合同支付项不可删除';
            }

            const stagePays = await this.getStagePays(this.ctx.stage);
            const orderParts = [], updateStageData = [], updateData = [];
            for (const sp of stagePays) {
                if (sp.order === pay.order) {
                    orderParts.push({ orgOrder: `f${sp.order}`, newOrder: '#ref!'});
                } else if (sp.order > pay.order) {
                    orderParts.push({ orgOrder: `f${sp.order}`, newOrder: `f${sp.order-1}`});
                    updateData.push({id: sp.pid, order: sp.order -1 });
                }
            }
            for (const sp of stagePays) {
                const [change, newExpr] = this._newExprAfterDelete(sp.expr, orderParts);
                if (change) {
                    updateStageData.push({ condition: { where: { sid: this.ctx.stage.id, pid: sp.pid } }, update: { expr: newExpr } });
                }
            }

            // 删除合同支付
            const transaction = await this.db.beginTransaction();
            try {
                // 假删除
                const result = await transaction.update(this.ctx.service.pay.tableName, { id: id, valid: false });
                if (result.affectedRows !== 1) throw '删除合同支付项失败';
                if (updateData.length > 0) await transaction.updateRows(this.ctx.service.pay.tableName, updateData);
                for (const usd of updateStageData) {
                    await transaction.update(this.tableName, usd.update, usd.condition);
                }
                await transaction.commit();
                return true;
            } catch(err) {
                await transaction.rollback();
                throw err;
            }
        }

        async cacheOrder(stage, transaction) {
            const sql = `UPDATE ${this.tableName} sp LEFT JOIN ${this.ctx.service.pay.tableName} p ON sp.pid = p.id SET sp.porder = p.\`order\` Where sp.sid = ? AND p.valid`;
            await transaction.query(sql, [stage.id]);
        }

        async clearCacheOrder(stage, transaction) {
            await transaction.update(this.tableName, { porder: 0 }, { where: { sid: stage.id } });
        }

        async refreshNextStagePreTp(transaction, nextStages, prePays) {
            const updateData = [];
            for (const s of nextStages) {
                const curPays = await this.getStageLastestPays(s);
                for (const cp of curPays) {
                    const pp = prePays.find(x => { return x.pid === cp.pid });
                    if (pp) {
                        updateData.push({
                            id: cp.id, pre_tp: pp.end_tp,
                            pre_used: pp.pre_used || !this.ctx.helper.checkZero(pp.tp),
                            pre_finish: pp.pre_finish || (pp.rprice ? pp.end_tp === pp.rprice : false),
                            start_stage_order: pp.start_stage_order,
                        });
                    }
                }
            }
            if (updateData.length > 0) await transaction.updateRows(this.tableName, updateData);
        }
    }

    return StagePay;
};