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);
                // 回滚
                if (this.transaction) {
                    await this.transaction.rollback();
                    this.transaction = null;
                }
            }
            return rst;
        }

        async createRoleRelaOther(transaction, data, content) {
            const insertData = JSON.parse(JSON.stringify(data));
            insertData.business_type = rptArchiveConst.getBusinessType(data.sid);
            insertData.rel_content = JSON.stringify(content);
            if (transaction) {
                await transaction.insert(this.tableName, insertData);
            } else {
                await this.db.insert(this.tableName, insertData);
            }
        }

        async createRoleRelationshipFromOtherBz(tender_id, sid, currentBzId, preBzId, cleanSignDate = true) {
            // 此方法适合变更令相关业务
            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) {
                            const contents = JSON.parse(role.rel_content);
                            if (cleanSignDate) {
                                contents.forEach(role => {
                                    role.sign_date = '';
                                });
                            }
                            await this.createRoleRelationship(tender_id, role.rpt_id, sid, currentBzId, '', contents);
                        }
                    });
                }
            }
        }

        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] = '';
                        }
                    }
                    if (newRole.type === '流程') {
                        if (newRole.assFlowInfos && newRole.assFlowInfos.length > 0) {
                            newRole.assFlowInfos.forEach(assRole => {
                                assRole.sign_date = '';
                            });
                        }
                    }
                }
                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 updateMultiChangeRoleRelationship(orgParams, srcKey, newRelArr) {
            for (let idx = 0; idx < orgParams.length; idx++) {
                const param = orgParams[idx];
                const tenderId = param[0];
                const sid = param[1];
                const businessId = param[2];
                const rptId = param[3];
                // 变更令的参数结构有些不一样
                // [tenderId, '-300', changeCid, reportId];
                const data = { tender_id: tenderId, sid, business_id: businessId, rpt_id: rptId };
                this.transaction = await this.db.beginTransaction();
                try {
                    await this.transaction.delete(this.tableName, data);
                    await this.transaction.commit();
                    await this.createRoleRelationship(tenderId, rptId, sid, businessId, srcKey, newRelArr);
                } catch (ex) {
                    console.log(ex.toString());
                    // 回滚
                    await this.transaction.rollback();
                }
            }
            return true;
        }

        async updateMultiOtherRoleRelationship(orgParams, newRelArr) {
            const conn = await this.db.beginTransaction();
            try {
                for (const param of orgParams) {
                    // 变更令的参数结构有些不一样
                    // [tenderId, '-300', changeCid, reportId];
                    const data = { tender_id: param[0], sid: param[1], business_id: param[2], rpt_id: param[3] };
                    await conn.delete(this.tableName, data);
                    await this.createRoleRelaOther(conn, data, newRelArr);
                }
                await conn.commit();
            } catch (err) {
                this.ctx.log(err);
                await conn.rollback();
            }
            return true;
        }

        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);
                    await 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; });
                            // 备注：因为业务上会出现那种非流程、非原报的签名人，所以这个audit会为null，如为null，则取流程最后一个通过的日期，总之，就不取period的后一个日期了
                            if (audit) {
                                role.sign_date = audit.end_time || time;
                            } else {
                                role.sign_date = time;
                                stage.auditors.forEach(ad => {
                                    if (ad.status === 3) {
                                        role.sign_date = ad.end_time || time;
                                    }
                                });
                            }
                            // 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;
};