Calculation/app/service/contract_pay.js

'use strict';

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

const BaseService = require('../base/base_service');
const contractConst = require('../const/contract');
const auditConst = require('../const/audit').contract;
const auditType = require('../const/audit').auditType;

module.exports = app => {

    class ContractPay extends BaseService {

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

        async getPays(options, cid) {
            const sql = 'SELECT * FROM ?? WHERE ' + this.ctx.helper._getOptionsSql(options) + ' AND `cid` = ? ORDER BY `create_time` DESC';
            const sqlParams = [this.tableName, cid];
            const list = await this.db.query(sql, sqlParams);
            const pay_shenpi_status = this.ctx.contract_tender ? this.ctx.subProject.page_show.openContractPayTenderShenpi : this.ctx.subProject.page_show.openContractPaySubProjectShenpi;
            if (list.length > 0) {
                const userList = await this.ctx.service.projectAccount.getAllDataByCondition({ where: { id: list.map(item => item.uid) } });
                for (const l of list) {
                    const userInfo = userList.find(item => item.id === l.uid);
                    l.username = userInfo ? userInfo.name : '';
                    l.files = await this.ctx.service.contractPayAtt.getAtt(l.id);
                    if (pay_shenpi_status) {
                        await this.ctx.service.contractSpAudit.loadUser(l);
                        await this.ctx.service.contractSpAudit.loadAuditViewData(l);
                        await this.ctx.service.contractSpAudit.checkShenpi(l);
                        if (l.status !== auditConst.status.checked || !l.final_auditor_str) {
                            l.curAuditors2 = await this.ctx.service.contractSpAudit.getAuditorsByStatus(l.cid, l.id, l.status, l.times);
                            if (l.status === auditConst.status.checked && !l.final_auditor_str) {
                                const final_auditor_str = l.curAuditors2[0].audit_type === auditType.key.common
                                    ? l.curAuditors2[0].name + (l.curAuditors2[0].role ? '-' + l.curAuditors2[0].role : '')
                                    : this.ctx.helper.transFormToChinese(l.curAuditors2[0].audit_order) + '审';
                                await this.defaultUpdate({ final_auditor_str, id: l.id });
                                l.final_auditor_str = final_auditor_str;
                            }
                        }
                    }
                }
            }
            return list;
        }

        async add(options, cid, data) {
            const node = await this.ctx.service.contract.getDataById(cid);
            if (!node) {
                throw '合同不存在';
            }
            const transaction = await this.db.beginTransaction();
            try {
                const insertData = {
                    spid: options.spid || null,
                    tid: options.tid || null,
                    contract_type: options.contract_type,
                    cid,
                    uid: this.ctx.session.sessionUser.accountId,
                    pay_time: data.pay_time,
                    used: data.used || '合同',
                    pay_price: data.pay_price,
                    debit_price: data.debit_price,
                    yf_price: data.yf_price,
                    sf_price: data.sf_price,
                    pay_type: data.pay_type,
                    remark: data.remark,
                    create_time: new Date(),
                    need_shenpi: options.spid ? this.ctx.subProject.page_show.openContractPaySubProjectShenpi : this.ctx.subProject.page_show.openContractPayTenderShenpi,
                };
                await transaction.insert(this.tableName, insertData);
                await this.calcContract(transaction, node);
                await transaction.commit();
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
            return { pays: await this.getPays(options, cid), node: { update: node } };
        }

        async save(options, cid, data) {
            if (!data.id) {
                throw '参数有误';
            }
            const node = await this.ctx.service.contract.getDataById(cid);
            if (!node) {
                throw '合同不存在';
            }
            const cpInfo = await this.getDataById(data.id);
            if (!cpInfo) {
                throw '合同' + contractConst.typeName[cpInfo.contract_type] + '不存在';
            }
            const transaction = await this.db.beginTransaction();
            try {
                await transaction.update(this.tableName, data);
                await this.calcContract(transaction, node);
                await transaction.commit();
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
            return { pays: await this.getPays(options, cid), node: { update: node } };
        }

        async del(options, cid, cpid) {
            if (!cpid) {
                throw '参数有误';
            }
            const node = await this.ctx.service.contract.getDataById(cid);
            if (!node) {
                throw '合同不存在';
            }
            const cpInfo = await this.getDataById(cpid);
            if (!cpInfo) {
                throw '合同' + contractConst.typeName[cpInfo.contract_type] + '不存在';
            }
            if (cpInfo.fpcid) {
                throw '该合同' + contractConst.typeName[cpInfo.contract_type] + '关联了资金支付明细，不能删除';
            }
            const transaction = await this.db.beginTransaction();
            try {
                await transaction.delete(this.tableName, { id: cpid });
                // 删除合同附件
                const attList = await this.ctx.service.contractPayAtt.getAllDataByCondition({ where: { cpid } });
                await this.ctx.helper.delFiles(attList);
                await transaction.delete(this.ctx.service.contractPayAtt.tableName, { cpid });
                await transaction.delete(this.ctx.service.contractSpAudit.tableName, { cpid });
                await this.calcContract(transaction, node);
                await transaction.commit();
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
            return { pays: await this.getPays(options, cid), node: { update: node } };
        }

        async calcContract(transaction, node) {
            const paysList = await transaction.query('SELECT * FROM ?? WHERE `cid` = ?', [this.tableName, node.id]);
            let pay_price = 0;
            let debit_price = 0;
            let yf_price = 0;
            let sf_price = 0;
            for (const l of paysList) {
                pay_price = this.ctx.helper.add(pay_price, l.pay_price);
                debit_price = this.ctx.helper.add(debit_price, l.debit_price);
                yf_price = this.ctx.helper.add(yf_price, l.yf_price);
                sf_price = this.ctx.helper.add(sf_price, l.sf_price);
            }
            node.pay_price = pay_price;
            node.debit_price = debit_price;
            node.yf_price = yf_price;
            node.sf_price = sf_price;
            node.exist_pay = paysList.length === 0 ? 0 : 1;
            await transaction.update(this.ctx.service.contract.tableName, node);
        }

        async createContractPays(transaction, fpid, uid, times, pays) {
            const addPays = [];
            const contracts = await transaction.select(this.ctx.service.contract.tableName, { where: { id: this._.uniq(this._.map(pays, 'cid')) } });
            for (const p of pays) {
                const contract = contracts.find(c => c.id === p.cid);
                if (contract) {
                    addPays.push({
                        spid: contract.spid || null,
                        tid: contract.tid || null,
                        contract_type: contract.contract_type,
                        cid: p.cid,
                        uid,
                        fpid,
                        fpcid: p.id,
                        pay_time: times,
                        used: p.used || '合同',
                        pay_price: p.pay_price || 0,
                        debit_price: 0,
                        yf_price: p.pay_price || 0,
                        sf_price: p.settle_price || 0,
                        pay_type: p.pay_type || '',
                        remark: '',
                        create_time: times,
                    });
                }
            }
            if (addPays.length > 0) {
                await transaction.insert(this.tableName, addPays);
                for (const c of contracts) {
                    await this.calcContract(transaction, c);
                }
                const commonJson = this.ctx.subProject.common_json ? JSON.parse(this.ctx.subProject.common_json) : {};
                const used = commonJson && commonJson.tender_contract_used ? commonJson.tender_contract_used : [];
                const addUsed = this._.uniq(this._.map(pays, 'used'));
                // 还要判断里面有叫"合同"的值，如果有则去除
                const index = addUsed.indexOf('合同');
                if (index > -1) {
                    addUsed.splice(index, 1);
                }
                // 判断addUsed和used对比是否有新增的值，如果有则更新分项目的common_json
                if (this._.difference(addUsed, used).length > 0) {
                    const newUsed = this._.uniq([...used, ...addUsed]);
                    commonJson.tender_contract_used = newUsed;
                    await transaction.update(this.ctx.service.subProject.tableName, { id: this.ctx.subProject.id, common_json: JSON.stringify(commonJson) });
                }
            }
        }

        async removeContractPays(transaction, fpid, pays) {
            await transaction.delete(this.tableName, { fpid });
            const contracts = await transaction.select(this.ctx.service.contract.tableName, { where: { id: this._.uniq(this._.map(pays, 'cid')) } });
            if (contracts.length > 0) {
                for (const c of contracts) {
                    await this.calcContract(transaction, c);
                }
            }
        }
    }
    return ContractPay;
};