Calculation/app/service/stage_pay.js

'use strict';

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

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 sql = 'SELECT SP.*, P.`csorder`, P.`cstimes`, P.`csaorder`, P.`order`, P.uid, P.name, 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 ?? As SP, ?? As P ' +
                '  WHERE SP.`sid` = ? AND SP.`stimes` = ? AND SP.`sorder` = ? AND SP.`pid` = P.`id` AND SP.`pid` = ? AND P.`valid`' +
                '  ORDER BY P.`order`';
            const sqlParam = [this.tableName, this.ctx.service.pay.tableName, sid, times, order, pid];
            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.name, 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 ?? As SP, ?? As P ' +
                '  WHERE SP.`sid` = ? AND SP.`stimes` = ? AND SP.`sorder` = ? AND SP.`pid` = P.`id` AND P.`valid`' +
                '  ORDER BY P.`order`';
            const sqlParam = [this.tableName, this.ctx.service.pay.tableName, sid, times, order];
            return await this.db.query(sql, sqlParam);
        }

        /**
         * 新增期时，初始化 期--合同支付 数据
         * @param {Object} stage - 新增的期
         * @param transaction - 事务
         * @returns {Promise<void>}
         */
        async addInitialStageData(stage, transaction) {
            if (!stage) {
                throw '初始化期合同支付数据失败';
            }
            const pays = await this.ctx.service.pay.getAllDataByCondition({where: { tid: this.ctx.tender.id } });
            const stagePays = [];
            for (const p of pays) {
                stagePays.push({
                    tid: p.tid,
                    sid: stage.id,
                    pid: p.id,
                    stimes: stage.times,
                    sorder: 0,
                    expr: p.expr,
                });
            }
            // 获取截止上期数据
            if (stage.order > 1) {
                const preStage = this.ctx.service.stage.getDataByCondition({tid: stage.tid, order: stage.order - 1});
                if (!preStage) {
                    throw '标段数据有误';
                }
                const prePays = this.getStageLastestPays(preStage.id);
                for (const pp of prePays) {
                    const sp = this._.find(stagePays, {pid: pp.pid});
                    sp.pre_total_price = pp.end_total_price;
                }
            }
            let result;
            if (transaction) {
                result = await transaction.insert(this.tableName, stagePays);
            } else {
                result = await this.db.insert(this.tableName, stagePays);
            }
            return result.affectedRows === pays.length;
        }

        async getStagePay(stage, pid) {
            return await this.getAuditorStagePay(pid, stage.id, stage.times, stage.curAuditor ? stage.curAuditor.order : 0);
        }

        /**
         * 获取某期合同支付数据
         *
         * @param {Object} stage - 期数据(通过StageController._getStageData()获取)
         * @returns {Promise<*>}
         */
        async getStagePays(stage) {
            return await this.getAuditorStageData(stage.id, stage.times, stage.curAuditor ? stage.curAuditor.order : 0);
            // const sql = 'SELECT SP.*, P.`order`, P.uid, P.name, 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 ?? As SP, ?? As P ' +
            //     '  WHERE SP.`sid` = ? AND SP.`stimes` = ? AND SP.`sorder` = ? AND SP.`pid` = P.`id` ' +
            //     '  ORDER BY P.`order`';
            // const sqlParam = [this.tableName, this.ctx.service.pay.tableName, stage.id, stage.times, stage.curAuditor ? stage.curAuditor.order : 0];
            // return await this.db.query(sql, sqlParam);
        }

        /**
         * 获取某期最后数据(不限制该期是否已经审批通过)
         *
         * @param {Number} sid - 期id
         * @returns {Promise<*>}
         */
        async getStageLastestPays(sid) {
            const sql = 'SELECT SP.*, P.`order`, P.uid, P.name, 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 ?? As SP, ?? As P, ( ' +
                '    SELECT MAX(`stimes`) As `stimes`, MAX(`sorder`) As `sorder` ' +
                '      FROM ?? ' +
                '      WHERE `sid` = ? ' +
                '      GOURP BY `sid`) As M' +
                '  WHERE SP.`sid` = ? AND SP.`stimes` = M.`stimes` AND SP.`sorder` = M.`sorder` AND SP.`pid` = P.`id` AND P.`valid` = true' +
                '  ORDER BY P.`order`';
            const sqlParam = [this.tableName, this.ctx.service.pay.tableName, this.ctx.service.stage.tableName, this.ctx.service.stageAudit.tableName,
                stage.id, stage.id];
            return await this.db.query(sql, sqlParam);
        }

        /**
         * 同步新增 (仅供合同支付新增时调用)
         * @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(data) {
            const transaction = await this.db.beginTransaction();
            try {
                // 更新数据
                const stagePay = await this.getStagePay(this.ctx.stage, data.pid);
                const updateData = { id: stagePay.id };
                if (data.expr !== undefined) { updateData.expr = data.expr }
                if (data.tp !== undefined) { updateData.tp = data.tp }
                if (data.pause !== undefined) { updateData.pause = data.pause }
                const result = await transaction.update(this.tableName, updateData);
                if (result.affectedRows !== 1) {
                    throw '保存数据失败';
                }
                // 缓存至pay
                if (data.expr !== undefined) {
                    const pr = await transaction.update(this.ctx.service.pay.tableName, {
                        id: data.pid, expr: data.expr
                    });
                    if (pr.affectedRows !== 1) {
                        throw '保存数据失败';
                    }
                }
                await transaction.commit();
            } catch(err) {
                await transaction.rollback();
                throw err;
            }
        }

        /**
         * 计算
         * @param stage
         * @param transaction
         * @returns {Promise<boolean>}
         */
        async calcAllStagePays(stage, transaction) {
            if (!stage || !transaction) {
                throw '计算数据错误';
            }
            const stagePays = await this.getStagePays(stage);
            const PayCalculator = require('../lib/pay_calc');
            const payCalculator = new PayCalculator(this.ctx, this.ctx.tender.info.decimal);
            await payCalculator.calculateAll(stagePays);
            for (const sp of stagePays) {
                await transaction.update(this.tableName, {
                    id: sp.id,
                    tp: sp.tp,
                    end_tp: sp.end_tp
                });
            }
        }

        /**
         * 拷贝上一操作人数据 为 下一操作人数据
         * @param stage - 期数据
         * @param times - 下一操作人 该期第几次
         * @param order - 下一操作人顺序
         * @param transaction - 事务
         * @returns {Promise<*>}
         */
        async copyAuditStagePays(stage, times, order, transaction) {
            console.log(times);
            console.log(order);
            if (!stage || !transaction || !times || !order) {
                throw '数据错误';
            }
            const sql = 'INSERT INTO ?? (`tid`, `sid`, `pid`, `stimes`, `sorder`, `expr`, `pause`, `attachment`, `pre_tp`) ' +
                        '  SELECT SP.`tid`, SP.`sid`, SP.`pid`, ?, ?, SP.`expr`, SP.`pause`, SP.`attachment`, SP.`pre_tp` ' +
                        '  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, stage.times, stage.curAuditor ? stage.curAuditor.order : 0];
            return await transaction.query(sql, sqlParam);
        }
    }

    return StagePay;
};