Calculation/app/service/contract_audit.js

'use strict';

/**
 * Created by EllisRan on 2020/3/3.
 */

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

module.exports = app => {

    class ContractAudit extends BaseService {

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

        async getList(options) {
            const list = await this.db.select(this.tableName, { where: options, orders: [['id', 'desc']] });
            for (const l of list) {
                const accountInfo = await this.ctx.service.projectAccount.getDataById(l.uid);
                l.name = accountInfo.name;
                l.role = accountInfo.role;
                l.company = accountInfo.company;
                l.mobile = accountInfo.mobile;
            }
            return list;
        }

        async saveAudits(options, accountList, transaction = null) {
            // 判断是否已存在该用户，存在则不插入
            const pauditList = await this.getAllDataByCondition({ where: options });
            const pushData = [];
            for (const a of this._.uniqBy(accountList, 'id')) {
                if (this._.findIndex(pauditList, { uid: a.id }) === -1) {
                    const data = {
                        spid: options.spid || null,
                        tid: options.tid || null,
                        uid: a.id,
                        create_time: new Date(),
                    };
                    pushData.push(data);
                }
            }
            if (pushData.length > 0) {
                return transaction ? await transaction.insert(this.tableName, pushData) : await this.db.insert(this.tableName, pushData);
            }
            return false;
        }

        async delAudit(id) {
            return await this.db.delete(this.tableName, { id });
        }

        async updatePermission(updateData) {
            if (!updateData.id) {
                return false;
            }
            return await this.db.update(this.tableName, updateData);
        }

        async checkPermission(options, uid) {
            if (this.ctx.session.sessionUser.is_admin) {
                return true;
            }
            let flag = false;
            const cloneOptions = this._.cloneDeep(options);
            cloneOptions.uid = uid;
            const info = await this.getDataByCondition(cloneOptions);
            if (info) {
                flag = true;
            }
            return flag;
        }

        async getUserPermissionEdit(options, uid) {
            const cloneOptions = this._.cloneDeep(options);
            cloneOptions.uid = uid;
            const info = await this.getDataByCondition(cloneOptions);
            return info && info.permission_edit;
        }

        async getUserList(tid, is_report = null) {
            const reportSql = is_report !== null ? ' AND ca.`is_report` = ' + is_report : '';
            const sql = 'SELECT ca.*, pa.name as user_name FROM ?? AS ca LEFT JOIN ?? AS pa ON ca.`uid` = pa.`id` ' +
                'WHERE ca.`tid` = ?' + reportSql + ' ORDER BY ca.`id` DESC';
            const params = [this.tableName, this.ctx.service.projectAccount.tableName, tid];
            return await this.db.query(sql, params);
        }

        async setOtherTender(tidList, userList) {
            // 根据标段找出创建人去除，已存在的先删除再插入
            const transaction = await this.db.beginTransaction();
            try {
                const tenderList = await this.ctx.service.tender.getAllDataByCondition({
                    columns: ['id', 'user_id'],
                    where: { id: tidList.split(',') },
                });
                const oldTouristList = await this.getAllDataByCondition({ where: { tid: tidList.split(',') } });
                const insertData = [];
                const deleteIdData = [];
                for (const user of userList) {
                    for (const t of tenderList) {
                        const delId = this._.find(oldTouristList, { tid: t.id, uid: user.uid });
                        if (delId) deleteIdData.push(delId.id);
                        if (user.uid !== t.user_id) {
                            insertData.push({
                                tid: t.id,
                                uid: user.uid,
                                is_report: user.is_report,
                                in_time: new Date(),
                            });
                        }
                    }
                }
                if (deleteIdData.length > 0) await transaction.delete(this.tableName, { id: deleteIdData });
                if (insertData.length > 0) await transaction.insert(this.tableName, insertData);
                await transaction.commit();
                return true;
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
        }
    }
    return ContractAudit;
};