Calculation/app/service/stage_rela.js

'use strict';

/**
 *
 *
 * @author Mai
 * @date
 * @version
 */

const auditConst = require('../const/audit').stage;
const changeConst = require('../const/change');

module.exports = app => {
    class StageRela extends app.BaseService {
        /**
         * 构造函数
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        constructor(ctx) {
            super(ctx);
            this.tableName = 'stage_rela';
        }

        _analysisStageRela(data) {
            const datas = data instanceof Array ? data : [data];
            for (const d of datas) {
                d.cache_tp = d.cache_tp ? JSON.parse(d.cache_tp) : {};
                d.cache_org_tp = d.cache_org_tp ? JSON.parse(d.cache_org_tp) : {};
            }
        }

        async getStageRela(sid) {
            const result = await this.getAllDataByCondition({
                where: { sid },
                orders: [['add_time', 'asc']],
            });
            this._analysisStageRela(result);
            return result;
        }

        async getHistoryStageRela(tid, sorder) {
            const sql = 'SELECT * FROM ' + this.tableName + ' WHERE tid = ? And sorder < ? ORDER BY add_time desc';
            const result = await this.db.query(sql, [tid, sorder]);
            this._analysisStageRela(result);
            return result;
        }

        async getPreRelaStage(tid, sorder, rela_tid) {
            const sql = 'SELECT * FROM ' + this.tableName + ' WHERE tid = ? AND rela_tid = ? And sorder < ? ORDER BY sorder';
            return await this.db.queryOne(sql, [tid, rela_tid, sorder]);
        }

        async _getCacheOrgTp(stage) {
            const bg = await this.ctx.service.stageChange.getQualityTotalPrice(stage);
            const gcl100 = await this.ctx.service.stageBills.getSumTotalPriceGcl(stage, '^[^0-9]*1[0-9]{2}(-|$)');
            return {
                contract_tp: stage.contract_tp, qc_tp: stage.qc_tp,
                gather_tp: this.ctx.helper.add(stage.contract_tp, stage.qc_tp),
                gather_tp_100: this.ctx.helper.add(gcl100.contract_tp, gcl100.qc_tp),
                bg_common: bg.common, bg_more: bg.more, bg_great: bg.great,
            };
        }

        async _calculateRelaStage(stage, preRelaStage) {
            const result = {}, helper = this.ctx.helper, stageBills = [];
            const ledger = await this.ctx.service.ledger.getData(stage.tid);
            const curBillsData = await this.ctx.service.stageBills.getLastestStageData(stage.tid, stage.id);
            helper.assignRelaData(ledger, [
                { data: curBillsData, fields: ['contract_qty', 'contract_tp', 'qc_qty', 'qc_tp', 'postil'], prefix: '', relaId: 'lid' },
            ]);
            const dealBills = await this.ctx.service.dealBills.getAllDataByCondition({ where: { tender_id: this.ctx.stage.tid } });

            const gcl = {}, gcl100 = {}, gcl100reg = /^[^0-9]*1[0-9]{2}(-|$)/;
            for (const t of ledger) {
                const db = dealBills.find(x => {
                    return x.code === t.b_code && x.name === t.name && x.unit === t.unit;
                });
                t.unit_price = db ? db.unit_price : 0;
                if (t.contract_qty) t.contract_tp = helper.mul(t.unit_price, t.contract_qty, this.ctx.tender.info.decimal.tp);
                if (t.qc_qty) t.qc_tp = helper.mul(t.unit_price, t.qc_qty, this.ctx.tender.info.decimal.tp);
                gcl.contract_tp = helper.add(gcl.contract_tp, t.contract_tp);
                gcl.qc_tp = helper.add(gcl.qc_tp, t.qc_tp);
                if (gcl100reg.test(t.b_code)) {
                    gcl100.contract_tp = helper.add(gcl100.contract_tp, t.contract_tp);
                    gcl100.qc_tp = helper.add(gcl100.qc_tp, t.qc_tp);
                }
                if (t.contract_qty || t.contract_tp || t.qc_qty || t.qc_tp) {
                    stageBills.push({
                        tid: this.ctx.tender.id, sid: this.ctx.stage.id, sorder: this.ctx.stage.order,
                        rela_tid: stage.tid, rela_sid: stage.id, rela_sorder: stage.order,
                        lid: t.id, unit_price: t.unit_price,
                        contract_qty: t.contract_qty, contract_tp: t.contract_tp, contract_expr: t.contract_expr,
                        qc_qty: t.qc_qty, qc_tp: t.qc_tp,
                        postil: t.postil,
                    });
                }
            }
            result.contract_tp = gcl.contract_tp;
            result.qc_tp = gcl.qc_tp;
            result.gather_tp = helper.add(gcl.contract_tp, gcl.qc_tp);
            result.gather_tp_100 = helper.add(gcl100.contract_tp, gcl100.qc_tp);

            const sql = 'SELECT sc.*, c.quality, cb.code, cb.name, cb.unit FROM ' + this.ctx.service.stageChange.tableName + ' sc' +
                '  LEFT JOIN ' + this.ctx.service.change.tableName + ' c ON sc.cid = c.cid' +
                '  LEFT JOIN ' + this.ctx.service.changeAuditList.tableName + ' cb ON sc.cbid = cb.id' +
                '  WHERE sid = ?';
            const data = await this.db.query(sql, [stage.id]);
            const bqData = [];
            for (const d of data) {
                if (!d.qty) continue;
                let bd = bqData.find(x => { return x.lid === d.lid && x.quality === d.quality; });
                if (!bd) {
                    const bills = dealBills.find(x => {
                        return x.code === d.code && x.name === d.name && x.unit === d.unit;
                    });
                    if (!bills) continue;
                    bd = { lid: d.lid, quality: d.quality, unit_price: bills.unit_price };
                    bqData.push(bd);
                }
                const tp = this.ctx.helper.mul(d.qty, bd.unit_price, tender.info.decimal.tp);
                bd.tp = this.ctx.helper.add(bd.tp, tp);
            }
            result.bg_common = helper.sum(helper._.map(bqData.filter(x => {return x.quality === changeConst.quality.common.value; }), 'tp'));
            result.bg_more = helper.sum(helper._.map(bqData.filter(x => {return x.quality === changeConst.quality.more.value; }), 'tp'));
            result.bg_great = helper.sum(helper._.map(bqData.filter(x => {return x.quality === changeConst.quality.great.value; }), 'tp'));

            const stageBillsFinal = [];
            const preStageBills = preRelaStage
                ? this.ctx.service.stageRelaBillsFinal.getAllDataByCondition({ where: { sid: preRelaStage.sid, rela_tid: preRelaStage.rela_tid } })
                : [];
            for (const b of stageBills) {
                const p = preStageBills.find(x => { return x.lid === b.lid });
                stageBillsFinal.push({
                    tid: this.ctx.tender.id, sid: this.ctx.stage.id, sorder: this.ctx.stage.order,
                    rela_tid: stage.tid, rela_sid: stage.id, rela_sorder: stage.order,
                    lid: b.lid,
                    contract_qty: p ? helper.add(p.contract_qty, b.contract_qty) : b.contract_qty,
                    contract_tp: p ? helper.add(p.contract_tp, b.contract_tp) : b.contract_tp,
                    qc_qty: p ? helper.add(p.qc_qty, b.qc_qty) : b.qc_qty,
                    qc_tp: p ? helper.add(p.qc_tp, b.qc_tp) : b.qc_tp,
                });
                if (p) preStageBills.splice(preStageBills.indexOf(p), 1);
            }
            for (const p of preStageBills) {
                stageBillsFinal.push({
                    tid: this.ctx.tender.id, sid: this.ctx.stage.id, sorder: this.ctx.stage.order,
                    rela_tid: stage.tid, rela_sid: stage.id, rela_sorder: stage.order,
                    lid: b.lid,
                    contract_qty: p.contract_qty, contract_tp: p.contract_tp,
                    qc_qty: p.qc_qty, qc_tp: p.qc_tp,
                });
            }
            return [result, stageBills, stageBillsFinal];
        }

        async calculateRelaStage(relaStage) {
            const preRelaStage = await this.getPreRelaStage(this.ctx.tender.id, this.ctx.stage.order, relaStage.tid);
            const cache_org_tp = await this._getCacheOrgTp(relaStage);
            const [cache_tp, stageBills, stageBillsFinal] = await this._calculateRelaStage(relaStage, preRelaStage);
            return { cache_tp, cache_org_tp, stageBills, stageBillsFinal }
        }

        async addStageRela(relaStage) {
            const addTime = new Date();
            const tender = await this.ctx.service.tender.getDataById(relaStage.tid);
            if (!tender) throw '关联标段不存在';
            const conn = await this.db.beginTransaction();
            try {
                const result = await this.calculateRelaStage(relaStage);
                const data = {
                    tid: this.ctx.tender.id,
                    sid: this.ctx.stage.id, sorder: this.ctx.stage.order,
                    rela_tid: relaStage.tid, rela_sid: relaStage.id, rela_sorder: relaStage.order, rela_tname: tender.name,
                    add_time: addTime, update_time: addTime,
                    cache_tp: JSON.stringify(result.cache_tp), cache_org_tp: JSON.stringify(result.cache_org_tp),
                };
                await conn.insert(this.tableName, data);
                if (result.stageBills.length > 0) await conn.insert(this.ctx.service.stageRelaBills.tableName, result.stageBills);
                if (result.stageBillsFinal.length > 0) await conn.insert(this.ctx.service.stageRelaBillsFinal.tableName, result.stageBillsFinal);
                await conn.update(this.ctx.service.stage.tableName, { id: this.ctx.stage.id, check_calc: 1 });
                await conn.commit();
            } catch (err) {
                await conn.rollback();
                throw err;
            }
        }

        async deleteStageRela(id) {
            const rela = await this.getDataById(id);
            if (!rela) throw '关联标段不存在';
            const conn = await this.db.beginTransaction();
            try {
                await conn.delete(this.tableName, { id: rela.id });
                await conn.delete(this.ctx.service.stageRelaBills.tableName, {sid: rela.sid, rela_tid: rela.rela_tid});
                await conn.delete(this.ctx.service.stageRelaBillsFinal.tableName, {sid: rela.sid, rela_tid: rela.rela_tid});
                await conn.update(this.ctx.service.stage.tableName, { id: this.ctx.stage.id, check_calc: 1 });
                await conn.commit();
            } catch (err) {
                await conn.rollback();
                throw err;
            }
        }

        async updateStageRela(id) {
            const rela = await this.getDataById(id);
            const relaStage = await this.ctx.service.stage.getDataById(rela.rela_sid);
            const conn = await this.db.beginTransaction();
            try {
                const result = await this.calculateRelaStage(relaStage);
                await conn.update(this.tableName, {
                    id: rela.id, update_time: new Date(),
                    cache_tp: JSON.stringify(result.cache_tp), cache_org_tp: JSON.stringify(result.cache_org_tp)
                });

                await conn.delete(this.ctx.service.stageRelaBills.tableName, {sid: rela.sid, rela_tid: rela.rela_tid});
                if (result.stageBills.length > 0) await conn.insert(this.ctx.service.stageRelaBills.tableName, result.stageBills);

                await conn.delete(this.ctx.service.stageRelaBillsFinal.tableName, {sid: rela.sid, rela_tid: rela.rela_tid});
                if (result.stageBillsFinal.length > 0) await conn.insert(this.ctx.service.stageRelaBillsFinal.tableName, result.stageBillsFinal);

                await conn.update(this.ctx.service.stage.tableName, { id: this.ctx.stage.id, check_calc: 1 });
                await conn.commit();
            } catch (err) {
                await conn.rollback();
                throw err;
            }
        }

        async getSumCacheTp (sid) {
            const result = {};
            const relas = await this.getAllDataByCondition({ where: { sid } });
            if (relas.length === 0) return result;

            this._analysisStageRela(relas);
            for (const r of relas) {
                result.contract_tp = this.ctx.helper.add(result.contract_tp, r.cache_tp.contract_tp);
                result.qc_tp = this.ctx.helper.add(result.qc_tp, r.cache_tp.qc_tp);
                result.gather_tp = this.ctx.helper.add(result.gather_tp, r.cache_tp.gather_tp);
                result.gather_tp_100 = this.ctx.helper.add(result.gather_tp_100, r.cache_tp.gather_tp_100);
                result.bg_common = this.ctx.helper.add(result.bg_common, r.cache_tp.bg_common);
                result.bg_more = this.ctx.helper.add(result.bg_more, r.cache_tp.bg_more);
                result.bg_great = this.ctx.helper.add(result.bg_more, r.cache_tp.bg_more);
            }
            return result;
        }
    }

    return StageRela;
};