Calculation/app/service/payment_tender.js

'use strict';

/**
 * 决策大屏用户查看权限-数据模型
 *
 * @author ellisran
 * @date 2021/09/23
 * @version
 */
const accountGroup = require('../const/account_group').group;
const paymentConst = require('../const/payment');
const auditConst = require('../const/audit').stage;
module.exports = app => {
    class paymentTender extends app.BaseService {
        constructor(ctx) {
            super(ctx);
            this.tableName = 'payment_tender';
        }

        async getList(uid, auditPermission) {
            if (auditPermission.view_all) {
                const sql1 = 'SELECT pt.*, pa.name as user_name FROM ?? as pt LEFT JOIN ?? as pa ON pt.`uid` = pa.`id` WHERE pt.`pid` = ? AND pt.`spid` = ?';
                const params1 = [this.tableName, this.ctx.service.projectAccount.tableName, this.ctx.session.sessionProject.id, this.ctx.subProject.id];
                return await this.db.query(sql1, params1);
            }
            const typeValues = [];
            const modes = this.ctx.subProject.payment_setting ? JSON.parse(this.ctx.subProject.payment_setting) : this._.cloneDeep(paymentConst.setting_modes);
            for (const m in paymentConst.setting_modes) {
                if (!modes[m]) modes[m] = this._.cloneDeep(paymentConst.setting_modes[m]);
                if (modes[m].checked) {
                    typeValues.push(modes[m].value);
                }
            }
            if (typeValues.length === 0) {
                return -1;
            }
            const sql = 'SELECT pt.*, pa.name as user_name FROM ?? as pt LEFT JOIN ?? as pa ON pt.`uid` = pa.`id` WHERE pid = ? AND spid = ? AND (pt.`uid` = ? ' +
                'OR pt.`id` in (SELECT pr.`tender_id` FROM ?? as pr WHERE pr.`uid` = ? AND pr.`type` IN (' + this.ctx.helper.getInArrStrSqlFilter(typeValues) + '))' +
                'OR pt.`id` in (SELECT pd.`tender_id` FROM ?? as pd WHERE pd.`uid` = ?)' +
                'OR pt.`id` in (SELECT pda.`tender_id` FROM ?? as pda LEFT JOIN ?? as pd ON pda.`tender_id` = pd.`tender_id` ' +
                'WHERE pd.`status` != ' + auditConst.status.uncheck + ' AND pda.`aid` = ?)' +
                'OR pt.`id` in (SELECT pra.`tender_id` FROM ?? as pra LEFT JOIN ?? as pd ON pra.`tender_id` = pd.`tender_id` ' +
                'WHERE pd.`status` != ' + auditConst.status.uncheck + ' AND pd.`status` !=' + auditConst.status.checkNo + ' AND pra.`uid` = ?))';
            const params = [this.tableName, this.ctx.service.projectAccount.tableName, this.ctx.session.sessionProject.id, this.ctx.subProject.id, uid,
                this.ctx.service.paymentTenderRpt.tableName, uid,
                this.ctx.service.paymentDetail.tableName, uid,
                this.ctx.service.paymentDetailAudit.tableName, this.ctx.service.paymentDetail.tableName, uid,
                this.ctx.service.paymentRptAudit.tableName, this.ctx.service.paymentDetail.tableName, uid];
            return await this.db.query(sql, params);
        }

        async getNoSpList(pid, spIsNull = true) {
            const spSql = spIsNull ? ' AND pt.`spid` = ?' : ' AND pt.`spid` != ?';
            const sql1 = 'SELECT pt.*, pa.name as user_name FROM ?? as pt LEFT JOIN ?? as pa ON pt.`uid` = pa.`id` WHERE pt.`pid` = ?' + spSql;
            const params1 = [this.tableName, this.ctx.service.projectAccount.tableName, pid, ''];
            return await this.db.query(sql1, params1);
        }

        async addTender(projectId, uid, folderId, name) {
            const transaction = await this.db.beginTransaction();
            try {
                const folderInfo = await this.ctx.service.paymentFolder.getDataById(folderId);
                if (!folderInfo || folderInfo.is_leaf === 0) {
                    throw '文件夹不存在或存在子目录不能新建标段';
                }
                const insertData = {
                    pid: projectId,
                    spid: this.ctx.subProject.id,
                    uid,
                    name,
                    folder_id: folderId,
                    in_time: new Date(),
                };
                const result = await transaction.insert(this.tableName, insertData);
                const updateData = [
                    { id: folderInfo.id, had_tender: 1 },
                ];
                // 更新父节点had_tender值
                if (folderInfo.parent_path) {
                    const parentFolderIds = folderInfo.parent_path.split('-');
                    for (const pf of parentFolderIds) {
                        updateData.push({
                            id: parseInt(pf),
                            had_tender: 1,
                        });
                    }
                }
                await transaction.updateRows(this.ctx.service.paymentFolder.tableName, updateData);
                // 同时生成固定的报表表单
                await this.ctx.service.paymentTenderRpt.setConstRpt(transaction, result.insertId, uid);
                await transaction.commit();
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
        }

        async deleteTender(id) {
            const transaction = await this.db.beginTransaction();
            try {
                const tenderInfo = await this.getDataById(id);
                if (!tenderInfo) {
                    throw '标段不存在';
                }
                if (tenderInfo.uid !== this.ctx.session.sessionUser.accountId && !this.ctx.session.sessionUser.is_admin) {
                    throw '您没有权限删除此标段';
                }
                const had_detail = await this.ctx.service.paymentDetail.haveDetail2Tender(id);
                if (had_detail) {
                    throw '请先删除所有报表表单详情';
                }
                const folderInfo = await this.ctx.service.paymentFolder.getDataById(tenderInfo.folder_id);
                if (!folderInfo) {
                    throw '文件夹不存在';
                }
                // 判断folderInfo下是否还存在tender，不存在则把had_tender为0，并判断父节点是否需要也为0
                const leafTenderCount = await transaction.count(this.tableName, { folder_id: folderInfo.id });
                if (leafTenderCount === 1) {
                    const updateDatas = [{
                        id: folderInfo.id,
                        had_tender: 0,
                    }];
                    if (folderInfo.parent_path) {
                        const parentFolderIds = folderInfo.parent_path.split('-').reverse();
                        for (const pfid of parentFolderIds) {
                            const parentFolderId = parseInt(pfid);
                            const leafFolderCount = await transaction.count(this.ctx.service.paymentFolder.tableName, { parent_id: parentFolderId, had_tender: 1 });
                            if (leafFolderCount === 1) {
                                updateDatas.push({
                                    id: parentFolderId,
                                    had_tender: 0,
                                });
                            } else {
                                break;
                            }
                        }
                    }
                    await transaction.updateRows(this.ctx.service.paymentFolder.tableName, updateDatas);
                }
                await transaction.delete(this.ctx.service.paymentTenderRpt.tableName, { tender_id: id });
                await transaction.delete(this.ctx.service.paymentShenpiAudit.tableName, { tid: id });
                await transaction.delete(this.tableName, { id });
                await transaction.commit();
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
        }

        // async getChildrenByParentId(parentId, transaction = null) {
        //     const list = await this.getAllDataByCondition({ where: { parent_id: parentId } });
        // }

        async doCheckTender(id) {
            return await this.service.paymentTender.getDataById(id);
        }

        async bindSp(tids) {
            const noSpTenderList = await this.getNoSpList(this.ctx.session.sessionProject.id);
            const noSpFolderList = await this.ctx.service.paymentFolder.getNoSpList(this.ctx.session.sessionProject.id);
            const transaction = await this.db.beginTransaction();
            try {
                const hadSpTenderList = await this.getNoSpList(this.ctx.session.sessionProject.id, false);
                if (tids.length === noSpTenderList.length && hadSpTenderList.length === 0) {
                    // 一次性迁移所有可以不用复制folder数据，也不用调整tender数据，直接更新spid
                    await transaction.update(this.tableName, { spid: this.ctx.subProject.id }, { where: { pid: this.ctx.session.sessionProject.id } });
                    await transaction.update(this.ctx.service.paymentFolder.tableName, { spid: this.ctx.subProject.id }, { where: { pid: this.ctx.session.sessionProject.id } });
                } else {
                    const hadSpTenderIds = hadSpTenderList.map(item => item.id);
                    // tids里过滤掉hadSpTenderIds存在的值
                    const filterTids = tids.filter(item => !hadSpTenderIds.includes(item));
                    if (filterTids.length > 0) {
                        const folderList = await this.ctx.service.paymentFolder.getAllDataByCondition({ where: { spid: this.ctx.subProject.id } });
                        // 需要复制一份folder数据，且比对folderList，如果存在则不复制，且可能需要调整id，parent_id，parent_path, order值
                        const allNotExistFolderIds = [];
                        for (const tid of filterTids) {
                            const tender = this._.find(noSpTenderList, { id: tid });
                            if (tender) {
                                const parentFolder = this._.find(noSpFolderList, { folder_id: tender.folder_id });
                                if (parentFolder) {
                                    const spParentFolder = this._.find(folderList, { folder_id: tender.folder_id });
                                    if (!spParentFolder) allNotExistFolderIds.push(tender.folder_id);
                                    const parentPathArray = parentFolder.parent_path ? this._.map(parentFolder.parent_path.split('-'), this._.toInteger) : [];
                                    if (parentPathArray.length > 0) {
                                        for (const id of parentPathArray) {
                                            const spFolder = this._.find(folderList, { folder_id: id });
                                            if (!spFolder && !this._.includes(allNotExistFolderIds, id)) {
                                                allNotExistFolderIds.push(id);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        const newFolderList = [];
                        if (allNotExistFolderIds.length > 0) {
                            const allNotExistFolderList = this._.orderBy(this._.filter(noSpFolderList, item => this._.includes(allNotExistFolderIds, item.folder_id)), ['in_time'], ['asc']);
                            for (const f of allNotExistFolderList) {
                                newFolderList.push({
                                    id: this.uuid.v4(),
                                    pid: this.ctx.session.sessionProject.id,
                                    spid: this.ctx.subProject.id,
                                    uid: f.uid,
                                    name: f.name,
                                    folder_id: f.folder_id,
                                    parent_id: f.parent_id,
                                    parent_path: f.parent_path,
                                    level: f.level,
                                    order: f.order,
                                    is_leaf: f.is_leaf,
                                    had_tender: f.had_tender,
                                    in_time: f.in_time,
                                });
                            }
                        }
                        await transaction.update(this.tableName, { spid: this.ctx.subProject.id }, { where: { id: filterTids } });
                        if (newFolderList.length > 0) await transaction.insert(this.ctx.service.paymentFolder.tableName, newFolderList);
                    }
                }
                // 权限也要迁移至本子项目
                const ppAudits = await this.ctx.service.paymentPermissionAudit.getAllDataByCondition({ where: { pid: this.ctx.session.sessionProject.id } });
                for (const audit of ppAudits) {
                    if (audit.uid) {
                        const spAudit = await this.ctx.service.subProjPermission.getDataByCondition({ spid: this.ctx.subProject.id, uid: audit.uid });
                        const payment_permission = [1];
                        const one_pp = audit.permission_json ? JSON.parse(audit.permission_json) : null;
                        if (one_pp) {
                            if (one_pp.admin) payment_permission.push(2);
                            if (one_pp.view_all) payment_permission.push(3);
                        }
                        const new_payment_permission = payment_permission.join(',');
                        console.log(spAudit, new_payment_permission);
                        if (spAudit && spAudit.payment_permission !== new_payment_permission) {
                            await transaction.update(this.ctx.service.subProjPermission.tableName, { id: spAudit.id, payment_permission: new_payment_permission });
                        } else if (!spAudit) {
                            const a = await this.ctx.service.projectAccount.getDataById(audit.uid);
                            if (a) {
                                const sp_permission = { id: this.uuid.v4(), spid: this.ctx.subProject.id, pid: this.ctx.session.sessionProject.id, uid: audit.uid, self_category_level: a.self_category_level, payment_permission: new_payment_permission };
                                await transaction.insert(this.ctx.service.subProjPermission.tableName, sp_permission);
                            }
                        }
                    }
                }
                await transaction.commit();
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
            return true;
        }
    }
    return paymentTender;
};