Calculation/app/service/ledger_audit.js

'use strict';

/**
 * 台账审批流程表
 *
 * @author Mai
 * @date 2018/5/25
 * @version
 */

const auditConst = require('../const/audit').ledger;
const smsTypeConst = require('../const/sms_type');
const SMS = require('../lib/sms');
const SmsAliConst = require('../const/sms_alitemplate');
const wxConst = require('../const/wechat_template');
const shenpiConst = require('../const/shenpi');
const pushType = require('../const/audit').pushType;

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

        /**
         * 获取标段审核人信息
         *
         * @param {Number} tenderId - 标段id
         * @param {Number} auditorId - 审核人id
         * @param {Number} times - 第几次审批
         * @return {Promise<*>}
         */
        async getAuditor(tenderId, auditorId, times = 1) {
            const sql = 'SELECT la.`audit_id`, pa.`name`, pa.`company`, pa.`role`, pa.`mobile`, pa.`telephone`, la.`times`, la.`audit_order`, la.`status`, la.`opinion`, la.`begin_time`, la.`end_time` ' +
                '  FROM ?? AS la Left Join ?? AS pa ON la.`audit_id` = pa.`id`' +
                '  WHERE la.`tender_id` = ? and la.`audit_id` = ? and la.`times` = ?';
            const sqlParam = [this.tableName, this.ctx.service.projectAccount.tableName, tenderId, auditorId, times];
            return await this.db.queryOne(sql, sqlParam);
        }

        async getAuditorByOrder(tenderId, order, times = 1) {
            const sql = 'SELECT la.`audit_id`, pa.`name`, pa.`company`, pa.`role`, pa.`mobile`, pa.`telephone`, la.`times`, la.`audit_order`, la.`status`, la.`opinion`, la.`begin_time`, la.`end_time` ' +
                '  FROM ?? AS la Left Join ?? AS pa ON la.`audit_id` = pa.`id`' +
                '  WHERE la.`tender_id` = ? and la.`audit_order` = ? and la.`times` = ?';
            const sqlParam = [this.tableName, this.ctx.service.projectAccount.tableName, tenderId, order, times];
            return await this.db.queryOne(sql, sqlParam);
        }

        async getLastestAuditor(tenderId, times, status) {
            const sql =
                'SELECT la.`audit_id`, pa.`name`, pa.`company`, pa.`role`, pa.`mobile`, pa.`telephone`,' +
                '    la.`times`, la.`audit_order`, la.`status`, la.`opinion`, la.`begin_time`, la.`end_time` ' +
                '    FROM ' + this.tableName + ' AS la' +
                '    Left Join ' + this.ctx.service.projectAccount.tableName + ' AS pa ON la.`audit_id` = pa.`id`' +
                '  WHERE la.`tender_id` = ? and la.`status` = ? and la.`times` = ?' +
                '  ORDER BY `audit_order` DESC';
            const sqlParam = [tenderId, status, times ? times : 1];
            return await this.db.queryOne(sql, sqlParam);
        }

        /**
         * 获取标段审核人最后一位的名称
         *
         * @param {Number} tenderId - 标段id
         * @param {Number} auditorId - 审核人id
         * @param {Number} times - 第几次审批
         * @return {Promise<*>}
         */
        async getStatusName(tenderId, times) {
            const sql = 'SELECT pa.`name` FROM ?? AS la Left Join ?? AS pa ON la.`audit_id` = pa.`id`' +
                '  WHERE la.`tender_id` = ? and la.`status` != ? ORDER BY la.`times` DESC, la.`audit_order` DESC';
            const sqlParam = [this.tableName, this.ctx.service.projectAccount.tableName, tenderId, auditConst.status.uncheck];
            return await this.db.queryOne(sql, sqlParam);
        }

        /**
         * 获取标段审核列表信息
         *
         * @param {Number} tenderId - 标段id
         * @param {Number} times - 第几次审批
         * @return {Promise<*>}
         */
        async getAuditors(tenderId, times = 1) {
            const sql =
                'SELECT la.`audit_id`, pa.`name`, pa.`company`, pa.`role`, pa.`mobile`, pa.`telephone`, la.`times`, la.`audit_order`, la.`status`, la.`opinion`, la.`begin_time`, la.`end_time`, g.`sort` ' +
                'FROM ?? AS la, ?? AS pa, (SELECT `audit_id`,(@i:=@i+1) as `sort` FROM ??, (select @i:=0) as it WHERE `tender_id` = ? AND `times` = ? GROUP BY `audit_id`) as g ' +
                'WHERE la.`tender_id` = ? and la.`times` = ? and la.`audit_id` = pa.`id` and g.`audit_id` = la.`audit_id` order by la.`audit_order`';
            const sqlParam = [this.tableName, this.ctx.service.projectAccount.tableName, this.tableName, tenderId, times, tenderId, times];
            const result = await this.db.query(sql, sqlParam);
            const sql2 = 'SELECT COUNT(a.`audit_id`) as num FROM (SELECT `audit_id` FROM ?? WHERE `tender_id` = ? AND `times` = ? GROUP BY `audit_id`) as a';
            const sqlParam2 = [this.tableName, tenderId, times];
            const count = await this.db.queryOne(sql2, sqlParam2);
            for (const i in result) {
                result[i].max_sort = count.num;
            }
            return result;
        }

        async getFinalAuditGroup(tenderId, times = 1) {
            const sql =
                'SELECT la.`audit_id`, pa.`name`, pa.`company`, pa.`role`, pa.`mobile`, pa.`telephone`, pa.`sign_path`, la.`times`, la.`tender_id`, Max(la.`audit_order`) as max_order ' +
                '  FROM ?? AS la Left Join ?? AS pa On la.`audit_id` = pa.`id`' +
                '  WHERE la.`tender_id` = ? and la.`times` = ? GROUP BY la.`audit_id` ORDER BY la.`audit_order`';
            const sqlParam = [this.tableName, this.ctx.service.projectAccount.tableName, tenderId, times];
            const result = await this.db.query(sql, sqlParam);
            for (const r of result) {
                const auditor = await this.getDataByCondition({tender_id: tenderId, times: r.times, audit_order: r.max_order});
                r.status = auditor.status;
                r.opinion = auditor.opinion;
                r.begin_time = auditor.begin_time;
                r.end_time = auditor.end_time;
            }
            return result;
        }

        /**
         * 获取标段当前审核人
         *
         * @param {Number} tenderId - 标段id
         * @param {Number} times - 第几次审批
         * @return {Promise<*>}
         */
        async getCurAuditor(tenderId, times = 1) {
            const sql =
                'SELECT la.`audit_id`, pa.`name`, pa.`company`, pa.`role`, pa.`mobile`, pa.`telephone`, la.`times`, la.`audit_order`, la.`status`, la.`opinion`, la.`begin_time`, la.`end_time` ' +
                '  FROM ?? AS la Left Join ?? AS pa On la.`audit_id` = pa.`id`' +
                '  WHERE la.`tender_id` = ? and la.`status` = ? and la.`times` = ?';
            const sqlParam = [this.tableName, this.ctx.service.projectAccount.tableName, tenderId, auditConst.status.checking, times];
            return await this.db.queryOne(sql, sqlParam);
        }

        /**
         * 获取最新审核顺序
         *
         * @param {Number} tenderId - 标段id
         * @param {Number} times - 第几次审批
         * @return {Promise<number>}
         */
        async getNewOrder(tenderId, times = 1) {
            const sql = 'SELECT Max(??) As max_order FROM ?? Where `tender_id` = ? and `times` = ?';
            const sqlParam = ['audit_order', this.tableName, tenderId, times];
            const result = await this.db.queryOne(sql, sqlParam);
            return result && result.max_order ? result.max_order + 1 : 1;
        }

        /**
         * 新增审核人
         *
         * @param {Number} tenderId - 标段id
         * @param {Number} auditorId - 审核人id
         * @param {Number} times - 第几次审批
         * @return {Promise<number>}
         */
        async addAuditor(tenderId, auditorId, times = 1, is_gdzs = 0) {
            const transaction = await this.db.beginTransaction();
            try {
                let newOrder = await this.getNewOrder(tenderId, times);
                // 判断是否存在固定终审，存在则newOrder - 1并使终审order+1
                newOrder = is_gdzs === 1 ? newOrder - 1 : newOrder;
                if (is_gdzs) await this._syncOrderByDelete(transaction, tenderId, newOrder, times, '+');
                const data = {
                    tender_id: tenderId,
                    audit_id: auditorId,
                    times,
                    audit_order: newOrder,
                    status: auditConst.status.uncheck,
                };
                const result = await transaction.insert(this.tableName, data);
                await transaction.commit();
                return (result.effectRows = 1);
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
            return false;
        }

        /**
         * 移除审核人时，同步其后审核人order
         * @param transaction - 事务
         * @param {Number} tenderId - 标段id
         * @param {Number} auditorId - 审核人id
         * @param {Number} times - 第几次审批
         * @return {Promise<*>}
         * @private
         */
        async _syncOrderByDelete(transaction, tenderId, order, times, selfOperate = '-') {
            this.initSqlBuilder();
            this.sqlBuilder.setAndWhere('tender_id', {
                value: tenderId,
                operate: '=',
            });
            this.sqlBuilder.setAndWhere('audit_order', {
                value: order,
                operate: '>=',
            });
            this.sqlBuilder.setAndWhere('times', {
                value: times,
                operate: '=',
            });
            this.sqlBuilder.setUpdateData('audit_order', {
                value: 1,
                selfOperate: selfOperate,
            });
            const [sql, sqlParam] = this.sqlBuilder.build(this.tableName, 'update');
            const data = await transaction.query(sql, sqlParam);

            return data;
        }

        /**
         * 移除审核人
         *
         * @param {Number} tenderId - 标段id
         * @param {Number} auditorId - 审核人id
         * @param {Number} times - 第几次审批
         * @return {Promise<boolean>}
         */
        async deleteAuditor(tenderId, auditorId, times = 1) {
            const transaction = await this.db.beginTransaction();
            try {
                const condition = { tender_id: tenderId, audit_id: auditorId, times };
                const auditor = await this.getDataByCondition(condition);
                if (!auditor) {
                    throw '该审核人不存在';
                }
                await this._syncOrderByDelete(transaction, tenderId, auditor.audit_order, times);
                await transaction.delete(this.tableName, condition);
                await transaction.commit();
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
            return true;
        }

        /**
         * 备份
         * @param {Object} revise - 修订
         * @returns {Promise<void>}
         * @private
         */
        async backupLedgerHistoryFile() {
            const timestamp = (new Date()).getTime();

            const billsHis = `${this.ctx.session.sessionProject.id}/${this.ctx.tender.id}/bills${timestamp}.json`;
            const bills = await this.ctx.service.ledger.getData(this.ctx.tender.id);
            await this.ctx.app.hisOss.put(this.ctx.app.config.hisOssPath + billsHis, Buffer.from(JSON.stringify(bills), 'utf8'));

            const posHis = `${this.ctx.session.sessionProject.id}/${this.ctx.tender.id}/pos${timestamp}.json`;
            const pos = await this.ctx.service.pos.getAllDataByCondition({tid: this.ctx.tender.id});
            await this.ctx.app.hisOss.put(this.ctx.app.config.hisOssPath + posHis, Buffer.from(JSON.stringify(pos), 'utf8'));

            return [billsHis, posHis];
        }

        /**
         * 开始审批
         *
         * @param {Number} tenderId - 标段id
         * @param {Number} times - 第几次审批
         * @return {Promise<boolean>}
         */
        async start(tenderId, times = 1) {
            const audit = await this.getDataByCondition({ tender_id: tenderId, times, audit_order: 1 });
            if (!audit) {
                if(this.ctx.tender.info.shenpi.ledger === shenpiConst.sp_status.gdspl) {
                    throw '请联系管理员添加审批人';
                } else {
                    throw '请先选择审批人，再上报数据';
                }
            }
            const sum = await this.ctx.service.ledger.addUp({ tender_id: tenderId /* , is_leaf: true*/ });

            // 拷贝备份台账数据
            const [billsHis, posHis] = await this.backupLedgerHistoryFile();

            const transaction = await this.db.beginTransaction();
            try {
                await transaction.update(this.tableName, {
                    id: audit.id,
                    status: auditConst.status.checking,
                    begin_time: new Date(),
                });
                await transaction.update(this.ctx.service.tender.tableName, {
                    id: tenderId,
                    ledger_status: auditConst.status.checking,
                    total_price: sum.total_price,
                    deal_tp: sum.deal_tp,
                    bills_file: billsHis,
                    pos_file: posHis,
                });

                // 添加短信通知-需要审批提醒功能
                await this.ctx.helper.sendAliSms(audit.audit_id, smsTypeConst.const.TZ, smsTypeConst.judge.approval.toString(), SmsAliConst.template.ledger_check);
                // 微信模板通知
                const wechatData = {
                    status: wxConst.status.check,
                    tips: wxConst.tips.check,
                    begin_time: Date.parse(new Date()),
                };
                await this.ctx.helper.sendWechat(audit.audit_id, smsTypeConst.const.TZ, smsTypeConst.judge.approval.toString(), wxConst.template.ledger, wechatData);

                await transaction.commit();
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
            return true;
        }

        /**
         * 审批
         * @param {Number} tenderId - 标段id
         * @param {auditConst.status.checked|auditConst.status.checkNo} checkType - 审批结果
         * @param {String} opinion 审批意见
         * @param {Number} times - 第几次审批
         * @return {Promise<void>}
         */
        async check(tenderId, checkType, opinion, times = 1) {
            if (checkType !== auditConst.status.checked && checkType !== auditConst.status.checkNo) {
                throw '提交数据错误';
            }
            const pid = this.ctx.session.sessionProject.id;
            const transaction = await this.db.beginTransaction();
            try {
                // 整理当前流程审核人状态更新
                const time = new Date();
                const audit = await this.getDataByCondition({
                    tender_id: tenderId,
                    times,
                    status: auditConst.status.checking,
                });
                if (!audit) {
                    throw '审核数据错误';
                }

                // 获取审核人列表
                const auditList = await this.getAuditors(tenderId, times);
                // 添加推送
                const noticeContent = await this.getNoticeContent(audit.tender_id, pid, audit.audit_id);
                const records = [
                    {
                        pid,
                        type: pushType.ledger,
                        uid: this.ctx.tender.data.user_id,
                        status: checkType,
                        content: noticeContent,
                    },
                ];
                auditList.forEach(audit => {
                    records.push({
                        pid,
                        type: pushType.ledger,
                        uid: audit.audit_id,
                        status: checkType,
                        content: noticeContent,
                    });
                });
                await transaction.insert('zh_notice', records);
                // 更新当前审核流程
                await transaction.update(this.tableName, { id: audit.id, status: checkType, opinion, end_time: time });
                const begin_audit = await this.getDataByCondition({
                    tender_id: tenderId,
                    audit_order: 1,
                });
                if (checkType === auditConst.status.checked) {
                    const nextAudit = await this.getDataByCondition({
                        tender_id: tenderId,
                        times,
                        audit_order: audit.audit_order + 1,
                    });
                    // 无下一审核人表示，审核结束
                    if (nextAudit) {
                        await transaction.update(this.tableName, {
                            id: nextAudit.id,
                            status: auditConst.status.checking,
                            begin_time: time,
                        });
                        await this.ctx.helper.sendAliSms(nextAudit.audit_id, smsTypeConst.const.TZ, smsTypeConst.judge.approval.toString(), SmsAliConst.template.ledger_check);
                        // 微信模板通知
                        const wechatData = {
                            status: wxConst.status.check,
                            tips: wxConst.tips.check,
                            begin_time: Date.parse(begin_audit.begin_time),
                        };
                        await this.ctx.helper.sendWechat(nextAudit.audit_id, smsTypeConst.const.TZ, smsTypeConst.judge.approval.toString(), wxConst.template.ledger, wechatData);
                    } else {
                        // 同步标段信息
                        await transaction.update(this.ctx.service.tender.tableName, {
                            id: tenderId,
                            ledger_status: checkType,
                        });
                        await this.ctx.service.tenderTag.saveTenderTag(tenderId, {ledger_time: new Date()}, transaction);
                        const users = this._.pull(this._.map(auditList, 'audit_id'), audit.id);
                        await this.ctx.helper.sendAliSms(users, smsTypeConst.const.TZ, smsTypeConst.judge.result.toString(), SmsAliConst.template.ledger_result, {
                            status: SmsAliConst.status.success,
                        });
                        // 微信模板通知
                        const wechatData = {
                            status: wxConst.status.success,
                            tips: wxConst.tips.success,
                            begin_time: Date.parse(begin_audit.begin_time),
                        };
                        await this.ctx.helper.sendWechat(users, smsTypeConst.const.TZ, smsTypeConst.judge.result.toString(), wxConst.template.ledger, wechatData);
                    }
                } else {
                    // 同步标段信息
                    await transaction.update(this.ctx.service.tender.tableName, {
                        id: tenderId,
                        ledger_times: times + 1,
                        ledger_status: checkType,
                    });
                    // 拷贝新一次审核流程列表
                    const auditors = await this.getAllDataByCondition({
                        where: { tender_id: tenderId, times },
                        columns: ['tender_id', 'audit_order', 'audit_id'],
                    });
                    for (const a of auditors) {
                        a.times = times + 1;
                        a.status = auditConst.status.uncheck;
                    }
                    await transaction.insert(this.tableName, auditors);

                    const users = this._.pull(this._.map(auditList, 'audit_id'), audit.id);
                    await this.ctx.helper.sendAliSms(users, smsTypeConst.const.TZ, smsTypeConst.judge.result.toString(), SmsAliConst.template.ledger_result, {
                        status: SmsAliConst.status.back,
                    });
                    // 微信模板通知
                    const wechatData = {
                        status: wxConst.status.back,
                        tips: wxConst.tips.back,
                        begin_time: Date.parse(begin_audit.begin_time),
                    };
                    await this.ctx.helper.sendWechat(audit.audit_id, smsTypeConst.const.TZ, smsTypeConst.judge.result.toString(), wxConst.template.ledger, wechatData);
                }

                await transaction.commit();
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
        }

        /**
         * 获取审核人需要审核的标段列表
         *
         * @param auditorId
         * @return {Promise<*>}
         */
        async getAuditTender(auditorId) {
            const sql =
                'SELECT la.`audit_id`, la.`times`, la.`audit_order`, la.`begin_time`, la.`end_time`, t.`id`, t.`name`, t.`project_id`, t.`type`, t.`user_id`, t.`ledger_status` ' +
                '  FROM ?? AS la Left Join ?? AS t ON la.`tender_id` = t.`id` ' +
                '  WHERE ((la.`audit_id` = ? and la.`status` = ?) OR (t.`user_id` = ? and t.`ledger_status` = ? and la.`status` = ? and la.`times` = (t.`ledger_times`-1)))' +
                '    ORDER BY la.`begin_time` DESC';
            const sqlParam = [
                this.tableName,
                this.ctx.service.tender.tableName,
                auditorId,
                auditConst.status.checking,
                auditorId,
                auditConst.status.checkNo,
                auditConst.status.checkNo,
            ];
            return await this.db.query(sql, sqlParam);
        }

        /**
         * 获取 某时间后 审批进度 更新的台账
         * @param {Integer} pid - 项目id
         * @param {Integer} uid - 查询人id
         * @param {Date} noticeTime - 查询事件
         * @return {Promise<*>}
         */
        async getNoticeTender(pid, uid, noticeTime) {
            let notice = await this.db.select('zh_notice', {
                where: { pid, type: pushType.ledger, uid },
                orders: [['create_time', 'desc']],
                limit: 10,
                offset: 0,
            });
            notice = notice.map(v => {
                const extra = JSON.parse(v.content);
                delete v.content;
                return { ...v, ...extra };
            });
            return notice;
        }

        /**
         * 用于添加推送所需的content内容
         * @param {Number} id  标段id
         * @param {Number} pid 项目id
         * @param {Number} uid 审核人id
         */
        async getNoticeContent(id, pid, uid) {
            const noticeSql =
                'SELECT * FROM (SELECT ' +
                '  t.`id` As `tid`, t.`name`,  pa.`name` As `su_name`, pa.role As `su_role`' +
                '  FROM (SELECT * FROM ?? WHERE `id` = ? ) As t' +
                '  LEFT JOIN ?? As pa ON pa.`id` = ?' +
                '  WHERE  t.`project_id` = ? ) as new_t GROUP BY new_t.`tid`';
            const noticeSqlParam = [this.ctx.service.tender.tableName, id, this.ctx.service.projectAccount.tableName, uid, pid];
            const content = await this.db.query(noticeSql, noticeSqlParam);
            return content.length ? JSON.stringify(content[0]) : '';
        }

        /**
         * 获取审核人流程列表
         * @param {Number} tender_id - 标段id
         * @param {Number} times 审核次数
         * @return {Promise<Array>} 查询结果集
         */
        async getAuditGroupByList(tender_id, times = 1) {
            const sql =
                'SELECT la.`audit_id`, pa.`name`, pa.`company`, pa.`role`, la.`times`, la.`tender_id`, la.`audit_order` ' +
                '  FROM ?? AS la Left Join ?? AS pa On la.`audit_id` = pa.`id`' +
                '  WHERE la.`tender_id` = ? and la.`times` = ? GROUP BY la.`audit_id` ORDER BY la.`audit_order`';
            const sqlParam = [this.tableName, this.ctx.service.projectAccount.tableName, tender_id, times];
            return await this.db.query(sql, sqlParam);
        }

        /**
         * 获取审核人流程列表(包括原报)
         * @param {Number} tender_id - 标段id
         * @param {Number} times 审核次数
         * @return {Promise<Array>} 查询结果集(包括原报)
         */
        async getAuditorsWithOwner(tender_id, times = 1) {
            const result = await this.getAuditGroupByList(tender_id, times);
            const sql =
                'SELECT pa.`id` As audit_id, pa.`name`, pa.`company`, pa.`role`, ? As times, ? As tender_id, 0 As `audit_order`' +
                '  FROM ' + this.ctx.service.tender.tableName + ' As s' +
                '  LEFT JOIN ' + this.ctx.service.projectAccount.tableName + ' As pa' +
                '  ON s.user_id = pa.id' +
                '  WHERE s.id = ?';
            const sqlParam = [times, tender_id, tender_id];
            const user = await this.db.queryOne(sql, sqlParam);
            result.unshift(user);
            return result;
        }

        async updateNewAuditList(tender, newIdList) {
            const transaction = await this.db.beginTransaction();
            try {
                // 先删除旧的审批流，再添加新的
                await transaction.delete(this.tableName, { tender_id: tender.id, times: tender.ledger_times });
                const newAuditors = [];
                let order = 1;
                for (const aid of newIdList) {
                    newAuditors.push({
                        tender_id: tender.id, audit_id: aid,
                        times: tender.ledger_times, audit_order: order, status: auditConst.status.uncheck,
                    });
                    order++;
                }
                if(newAuditors.length > 0) await transaction.insert(this.tableName, newAuditors);
                await transaction.commit();
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
        }

        async updateLastAudit(tender, auditList, lastId) {
            const transaction = await this.db.beginTransaction();
            try {
                // 先判断auditList里的aid是否与lastId相同，相同则删除并重新更新order
                const idList = this._.map(auditList, 'audit_id');
                let order = idList.length + 1;
                if (idList.indexOf(lastId) !== -1) {
                    await transaction.delete(this.tableName, { tender_id: tender.id, times: tender.ledger_times, audit_id: lastId });
                    const audit = this._.find(auditList, { 'audit_id': lastId });
                    // 顺移之后审核人流程顺序
                    await this._syncOrderByDelete(transaction, tender.id, audit.audit_order, tender.ledger_times);
                    order = order - 1;
                }

                // 添加终审
                const newAuditor = {
                    tender_id: tender.id, audit_id: lastId,
                    times: tender.ledger_times, audit_order: order, status: auditConst.status.uncheck,
                };
                await transaction.insert(this.tableName, newAuditor);
                await transaction.commit();
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
        }
    }

    return LedgerAudit;
};