Calculation/app/service/stage_bonus.js

'use strict';

/**
 *  奖罚金
 *
 * @author Mai
 * @date
 * @version
 */

const auditConst = require('../const/audit').stage;
const path = require('path');

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

        _parseData(data) {
            const helper = this.ctx.helper;
            if (!data) return;
            const datas = data instanceof Array ? data : [data];
            for (const d of datas) {
                if (d.proof_file) {
                    d.proof_file = JSON.parse(d.proof_file);
                    d.proof_file.forEach(f => {
                        if (helper.canPreview(f.fileext)){
                            f.viewpath = f.filepath.substr(3, f.filepath.length - 3);
                        }
                    });
                } else {
                    d.proof_file = [];
                }
            }
        }

        async getStageData(stage, cancel = false) {
            const data = await this.getAllDataByCondition({where: { sid: stage.id }});
            this._parseData(data);
            if (!stage || cancel || !stage.readOnly || this.ctx.tender.isTourist || stage.status === auditConst.status.checked
                || (stage.flowAuditorIds && stage.flowAuditorIds.indexOf(this.ctx.session.sessionUser.accountId) >= 0)) return data;

            for (const d of data) {
                const his = d.shistory ? JSON.parse(d.shistory) : [];
                const h = this.ctx.helper._.find(his, {
                    stimes: this.ctx.stage.curTimes, sorder: this.ctx.stage.curOrder
                });
                d.tp = h ? h.tp : null;
            }
            return data;
        }

        async getPreStageData(tid, sorder) {
            const sql = 'SELECT * From ' + this.tableName + ' WHERE sorder < ? And tid = ?';
            const sqlParam = [sorder, tid];
            const data = await this.db.query(sql, sqlParam);
            this._parseData(data);
            return data;
        }

        async getEndStageData(tid, sorder) {
            const sql = 'SELECT * From ' + this.tableName + ' WHERE sorder <= ? And tid = ? ORDER BY `sorder`, `order`';
            const sqlParam = [sorder, tid];
            const data = await this.db.query(sql, sqlParam);
            this._parseData(data);
            return data;
        }

        async getStageDataById(bonusId) {
            const data = await this.getAllDataByCondition({ where: { id: bonusId } });
            this._parseData(data);
            return data[0];
        }

        async _addDatas(data) {
            const tpDecimal = this.ctx.tender.info.decimal.extra
                ? this.ctx.tender.info.decimal.extraTp
                : this.ctx.tender.info.decimal.tp;

            const datas = data instanceof Array ? data : [data];
            const insertData = [];
            for (const d of datas) {
                if (!d.name || !d.order) throw '新增奖罚金，提交的数据错误';
                const nd = {
                    id: this.uuid.v4(),
                    tid: this.ctx.tender.id,
                    sid: this.ctx.stage.id,
                    sorder: this.ctx.stage.order,
                    uid: this.ctx.session.sessionUser.accountId,
                    create_time: new Date(),
                    name: d.name,
                    order: d.order,
                };
                nd.b_type = d.b_type ? d.b_type : null;
                nd.tp = d.tp ? this.ctx.helper.round(d.tp, tpDecimal) : 0;
                nd.code = d.code ? d.code: null;
                nd.proof = d.proof ? d.proof : null;
                nd.real_time = d.real_time ? d.real_time : null;
                nd.memo = d.memo ? d.memo : null;
                nd.doc_co = d.doc_co ? d.doc_co : null;
                insertData.push(nd);
            }
            await this.db.insert(this.tableName, insertData);
            return insertData;
        }

        async _delDatas (data) {
            const datas = data instanceof Array ? data : [data];
            const orgDatas = await this.getAllDataByCondition({where: {sid: this.ctx.stage.id, id: this.ctx.helper._.map(datas, 'id')}});
            for (const od of orgDatas) {
                if (od.sid !== this.ctx.stage.id) throw '非本期新增数据，不可删除';
            }
            await this.db.delete(this.tableName, {id: datas});
            return datas;
        }

        async _updateDatas (data) {
            const tpDecimal = this.ctx.tender.info.decimal.extra
                ? this.ctx.tender.info.decimal.extraTp
                : this.ctx.tender.info.decimal.tp;

            const datas = data instanceof Array ? data : [data];
            const orgDatas = await this.getAllDataByCondition({
                where: { id: this.ctx.helper._.map(datas, 'id') }
            });

            const uDatas = [];
            for (const d of datas) {
                const od = this.ctx.helper._.find(orgDatas, {id: d.id});
                if (!od) continue;

                const nd = {id: od.id};
                if (d.name !== undefined) nd.name = d.name;
                if (d.b_type !== undefined) nd.b_type = d.b_type;
                if (d.tp !== undefined) nd.tp = this.ctx.helper.round(d.tp, tpDecimal);
                if (d.code !== undefined) nd.code = d.code;
                if (d.proof !== undefined) nd.proof = d.proof;
                if (d.proof_file !== undefined) nd.proof_file = JSON.stringify(d.proof_file);
                if (d.real_time !== undefined) nd.real_time = new Date(d.real_time);
                if (d.memo !== undefined) nd.memo = d.memo;
                if (d.order !== undefined) nd.order = d.order;
                if (d.doc_co !== undefined) nd.doc_co = d.doc_co;
                uDatas.push(nd);
            }
            if (uDatas.length > 0) {
                await this.db.updateRows(this.tableName, uDatas);
                this._parseData(uDatas);
                return uDatas;
            } else {
                return [];
            }
        }

        async updateDatas(data) {
            const result = {add: [], del: [], update: []};
            try {
                if (data.add) {
                    result.add = await this._addDatas(data.add);
                }
                if (data.update) {
                    result.update = await this._updateDatas(data.update);
                }
                if (data.del) {
                    result.del = await this._delDatas(data.del);
                }
                return result;
            } catch (err) {
                if (err) result.err = err;
                return result;
            }
        }

        async updateHistory4TimesOrder(stage, times, order, transaction) {
            const datas = await this.getStageData(stage);
            if (datas.length === 0) return;

            const updateDatas = [];
            for (const d of datas) {
                for (const curOrder of order) {
                    const history = d.shistory && d.shistory !== '' ? JSON.parse(d.shistory) : [];
                    const his = history.find(function (x) {
                        return x.stimes && x.stimes === times
                            && x.sorder !== undefined && x.sorder !== null && x.sorder === curOrder;
                    });
                    if (his) {
                        his.tp = d.tp;
                    } else {
                        history.push({ stimes: times, sorder: curOrder, tp: d.tp });
                    }
                    updateDatas.push({ id: d.id, shistory: JSON.stringify(history) });
                }
            }
            await transaction.updateRows(this.tableName, updateDatas);
        }

        async updateHistory(stage, transaction) {
            await this.updateHistory4TimesOrder(stage, stage.curTimes, [stage.curOrder], transaction);
        }

        async updateHistory4CheckAgain(stage, transaction) {
            await this.updateHistory4TimesOrder(stage, stage.curTimes, [stage.curOrder + 1], transaction);
        }

        async deleteStageTimesData(sid, times, transaction) {
            const datas = await this.getAllDataByCondition({where: { sid: sid }});
            if (datas.length === 0) return;

            const updateDatas = [];
            for (const d of datas) {
                const history = d.shistory && d.shistory !== '' ? JSON.parse(d.shistory) : [];
                const his = history.filter(function (x) {
                    return x.stimes && x.stimes < times;
                });
                his.sort(function (x, y) {
                    return (x.stimes * 1000 + x.sorder) - (y.stimes * 1000 + y.sorder);
                });
                updateDatas.push({
                    id: d.id,
                    shistory: JSON.stringify(his),
                    tp: his.length > 0 ? his[his.length - 1].tp : null,
                });
            }
            await transaction.updateRows(this.tableName, updateDatas);
        }

        async getSumTp(stage) {
            if (!stage || stage.length === 0) return {};

            const stages = stage instanceof Array ? stage : [stage];
            const condition = {};
            condition.sid = stage.length === 1 ? stage[0].id : stages.map(x => { return x.id; });
            const sql = `SELECT SUM(IF(tp > 0, tp, 0)) AS positive_tp, SUM(IF(tp < 0, tp, 0)) AS negative_tp, SUM(IF(b_type = '奖金', tp, 0)) AS reward_tp, SUM(IF(b_type = '罚金', tp, 0)) AS forfeit_tp, SUM(tp) AS sum_tp From ${this.tableName} ` + this.ctx.helper.whereSql(condition);
            return await this.db.queryOne(sql);
        }
    }

    return StageBonus;
};