Calculation/app/service/shenpi_audit.js

'use strict';

/**
 * 版本数据模型
 *
 * @author CaiAoLin
 * @date 2017/10/25
 * @version
 */
const shenpiConst = require('../const/shenpi');

module.exports = app => {

    class ShenpiAudit extends app.BaseService {

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

        async getAudit(tid, type, status) {
            const sql = 'SELECT sp.audit_id, sp.audit_type, pa.name FROM ?? AS sp LEFT JOIN ?? AS pa ON sp.audit_id = pa.id' +
                ' WHERE sp.tid = ? AND sp.sp_type = ? AND sp.sp_status = ?';
            const sqlParam = [this.tableName, this.ctx.service.projectAccount.tableName, tid, type, status];
            return await this.db.queryOne(sql, sqlParam);
        }

        async getAuditList(tid, type, status) {
            const sql = 'SELECT sp.audit_id, sp.audit_type, pa.name FROM ?? AS sp LEFT JOIN ?? AS pa ON sp.audit_id = pa.id' +
                ' WHERE sp.tid = ? AND sp.sp_type = ? AND sp.sp_status = ? ORDER BY sp.audit_order ASC, sp.id ASC';
            const sqlParam = [this.tableName, this.ctx.service.projectAccount.tableName, tid, type, status];
            return await this.db.query(sql, sqlParam);
        }

        async getAuditGroupList(tid, type, status) {
            const sql = 'SELECT sp.audit_id, sp.audit_type, sp.audit_order, pa.name FROM ?? AS sp LEFT JOIN ?? AS pa ON sp.audit_id = pa.id' +
                ' WHERE sp.tid = ? AND sp.sp_type = ? AND sp.sp_status = ? ORDER BY sp.audit_order ASC, sp.id ASC';
            const sqlParam = [this.tableName, this.ctx.service.projectAccount.tableName, tid, type, status];
            const audits = await this.db.query(sql, sqlParam);
            const result = [];
            for (const a of audits) {
                if (a.audit_order > 0) {
                    if (result[a.audit_order - 1]) {
                        result[a.audit_order - 1].push(a);
                    } else {
                        result.push([a]);
                    }
                } else {
                    result.push([a]);
                }
            }
            return result;
        }

        async addAudit(data) {
            let result;
            const transaction = await this.db.beginTransaction();
            try {
                if (parseInt(data.code) === shenpiConst.sp_type.stage && parseInt(data.status) === shenpiConst.sp_status.gdspl) {
                    const options = {
                        where: {
                            tid: this.ctx.tender.id,
                            user_id: data.audit_id,
                        },
                    };
                    const updateData = {
                        status: 1,
                    };
                    await transaction.update(this.ctx.service.ledgerCooperation.tableName, updateData, options);
                }
                const insertData = {
                    tid: this.ctx.tender.id,
                    sp_type: data.code,
                    sp_status: data.status,
                    audit_id: data.audit_id,
                };
                if (data.audit_type) insertData.audit_type = data.audit_type;
                if (data.audit_order) insertData.audit_order = data.audit_order;
                result = await transaction.insert(this.tableName, insertData);
                await transaction.commit();
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
            if (result.affectedRows !== 1) throw '添加审批人失败';
            data.id = result.insertId;
            return data;
        }

        async removeAudit(data) {
            const delData = {
                tid: this.ctx.tender.id,
                sp_type: data.code,
                sp_status: data.status,
                audit_id: data.audit_id,
            };
            const audit = await this.getDataByCondition(delData);
            const allAudit = await this.getAllDataByCondition({ where: { tid: this.ctx.tender.id, sp_type: data.code, sp_status: data.status } });
            const sameOrder = allAudit.filter(x => { return x.audit_order === audit.audit_order });
            const updateData = [];
            if (sameOrder.length === 1) {
                for (const aa of allAudit) {
                    if (aa.audit_order > audit.audit_order) updateData.push({ id: aa.id, audit_order: aa.audit_order - 1});
                }
            }
            const transaction = await this.db.beginTransaction();
            try {
                await transaction.delete(this.tableName, delData);
                if (updateData.length > 0) await transaction.updateRows(this.tableName, updateData);
                if (parseInt(data.code) === shenpiConst.sp_type.stage && parseInt(data.status) === shenpiConst.sp_status.gdspl) {
                    const options = {
                        where: {
                            tid: this.ctx.tender.id,
                            user_id: data.audit_id,
                        },
                    };
                    const updateData = {
                        status: 0,
                    };
                    await transaction.update(this.ctx.service.ledgerCooperation.tableName, updateData, options);
                }
                await transaction.commit();
                return true;
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
        }

        async copyAudit2otherTender(data) {
            const transaction = await this.db.beginTransaction();
            try {
                const shenpi_status = parseInt(data.status);
                // 1.复制修改当前审批到其他的tender_info里
                // 2.删除其他的shenpiAudit
                // 3.添加新的shenpiAudit(还要针对该标段是否为原报进行处理)
                const tenderInfoUpdateList = [];
                const tenders = [];
                for (const tid of data.tidList.split(',')) {
                    // 获取原报
                    const tender = await this.ctx.service.tender.getDataById(tid);
                    if (tender) {
                        tenders.push({ id: parseInt(tid), user_id: tender.user_id });
                        const shenpiInfo = await this.ctx.service.tenderInfo.getTenderShenpiInfo(tid);
                        // 把当前期状态复制到其他标段里
                        if (shenpiInfo[data.code] !== shenpi_status) {
                            shenpiInfo[data.code] = shenpi_status;
                            tenderInfoUpdateList.push({ row: { shenpi: JSON.stringify(shenpiInfo) }, where: { tid: parseInt(tid) } });
                        }
                    }
                }
                if (tenderInfoUpdateList.length > 0) await transaction.updateRows(this.ctx.service.tenderInfo.tableName, tenderInfoUpdateList);
                const insertList = [];
                const needYB = ['ledger', 'revise', 'change'];
                const canYB = needYB.indexOf(data.code) !== -1;
                for (const t of tenders) {
                    if (shenpi_status !== shenpiConst.sp_status.sqspr) {
                        await transaction.delete(this.tableName, { tid: t.id, sp_type: shenpiConst.sp_type[data.code], sp_status: shenpi_status });
                        const sourceList = data.auditList.filter(x => { return x.audit_id && (x.audit_id !== t.user_id || canYB) });
                        sourceList.sort((a, b) => { return a.audit_order - b.audit_order; });
                        let audit_order = 0, curAuditOrder = 0;
                        for (const s of sourceList) {
                            if (s.audit_order !== curAuditOrder) {
                                curAuditOrder = s.audit_order;
                                audit_order = audit_order + 1;
                            }
                            insertList.push({
                                tid: t.id,
                                sp_type: shenpiConst.sp_type[data.code],
                                sp_status: shenpi_status,
                                audit_id: s.audit_id,
                                audit_type: s.audit_type,
                                audit_order: audit_order,
                            });
                        }
                    }
                }
                // console.log(tenderInfoUpdateList, insertList);
                if (insertList.length > 0) await transaction.insert(this.tableName, insertList);
                await transaction.commit();
                return true;
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
        }

        async copyAudit2otherShenpi(data) {
            const transaction = await this.db.beginTransaction();
            try {
                const shenpi_status = parseInt(data.status);
                // 1.修改当前审批到它的tender_info里
                // 2.删除相同审批状态的shenpiAudit
                // 3.添加新的shenpiAudit(还要针对该标段是否为原报进行处理)
                const insertList = [];
                const needYB = ['ledger', 'revise', 'change'];
                const shenpiInfo = await this.ctx.service.tenderInfo.getTenderShenpiInfo(this.ctx.tender.id);
                for (const code of data.shenpiList.split(',')) {
                    // 把当前审批状态复制到其他标段里
                    if (shenpiInfo[code] !== shenpi_status) {
                        shenpiInfo[code] = shenpi_status;
                    }
                    if (shenpiInfo[code] !== shenpiConst.sp_status.sqspr) {
                        await transaction.delete(this.tableName, { tid: this.ctx.tender.id, sp_type: shenpiConst.sp_type[code], sp_status: shenpiInfo[code] });
                        for (const aid of data.aidList.split(',')) {
                            if (aid && parseInt(aid) !== this.ctx.tender.data.user_id || (parseInt(aid) === this.ctx.tender.data.user_id && needYB.indexOf(code) !== -1)) {
                                const insertData = {
                                    tid: this.ctx.tender.id,
                                    sp_type: shenpiConst.sp_type[code],
                                    sp_status: shenpi_status,
                                    audit_id: parseInt(aid),
                                };
                                insertList.push(insertData);
                            }
                        }
                    }
                }
                await transaction.update(this.ctx.service.tenderInfo.tableName,
                    {
                        shenpi: JSON.stringify(shenpiInfo),
                    },
                    {
                        where: {
                            tid: this.ctx.tender.id,
                        },
                    });
                if (insertList.length > 0) await transaction.insert(this.tableName, insertList);
                await transaction.commit();
                return true;
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
        }

        async setAuditType(data) {
            const conn = await this.db.beginTransaction();
            try {
                const updateData = { audit_type: data.audit_type };
                const condition = {
                    tid: this.ctx.tender.id,
                    sp_type: data.code,
                    sp_status: data.status,
                    audit_id: data.audit_id,
                };
                await conn.update(this.tableName, updateData, { where: condition });
                await conn.commit();
            } catch (err) {
                await conn.rollback();
                throw err;
            }
        }

        // 更新审批流程
        async updateAuditList(transaction, tenderId, sp_status, sp_type, ids) {
            if (sp_status === shenpiConst.sp_status.gdspl) {
                const auditList = await this.getAuditList(tenderId, sp_type, sp_status);
                const oldIds = this._.map(auditList, 'audit_id');
                if (this._.isEqual(ids, oldIds)) {
                    return;
                }
                // 更新固定审批流
                await transaction.delete(this.tableName, { tid: tenderId, sp_type, sp_status });
                const insertDatas = [];
                for (const [i, id] of ids.entries()) {
                    insertDatas.push({
                        tid: tenderId,
                        sp_type,
                        sp_status,
                        audit_id: id,
                        audit_order: i + 1,
                    });
                }
                await transaction.insert(this.tableName, insertDatas);
                if (sp_type === shenpiConst.sp_type.stage) {
                    // 判断哪些audit_id不存在了，哪些audit_为新增
                    const exist = this._.difference(ids, oldIds);// 判断新增的
                    const unExist = this._.difference(oldIds, ids);// 判断已删除的
                    console.log(ids, oldIds, exist, unExist);
                    if (exist.length > 0) {
                        const options = {
                            where: {
                                tid: this.ctx.tender.id,
                                user_id: exist,
                            },
                        };
                        const updateData = {
                            status: 1,
                        };
                        await transaction.update(this.ctx.service.ledgerCooperation.tableName, updateData, options);
                    }
                    if (unExist.length > 0) {
                        const options2 = {
                            where: {
                                tid: this.ctx.tender.id,
                                user_id: unExist,
                            },
                        };
                        const updateData2 = {
                            status: 0,
                        };
                        await transaction.update(this.ctx.service.ledgerCooperation.tableName, updateData2, options2);
                    }
                }
            } else if (sp_status === shenpiConst.sp_status.gdzs) {
                const audit = await this.getAudit(tenderId, sp_type, sp_status);
                if (audit && audit.audit_id !== ids[ids.length - 1]) {
                    // 更换终审
                    await transaction.update(this.tableName, { audit_id: ids[ids.length - 1] }, { where: { tid: tenderId, sp_type, sp_status } });
                } else if (!audit) {
                    await transaction.insert(this.tableName, { tid: tenderId, sp_type, sp_status, audit_id: ids[ids.length - 1] });
                }
            }
        }
    }

    return ShenpiAudit;
};