Calculation/app/service/report_memory.js

'use strict';

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

const StageIm = require('../lib/stage_im');
const imType = require('../const/tender').imType;
const audit = require('../const/audit');
// const path = require('path');
// const fs = require('fs');

const stageImTz = 'mem_stage_im_tz';
const stageImTzBills = 'mem_stage_im_tz_bills';
const stageImZl = 'mem_stage_im_zl';

module.exports = app => {
    class ReportMemory extends app.BaseService {

        /**
         * 构造函数
         *
         * @param {Object} ctx - egg全局context
         * @return {void}
         */
        constructor(ctx) {
            super(ctx);
            this.tableName = 'report_memory';
            // 需要缓存的数据
            this.stageImData = null;
        }

        async _checkTender(tid) {
            if (this.ctx.tender) return;
            const tender = await this.ctx.service.tender.getTender(tid);
            tender.info = await this.ctx.service.tenderInfo.getTenderInfo(tid);
            this.ctx.tender = tender;
        }

        async _checkStage(sid) {
            if (!this.ctx.stage) {
                const status = audit.stage.status;
                const stage = await this.ctx.service.stage.getDataById(sid);
                stage.auditors = await this.ctx.service.stageAudit.getAuditors(stage.id, stage.times);
                stage.curAuditor = await this.ctx.service.stageAudit.getCurAuditor(stage.id, stage.times);

                const accountId = this.ctx.session.sessionUser.accountId, auditorIds = this._.map(stage.auditors, 'aid'), shareIds = [];
                if (accountId === stage.user_id) { // 原报
                    if (stage.curAuditor) {
                        stage.readOnly = stage.curAuditor.aid !== accountId;
                    } else {
                        stage.readOnly = stage.status !== status.uncheck && stage.status !== status.checkNo;
                    }
                    stage.curTimes = stage.times;
                    if (stage.status === status.uncheck || stage.status === status.checkNo) {
                        stage.curOrder = 0;
                    } else if (stage.status === status.checked) {
                        stage.curOrder = this._.max(this._.map(stage.auditors, 'order'));
                    } else {
                        stage.curOrder = stage.curAuditor.aid === accountId ? stage.curAuditor.order : stage.curAuditor.order - 1;
                    }
                } else if (auditorIds.indexOf(accountId) !== -1) { // 审批人
                    if (stage.status === status.uncheck) {
                        throw '您无权查看该数据';
                    }
                    stage.curTimes = stage.status === status.checkNo ? stage.times - 1 : stage.times;
                    if (stage.status === status.checked) {
                        stage.curOrder = this._.max(this._.map(stage.auditors, 'order'));
                    } else if (stage.status === status.checkNo) {
                        const audit = await this.service.stageAudit.getDataByCondition({
                            sid: stage.id, times: stage.times - 1, status: status.checkNo
                        });
                        stage.curOrder = audit.order;
                    } else {
                        stage.curOrder = accountId === stage.curAuditor.aid ? stage.curAuditor.order : stage.curAuditor.order - 1;
                    }
                } else if (shareIds.indexOf(accountId) !== -1) { // 分享人
                    if (stage.status === status.uncheck) {
                        throw '您无权查看该数据';
                    }
                    stage.curTimes = stage.status === status.checkNo ? stage.times - 1 : stage.times;
                    stage.curOrder = stage.status === status.checked ? this._.max(this._.map(stage.auditors, 'order')) : stage.curAuditor.order - 1;
                }

                this.ctx.stage = stage;
                this.ctx.stage.cacheTime = this.ctx.stage.readOnly ? (this.ctx.stage.cache_time_r).getTime(): (this.ctx.stage.cache_time_l).getTime();
            }
        }

        // build-time: 162-384ms, redis-cache: 0-41ms, mysql + IO: 116-146ms
        // 一定程度上算是大Value缓存，数据多了以后：
        // 1. 达到redis内存阈值时，数据会swap到磁盘，此时将消耗IO时间
        // 2. redis单独服务器
        // 3. redis集群
        async _getReportMemoryCache(name, tid, sid, time) {
            // redis
            const cacheKey = name + '-t' + tid + (sid ? '-s' + sid : '') + (time ? '-' + time : '');
            const data = await this.cache.get(cacheKey);
            if (data) {
                return eval(data);
            } else {
                return null;
            }

            // mysql + IO
            // const rm = await this.getDataByCondition({
            //     tid: tid, sid: sid, name: name, time: time
            // });
            // if (rm && rm.file) {
            //     const file = path.join(this.ctx.app.config.filePath, 'report', 'cache', rm.file);
            //     if (fs.existsSync(file)) {
            //         const data = await fs.readFileSync(file, 'utf8');
            //         return eval(data);
            //     } else {
            //         return null;
            //     }
            // }
        }

        async _setReportMemoryCache(name, tid, sid, time, data) {
            // redis
            const cacheKey = name + '-t' + tid + (sid ? '-s' + sid : '') + (time ? '-' + time : '');
            this.cache.set(cacheKey, JSON.stringify(data), 'EX', this.ctx.app.config.cacheTime);

            // mysql + IO
            // const file = path.join('report', 'cache', 'rm' + (new Date()).getTime() + '.json');
            // await this.ctx.helper.saveBufferFile(JSON.stringify(data), path.join(this.ctx.app.config.filePath, file));
            // const rm = await this.getDataByCondition({
            //     tid: tid, sid: sid, name: name, time: time
            // });
            // if (rm) {
            //     await this.db.update(this.tableName, {id: rm.id, file: file});
            // } else {
            //     await this.db.insert(this.tableName, {tid: tid, sid: sid, name: name, time: time, file: file});
            // }
        }

        async _generateStageIm(tid, sid, isTz = true) {
            if (isTz && this.ctx.stage.im_type !== imType.tz.value) {
                throw '您查看的报表跟设置不符，请查看“总量控制”的报表';
            } else if (!isTz && this.ctx.stage.im_type === imType.tz.value) {
                throw '您查看的报表跟设置不符，请查看“0号台账”的报表';
            }
            const stageIm = new StageIm(this.ctx);
            await stageIm.buildImData();
            this.stageImData.main = stageIm.ImData;
            if (isTz) {
                this.stageImData.bills = stageIm.ImBillsData;
                await this._setReportMemoryCache(stageImTz, tid, sid, this.ctx.stage.cacheTime, this.stageImData.main);
                await this._setReportMemoryCache(stageImTzBills, tid, sid, this.ctx.stage.cacheTime, this.stageImData.bills);
            } else {
                await this._setReportMemoryCache(stageImZl, tid, sid, this.ctx.stage.cacheTime, this.stageImData.main);
            }
        }

        async getStageImTzNoReturn(tid, sid) {
            // 备注：单独拎出以下几行代码一个是为了提高效率(跟getStageImTzDataDirectlyByKey方法协作使用)
            //      二是如果出现并行查询(台账及台账清单)情况下，会出现干扰(已验证过)，导致数据丢失
            if (!this.stageImData) {
                this.stageImData = {};
            }
            try {
                await this._generateStageIm(tid, sid);
            } catch (err) {
                this.stageImData.main = [];
                this.stageImData.bills = [];
            }
        }

        getStageImTzDataDirectlyByKey(key) {
            let rst = [];
            if (key === 'mem_stage_im_tz') {
                rst = this.stageImData.main;
            } else {
                rst = this.stageImData.bills;
            }
            return rst;
        }

        async getStageImTzData(tid, sid) {
            await this._checkTender(tid);
            await this._checkStage(sid);
            const cache = await this._getReportMemoryCache('mem_stage_im_tz', tid, sid, this.ctx.stage.cacheTime);
            if (cache) {
                //console.log('cache');
                return cache;
            }

            //console.log('build');
            if (!this.stageImData) {
                this.stageImData = {};
                try {
                    await this._generateStageIm(tid, sid);
                } catch (err) {
                    if (err.statck) {
                        this.ctx.logger.error(err);
                    }
                    this.stageImData.main = err.statck ? '数据错误' : err;
                    this.stageImData.bills = this.stageImData.main;
                }
            }
            return this.stageImData.main;
        }

        async getStageImTzBillsData(tid, sid) {
            await this._checkTender(tid);
            await this._checkStage(sid);
            const cache = await this._getReportMemoryCache('mem_stage_im_tz_bills', tid, sid, this.ctx.stage.cacheTime);
            if (cache) return cache;

            if (!this.stageImData) {
                this.stageImData = {};
                try {
                    await this._generateStageIm(tid, sid);
                } catch (err) {
                    if (err.statck) {
                        this.ctx.logger.error(err);
                    }
                    this.stageImData.main = err.statck ? '数据错误' : err;
                    this.stageImData.bills = this.stageImData.main;
                }
            }
            return this.stageImData.bills;
        }

        async getStageImZlData(tid, sid) {
            await this._checkTender(tid);
            await this._checkStage(sid);
            const cache = await this._getReportMemoryCache('mem_stage_im_zl', tid, sid, this.ctx.stage.cacheTime);
            if (cache) return cache;

            this.stageImData = {};
            try {
                await this._generateStageIm(tid, sid, false);
            } catch (err) {
                if (err.statck) {
                    this.ctx.logger.error(err);
                }
                this.stageImData.main = err.statck ? '数据错误' : err;
            }
            return this.stageImData.main;
        }
    }

    return ReportMemory;
};