Calculation/app/service/role_rpt_rel.js

'use strict';

/**
 * Created by Tony on 2019/9/26.
 */

const BaseService = require('../base/base_service');
const rptArchiveConst = require('../const/rpt_archive');

module.exports = app => {

    class RoleRptRel extends BaseService {

        /**
         * 构造函数
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        constructor(ctx) {
            super(ctx);
            this.tableName = 'role_rpt_rel';
            this.dataId = 'id';
        }

        async getRoleRptRelById(id) {
            this.initSqlBuilder();
            this.sqlBuilder.setAndWhere('id', {
                value: id,
                operate: '=',
            });
            this.sqlBuilder.columns = ['id', 'tender_id', 'rpt_id', 'rel_content'];
            const [sql, sqlParam] = this.sqlBuilder.build(this.tableName);
            const list = await this.db.query(sql, sqlParam);
            return list;
        }

        async getRoleRptRelByTenderId(tenderId, stageId) {
            this.initSqlBuilder();
            this.sqlBuilder.setAndWhere('tender_id', {
                value: tenderId,
                operate: '=',
            });
            if (stageId) {
                this.sqlBuilder.setAndWhere('sid', {
                    value: stageId,
                    operate: '=',
                });
            }
            this.sqlBuilder.columns = ['id', 'tender_id', 'rpt_id', 'sid', 'rel_content'];
            const [sql, sqlParam] = this.sqlBuilder.build(this.tableName);
            const list = await this.db.query(sql, sqlParam);
            // console.log(list);
            return list;
        }

        async getCrossTenderRoleRptRels(selectedTenders) {
            let rst = [];
            // 条件比较特别，需要直接写sql
            if (selectedTenders.length > 0) {
                let where_sql = '';
                for (let idx = 0; idx < selectedTenders.length; idx++) {
                    if (idx === 0) {
                        where_sql = '(tender_id = ' + selectedTenders[idx][0] + ' AND sid = ' + selectedTenders[idx][1] + ' AND rpt_id = ' + selectedTenders[idx][2] + ')';
                    } else {
                        where_sql = where_sql + ' OR (tender_id = ' + selectedTenders[idx][0] + ' AND sid = ' + selectedTenders[idx][1] + ' AND rpt_id = ' + selectedTenders[idx][2] + ')';
                    }
                }
                const sql = 'SELECT ?? FROM ?? WHERE ' + where_sql;
                const columns = ['id', 'tender_id', 'rpt_id', 'sid', 'rel_content'];
                const sqlParam = [columns, this.tableName];
                rst = await this.db.query(sql, sqlParam);
                // console.log(rst);
            }
            return rst;
        }

        async getRoleRptRelByDetailIds(tenderId, rptId, sid, bzId = '-1') {
            this.initSqlBuilder();
            this.sqlBuilder.setAndWhere('tender_id', {
                value: tenderId,
                operate: '=',
            });
            if (rptId instanceof Array) {
                this.sqlBuilder.setAndWhere('rpt_id', {
                    value: rptId,
                    operate: 'in',
                });
            } else if (rptId !== '-1' && rptId !== null && rptId !== '') {
                this.sqlBuilder.setAndWhere('rpt_id', {
                    value: rptId,
                    operate: '=',
                });
            }
            this.sqlBuilder.setAndWhere('sid', {
                value: sid,
                operate: '=',
            });
            if (bzId !== '-1' && bzId !== null && bzId !== '') {
                this.sqlBuilder.setAndWhere('business_id', {
                    value: `"${bzId}"`,
                    operate: '=',
                });
            }
            this.sqlBuilder.columns = ['id', 'tender_id', 'rpt_id', 'sid', 'business_id', 'rel_content'];
            const [sql, sqlParam] = this.sqlBuilder.build(this.tableName);
            const list = await this.db.query(sql, sqlParam);
            // console.log(list);
            return list;
        }

        async createRoleRelationship(tender_id, rpt_id, sid, business_id, source_type, relArr) {
            let rst = null;
            this.transaction = await this.db.beginTransaction();
            try {
                const data = {
                    tender_id,
                    rpt_id,
                    sid,
                    business_id,
                    // business_type: source_type,
                    business_type: rptArchiveConst.getBusinessType(sid),
                    rel_content: JSON.stringify(relArr),
                };
                // console.log(data);
                rst = await this.transaction.insert(this.tableName, data);
                await this.transaction.commit();
            } catch (ex) {
                console.log(ex);
                // 回滚
                await this.transaction.rollback();
            }
            return rst;
        }

        async createRoleRelationshipFromOtherBz(tender_id, sid, currentBzId, preBzId) {
            // 此方法适合变更令相关业务
            if (preBzId && currentBzId) {
                const preRst = await this.getRoleRptRelByDetailIds(tender_id, '-1', sid, '', preBzId);
                if (preRst.length > 0) {
                    preRst.forEach(async role => {
                        const curRst = await this.getRoleRptRelByDetailIds(tender_id, role.rpt_id, sid, '', currentBzId);
                        if (curRst.length === 0) {
                            await this.createRoleRelationship(tender_id, role.rpt_id, sid, currentBzId, '', JSON.parse(role.rel_content));
                        }
                    });
                }
            }
        }

        async addInitialStageData(tender_id, stage, preStage) {
            // 在加stage的时候需要挂上这个，copy之前的签名人
            const rst = [];
            const preRoleRelList = await this.getRoleRptRelByTenderId(tender_id, preStage.id);
            for (const rptRoleRel of preRoleRelList) {
                const relList = JSON.parse(rptRoleRel.rel_content);
                // const newRptRoleRel = {tender_id: tender_id, rpt_id: rptRoleRel.rpt_id, sid: stage.id, rel_content: ''};
                const newRelList = [];
                for (const role of relList) {
                    const newRole = {};
                    newRelList.push(newRole);
                    for (const key in role) {
                        if (key !== 'sign_date') {
                            newRole[key] = role[key];
                        } else {
                            newRole[key] = '';
                        }
                    }
                }
                await this.createRoleRelationship(tender_id, rptRoleRel.rpt_id, stage.id, '', 'tender', newRelList); // 暂时用不到，就先不返回结果
            }
            return rst;
        }

        async updateRoleRelationship(id, tender_id, rpt_id, sid, business_id, source_type, relArr) {
            let rst = null;
            if (id < 0) {
                rst = await this.createRoleRelationship(tender_id, rpt_id, sid, business_id, source_type, relArr);
            } else {
                this.transaction = await this.db.beginTransaction();
                try {
                    const data = {
                        id,
                        tender_id,
                        rpt_id, sid,
                        business_id,
                        // business_type: source_type,
                        business_type: rptArchiveConst.getBusinessType(sid),
                        rel_content: JSON.stringify(relArr),
                    };
                    rst = await this.transaction.update(this.tableName, data);
                    await this.transaction.commit();
                } catch (ex) {
                    console.log(ex);
                    // 回滚
                    await this.transaction.rollback();
                }
            }
            return rst;
        }

        async updateMultiRoleRelationship(orgParams, bzId, srcKey, newRelArr) {
            for (let idx = 0; idx < orgParams.length; idx++) {
                const param = orgParams[idx];
                const data = { tender_id: param[0], sid: param[1], rpt_id: param[2] };
                this.transaction = await this.db.beginTransaction();
                try {
                    await this.transaction.delete(this.tableName, data);
                    this.transaction.commit();
                    await this.createRoleRelationship(param[0], param[2], param[1], bzId, srcKey, newRelArr);
                } catch (ex) {
                    console.log(ex.toString());
                    // 回滚
                    await this.transaction.rollback();
                }
            }
            return true;
        }

        async checkSignDate(transaction, stage, curAudit, time) {
            const rptRole = await this.getAllDataByCondition({ where: { sid: stage.id } });
            const period = stage.period.split(' ~ ');

            const updateData = [];
            for (const rc of rptRole) {
                if (!rc.rel_content) continue;
                let bChange = false;
                const roleContent = JSON.parse(rc.rel_content);
                for (const role of roleContent) {
                    if (!role.sign_date || role.sign_flow) {
                        if (role.acc_id === curAudit.aid) {
                            role.sign_date = time;
                        } else if (role.acc_id === stage.userId) {
                            role.sign_date = stage.auditors[0].begin_time || time;
                        } else {
                            const audit = this.ctx.helper._.findLast(stage.auditors, x => { return x.aid === role.acc_id; });
                            role.sign_date = audit ? audit.end_time || time : new Date(period[period.length - 1]);
                        }
                        role.sign_flow = 1;
                        bChange = true;
                    }
                }
                if (bChange) updateData.push({ id: rc.id, rel_content: JSON.stringify(roleContent) });
            }
            if (updateData.length > 0) await transaction.updateRows(this.tableName, updateData);
        }
    }
    return RoleRptRel;
};